import bpy
import time
from math import cos
import ast
import os
import ctypes
 
'''
Código rodado em background que transforama dados do corsika modelos 3d de curvas,
a animação das curvas são salvar em formato png utilizando o comando:

para transformar em mp4 pode-se usar (no linux) ffmpeg:


blender -b -P blender_visu_script.py -o /home/bruno/Desktop/rend/img###.png -a

cat *.png | ffmpeg -f image2pipe -r 30 -i - output.mp4 -y

rm *.png

'''

# ARGUMENTOS

arquivos_nome = ["EDrezultate2",] # nome txt com dados
limite = -1
# limite = (4 + 1) * 100 # -1 para ler todos os dados dos arquivos

## cc -fPIC -shared -o mesma.exe mesmalinha.c

_file = "mesma.exe"
_path = os.path.join(*(os.path.split(os.getcwd()) + (_file, )))
_mod = ctypes.cdll.LoadLibrary(_path)

_mesma = _mod.mesmalinhac
_mesma.argtypes = (ctypes.c_int,)
_mesma.restype = ctypes.c_double

def mesmalinhac(values1):
    return (_mesma(len(values1)))

def make_curve(points,loop2):
    '''
    Funcao que cria curva no blender
    '''
    # create the Curve Datablock

    curveData = bpy.data.curves.new(f'myCurve{loop2}', type='CURVE')
    curveData.dimensions = '3D'
    curveData.resolution_u = 4

    # map coords to spline
    polyline = curveData.splines.new('POLY')
    polyline.points.add(len(points)-1)
    for i, coord in enumerate(points):
        x,y,z = coord
        polyline.points[i].co = (x, y, z, 1)

    # create Object
    curveOB = bpy.data.objects.new(f'myCurve{loop2}', curveData)
    curveData.bevel_resolution = 6
    curveData.bevel_depth = 0.001667


    # attach to scene and validate context
    scn = bpy.context.scene
    scn.collection.objects.link(curveOB)

    bpy.ops.object.shade_smooth()

def remove_materials_objects():
    '''
    Função que remove todos materiais, objetos e curvas
    '''

    for material in bpy.data.materials: #remove materiais existentes
        bpy.data.materials.remove(material)
    
    for object in bpy.data.objects: # remove todos objetos
        bpy.data.objects.remove(object)
    
    for curva in bpy.data.curves: # remove todas curvas
        bpy.data.curves.remove(curva)    

def create_material(loop):
    '''
    Função que cria novo material

    Argumento loop representa o arquivo que está sendo usado
    '''
    bpy.data.materials.new(name="base"+f'{loop}') # cria material
    mat = bpy.data.materials[f'base{loop}'] # seleciona material criado
    
    mat.use_nodes = True
    Princi = mat.node_tree.nodes['Principled BSDF'] # nodo Principled BSDF
    
    if loop == 0: # primeiro arquivo cor vermelha
        Princi.inputs['Base Color'].default_value = (1.0, 0.028571, 0.021429, 0.4) # R G B Alpha
    elif loop == 1: # segundo arquivo cor verde
        Princi.inputs['Base Color'].default_value = (0.028571, 1, 0.021429, 0.4) # R G B Alpha
    elif loop == 2: # terceiro arquivo cor azul
        Princi.inputs['Base Color'].default_value = (0.028571, 0.021429, 1, 0.4) # R G B Alpha
    else: # mais arquivos tem a cor decidida por cos()
        Princi.inputs['Base Color'].default_value = (cos(loop*3.14), 1/cos(loop*3.14), cos(loop*3.14*2), 0.4) # R G B Alpha

    Princi.inputs['Roughness'].default_value = 0.445455
    Princi.inputs['Specular'].default_value = 0.08636365830898285

def insert_material(loop,loop2):
    '''
    Função que insere o material loop na curva loop2
    '''
    mat = bpy.data.materials['base'+f'{loop}']
    curva = bpy.data.objects[f'myCurve{loop2}']
    
    curva.data.materials.append(mat)

def anima(t_i,t_f,loop2):
    '''
    Função responsável pela animação da curva, utiliza somente o tempo final e inicial da curva
    '''
    if(t_i>t_f): #caso esteja trocado
        d= t_f
        t_f= t_i
        t_i= d
    scene = bpy.context.scene
    curva = bpy.data.curves[f'myCurve{loop2}'] 
    
    scene.frame_set(t_f)

    curva.keyframe_insert(data_path='bevel_factor_end')
    
    scene.frame_set(t_i)
    curva.bevel_factor_end = 0
    curva.keyframe_insert(data_path='bevel_factor_end')
    curva.animation_data.action.fcurves[0].keyframe_points[0].interpolation = 'LINEAR'
    curva.bevel_factor_mapping_end = 'SPLINE'     

def curva(dados):
    '''
    Funcao que retorna os dados separados em diferentes curvas.
    '''
    x=[]
    y=[]

    xend=[]
    yend=[]

    dados_new=[]
    for linha in dados:
        ligne=linha.replace('\n','')
        l=ligne.split(' ')
        # print(l)
        dados_new.append(l)

        x.append(float(l[2])/1000000)
        xend.append(float(l[6])/1000000)

        y.append(float(l[3])/1000000)
        yend.append(float(l[7])/1000000)

    xif = inif(x,xend) # [inicial,final]
    yif = inif(y,yend) # [inicial,final]

    mesmax = mesmalinha(xif)
    mesmay = mesmalinha(yif)

    print(mesmax)

    mesma = (mesmax, mesmay)
    todas_curvas_x = []
    todas_curvas_y = []
    for loop,dado in enumerate(mesma):    
        for linha in dado: #colocar em função
            indexes = []
            for j in range (0,len(linha)):
                if loop == 0:
                    indexes.append(x.index(linha[j][0]))
                else:
                    indexes.append(y.index(linha[j][0]))        

            dados_salvar=[]
            for g in range (0,len(linha)):
                dados_salvar.append(dados_new[indexes[g]])
                
            if loop ==0:
                todas_curvas_x.append(dados_salvar)
            else:
                todas_curvas_y.append(dados_salvar)
    
    if todas_curvas_x < todas_curvas_y:
        maior_curva = todas_curvas_y.copy()
        menor_curva = todas_curvas_x.copy()
    else:
        maior_curva = todas_curvas_x.copy()
        menor_curva = todas_curvas_y.copy()
    
    todas_curvas = []
    for dado in maior_curva:
        if dado in menor_curva:
            todas_curvas.append(dado)   
    return(todas_curvas)

def mesmalinha(inicial_final):
    '''
    Função que encontra pontos iguais nos dados para serem
    classificados como sendo da mesma curva. Também detecta 
    bifurcação da linha, fazendo as duas linhas serem curvas
    diferentes, evitando erros. 
    
    inicial_final = [x,xend]
    '''

    print(f"\n\n\nOIII\n\n\n")
    iniciais =[f[0] for f in inicial_final]
    finais = [f[1] for f in inicial_final]

    # SALVAR EM UM ARQUIVO PARA O C LER
    fl = open("data.txt","w")
    for i in range(len(iniciais)):
        fl.writelines(f"{str(iniciais[i])} {str(finais[i])}\n")
    fl.close()
    
    # n = 200
    # iniciais = list(range(1,n+1))
    # finais = list(range(2,n+2))
    print("try")
    mesmalinhac(iniciais) 
    print("\nFOI\n")

    file = open("dados_out.txt")
    tr= file.read()
    file.close()
    tr= tr.replace("],]","]]")
    tr= tr.replace("],]","]]")
      
    # Converting string to list
    linhas = ast.literal_eval(tr)

    return(linhas)

def inif(li,lf):
    '''
    Funcao que organiza os dados em [inicial,final]
    '''
    tu=[]
    for i in range(0,len(li)):
        tu.append([li[i],lf[i]])
    return(tu)

##                  
## CODIGO PRINCIPAL 
##                  

start_time= time.time()

remove_materials_objects()

loop2 = 0
last_frame = 0 #para encontrar o ultimo frame
for loop,arquivo_nome in enumerate(arquivos_nome):

    arquivo = open(arquivo_nome,'r')
    tabraw = arquivo.readlines(limite)
    arquivo.close()

    dados_curvas = curva(tabraw)
    
    create_material(loop)
    
    # LOOP PRINCIPAL
    for curve in dados_curvas:

        loop2 += 1
        pontos =[]        
        for count,l in enumerate(curve):
            
            # print(f"{count/len(curve)*100}% linha: {l}") # O quanto foi feito 
    
            x=float(l[2])/1000000
            y=float(l[3])/1000000 
            z=float(l[4])/1000000
            tini=float(l[5])*1000000
            xend=float(l[6])/1000000 
            yend=float(l[7])/1000000 
            zend=float(l[8])/1000000 
            tend=float(l[9])*1000000 

            pontos.append((x,y,z))

            if count == 0:
                tempo_inicial = int(tini)
            tempo_final = int(tend)
            
            if tempo_inicial == tempo_final:
                tempo_final = tempo_inicial + 1
            
        make_curve(pontos,loop2)

        # manejo materiais
        insert_material(loop,loop2)    

        anima(tempo_inicial, tempo_final,loop2) 

        if tempo_final > last_frame: #encontrando ultimo frame
            last_frame = tempo_final

bpy.context.scene.frame_current = 0 # retorna para frame inicial 

# luz
bpy.ops.object.light_add(type='SUN', align='WORLD', location=(0, -5.04, 4.6), rotation=(1.05418, 0, 0), scale=(1, 1, 1))

##camera
bpy.ops.object.camera_add(enter_editmode=False, align='VIEW', location=(-1.7681, -5.40785, 1.12727), rotation=(87.3975/57.3, 0, -12.974/57.3))

bpy.context.scene.render.resolution_x = 1080
bpy.context.scene.render.resolution_y = 1920

bpy.data.objects['Camera'].select_set(True)

bpy.data.scenes[0].camera = bpy.data.objects['Camera']

# render
bpy.data.worlds["World"].node_tree.nodes["Background"].inputs[0].default_value = (0.8, 0.8, 0.8, 1) #background escuro

bpy.context.scene.frame_end = last_frame + 10
bpy.context.scene.eevee.use_bloom = True
bpy.context.scene.eevee.use_gtao = True
bpy.context.scene.eevee.use_ssr = True
bpy.context.scene.eevee.use_motion_blur = True

#save
bpy.ops.wm.save_mainfile() # salva como untitled.blend
print(f"frame final: {last_frame}")
print('Levou {} minutos'.format((time.time() - start_time)/60))