# -*- coding: iso-8859-15 -*-
import Tkinter as tk
from PTE import *
from pylab import *
from layers import *
from numpy import zeros
import os
import tkFileDialog
import shutil
import sys

##############################################################################
# Control variables and lists
Edict = dict()
Ebuttons = list()
Labentrys = list()
Frames = list()
i = 0
Econtrol = 0

##############################################################################
# Element callback
def elem_callback(x, edict , ebutton):
    global Labentrys
    PTable(edict[x] , ebutton[x], Labentrys)

##############################################################################
# Element selection
def elem_select(i, button):

    global Econtrol, Edict, Labentrys
    button[Econtrol]['relief']='raised'
    Econtrol = i
    button[i]['relief']='sunken'

    Labentrys[0].configure(text = '%s' %Edict[i]['name'])
    Labentrys[1].configure(text = 'Mass - %f' %Edict[i]['mass'])
    Labentrys[2].configure(text = 'Z - %f' %Edict[i]['Z'])
    Labentrys[3].configure(text = 'Symbol - %s' %Edict[i]['symbol'])
    Labentrys[4].configure(text = 'Line Shape α - %f' %Edict[i]['LineShape'])
    Labentrys[5].configure(text = 'Max Depht - %f' %Edict[i]['profundidademax'])

    for i in arange(6,12):
        Labentrys[i].delete (0, "end")

    Labentrys[6].insert(0, Edict[int(Econtrol)]['name'])
    Labentrys[7].insert(0, Edict[int(Econtrol)]['mass'])
    Labentrys[8].insert(0, int(Edict[int(Econtrol)]['Z']))
    Labentrys[9].insert(0, Edict[int(Econtrol)]['symbol'])
    Labentrys[10].insert(0, Edict[int(Econtrol)]['LineShape'])
    Labentrys[11].insert(0, Edict[int(Econtrol)]['profundidademax'])

##############################################################################
# Init
def ewin_build(window, OFlabentries, mainwindow, calcbutton, distvar, modevar, Labelframe):

##############################################################################
# Element addition
    def create():
        global i, Edict, Ebuttons
        Edict[i]=dict(name="New Element",symbol="Hf",mass=178.,Z=72,dist=zeros(int(10./float(OFlabentries[17].get()))),LineShape=200.,profundidademax=10.)
        Ebuttons.insert(i, tk.Button(Eframe, text=i, width=1, height=1, command = lambda i=i : elem_select(i,Ebuttons)) )
        Ebuttons[i].grid(column = ((len(Ebuttons)-1)%13), row = int(math.floor((len(Ebuttons)-1)/13)))
        i = i+1

##############################################################################
# Element deletion
    def remove():
        global i, Edict, Ebuttons, Econtrol
        if i > 1:
            i = i-1
            del Edict[i]
            Ebuttons[i].destroy()
            del Ebuttons[i]
            if Econtrol == i:
                Econtrol = Econtrol -1
                Ebuttons[Econtrol]['relief']='sunken'
        elem_select(0, Ebuttons)

##############################################################################
# Element Frames

    Labelprop = tk.LabelFrame(window, text = 'Properties', relief='raised', bd=2)
    Labelprop.pack(side = 'top')
    Label1 = tk.LabelFrame(window, text = 'Elements', relief='raised', bd=2)
    Label1.pack(side = 'top') 
    # For Button Creation
    Eframe = tk.Canvas(Label1)
    Eframe.pack(fill='both',expand=0)

##############################################################################
# Init
    create()
    
##############################################################################
# Properties

    global Econtrol, Edict, Labentrys
    def update(i):
        Edict[i]['name'] = str(Labentrys[6].get())
        Labentrys[0].configure(text = '%s' %Edict[i]['name'])
        Edict[i]['mass'] = float(Labentrys[7].get())
        Labentrys[1].configure(text = 'Mass - %f' %Edict[i]['mass'])
        Edict[i]['Z'] = float(Labentrys[8].get())
        Labentrys[2].configure(text = 'Z - %f' %Edict[i]['Z'])
        Edict[i]['symbol'] = str(Labentrys[9].get())
        Labentrys[3].configure(text = 'Symbol - %s' %Edict[i]['symbol'])
        Edict[i]['LineShape'] = float(Labentrys[10].get())
        Labentrys[4].configure(text = 'Line Shape α - %f' %Edict[i]['LineShape'])
        Edict[i]['profundidademax'] = float(Labentrys[11].get())
        Labentrys[5].configure(text = 'Max Depht - %f' %Edict[i]['profundidademax'])
        Edict[i]['dist'] = np.loadtxt(Edict[i]['symbol']+".prof")

    for i in range(3):
        Frames.insert(i, tk.Frame(Labelprop) )

    Frames[0].pack(side='left')
    Frames[1].pack(side='top')
    Frames[2].pack(side='right')

    for i in arange(3, 5):
        Frames.insert(i, tk.Frame(Frames[0]) )

    Frames[3].pack(side='left')
    Frames[4].pack(side='right')

    for i in arange(5, 7):
        Frames.insert(i, tk.Frame(Frames[1]) )

    Frames[5].pack(side='left')
    Frames[6].pack(side='right')
    Labeldist = tk.LabelFrame(Frames[5], text = 'Distribution', relief='raised', bd=2)
    Labeldist.pack(side = 'bottom') 
    Frames.insert(7, tk.Frame(Labeldist) )
    Frames[7].pack(side='top')

    # Label // Entries numbers:
    # 0 // 6 = Name
    # 1 // 7 = Mass
    # 2 // 8 = Z (Atomic number)
    # 3 // 9 = Symbol
    # 4 // 10 = Line shape
    # 5 // 11 = Max Depht
    ## 13 // 12 = Resonance energy (For RNA only)
    Labentrys.insert(0, tk.Label(Frames[3], width=23, pady=2, text='%s' %Edict[int(Econtrol)]['name']) )
    Labentrys.insert(1, tk.Label(Frames[3], width=23, pady=2, text='Mass - %f' %Edict[int(Econtrol)]['mass']) )
    Labentrys.insert(2, tk.Label(Frames[3], width=23, pady=2, text='Z - %f' %Edict[int(Econtrol)]['Z']) )
    Labentrys.insert(3, tk.Label(Frames[3], width=23, pady=2, text= 'Symbol - %s' %Edict[int(Econtrol)]['symbol']) )
    Labentrys.insert(4, tk.Label(Frames[3], width=23, pady=2, text='Line Shape α - %f' %Edict[int(Econtrol)]['LineShape']) )
    Labentrys.insert(5, tk.Label(Frames[3], width=23, pady=2, text='Max Depht - %f' %Edict[int(Econtrol)]['profundidademax']) )

    for i in arange(6, 13):
        Labentrys.insert(i, tk.Entry(Frames[4], width=17) )

    Labentrys.insert(13, tk.Label(Frames[3], width=23, pady=2, text='Resonance energy') )

    for i in range(14):
        Labentrys[i].pack()

    # Declaration of interpolation and distribution method variables
    methodvar = tk.StringVar()
    methodvar.set('reta')


##############################################################################
# Load/Save sample
    def LOADSAMPLE():
        global i, Econtrol
        arquivo = tkFileDialog.askopenfile()
        for n in arange(9,18):
            OFlabentries[n].delete(0,len(OFlabentries[n].get()))
            OFlabentries[n].insert(0,float(arquivo.readline()))
        for n in arange(21,24):
            OFlabentries[n].delete(0,len(OFlabentries[n].get()))
            OFlabentries[n].insert(0,float(arquivo.readline()))
        f = loadtxt(arquivo.name + '.elm', dtype="string")
        els = f[:, 0]
        eln = f[:, 1]
        elm = f[:, 2]
        elz = f[:, 3]
        LSs = f[:, 4]
        eld = f[:, 5]
        Edict.clear()
        for n in range(len(Ebuttons)):
            Ebuttons[n].destroy()
        del Ebuttons[:]
        i = 0
        Econtrol = 0
        for n in range(len(els)):
            create()           
            Edict[n]['LineShape'] = float(LSs[n])
            Edict[n]['symbol'] = str(els[n])
            Edict[n]['name'] = str(eln[n])
            Edict[n]['mass'] = float(elm[n])
            Edict[n]['Z'] = float(elz[n])
            Edict[n]['profundidademax'] = float(eld[n])
            Ebuttons[n]['text'] = str(els[n])
            shutil.copy(arquivo.name + '-' + Edict[n]['symbol'] + '.dat' , Edict[n]['symbol']+'.dat')
            shutil.copy(arquivo.name + '-' + Edict[n]['symbol'] + '.prof' , Edict[n]['symbol']+'.prof')
        elem_select(0,Ebuttons)
        arquivo.close()

    def SAVESAMPLE():
        config = tkFileDialog.asksaveasfile(mode='w')
        elist = open(config.name + '.elm', 'w+')
        for k in arange(9,18):
            config.write( (OFlabentries[k].get())+'\n' )
        for j in arange(21,24):
            config.write( (OFlabentries[j].get())+'\n' )
        config.write( '##############################################################################\n' )
        config.write( '# dƐ/dx\n# dω²/dx\n# θ out\n# θ in\n# FWHM\n# E min\n# E max\n# E step\n# Depth step\n# Ion energy\n# Ion mass\n# Ion Z\n' )
        for n in range(len(Edict)):
            elist.write(Edict[n]['symbol']+' ')
            elist.write(Edict[n]['name']+' ')
            elist.write(str(Edict[n]['mass'])+' ')
            elist.write(str(Edict[n]['Z'])+' ')
            elist.write(str(Edict[n]['LineShape'])+' ')
            elist.write(str(Edict[n]['profundidademax'])+'\n')
            shutil.copy(Edict[n]['symbol']+'.prof', config.name  + '-' + Edict[n]['symbol'] + '.prof')
            shutil.copy(Edict[n]['symbol']+'.dat', config.name  + '-' + Edict[n]['symbol'] + '.dat')
            shutil.copy('temp.sim', config.name  + '.sim')
        elist.close()
        config.close()

##############################################################################
# Menu
    def donothing():
        return 0

    menubar = tk.Menu(mainwindow, bg='grey', relief='flat', bd=0)
    filemenu = tk.Menu(menubar, tearoff=0)
    filemenu.add_command(label="Simulate", command=lambda i=int(Econtrol) :calcbutton.invoke())
    filemenu.add_separator()
    filemenu.add_command(label="Exit", command=sys.exit)
    menubar.add_cascade(label="File", menu=filemenu)

    samplemenu = tk.Menu(menubar, tearoff=0)
    samplemenu.add_command(label="Load Sample", command=lambda i=int(Econtrol) :LOADSAMPLE())
    samplemenu.add_command(label="Save Sample", command=lambda i=int(Econtrol) :SAVESAMPLE())
    menubar.add_cascade(label="Samples", menu=samplemenu)

    helpmenu = tk.Menu(menubar, tearoff=0)
    helpmenu.add_command(label="Help!", command=donothing)
    helpmenu.add_command(label="About...", command=donothing)
    menubar.add_cascade(label="Help", menu=helpmenu)
    mainwindow.config(menu=menubar)

##############################################################################
# Buttons

    but = tk.Button(Frames[3], command=create, text='Add element', bd=1, height=1,width=15, pady='4')
    but.pack()
    butrmv = tk.Button(Frames[4], command=remove, text='Remove element', bd=1, height=1,width=14, pady='4')
    butrmv.pack()
    butPTE = tk.Button(Frames[5], text='Select from PTE', bd=1, width=15, command=lambda i=i :elem_callback(Econtrol,Edict,Ebuttons) )
    butPTE.pack()
    BUpdate = tk.Button(Frames[5], text ='Update properties', command=lambda i=int(Econtrol) :update(Econtrol), width=15)
    BUpdate.pack()

##############################################################################
# Distribution
 
    def changestate():
        if str(distvar.get()) == 'layer':
            BLayer['state']='normal'
            BUpdateD['state']='disabled'
            RS['state']='disabled'
            RL['state']='disabled'
            OFlabentries[9]['state']='disabled'
            OFlabentries[10]['state']='disabled'
            for i in arange(6, 12):
                Labentrys[i]['state']='disabled'
            but['state']='disabled'
            butrmv['state']='disabled'
            butPTE['state']='disabled'
            BUpdate['state']='disabled'
            for n in arange(0, len(Ebuttons)):
                Ebuttons[n]['state'] = 'disabled'

        elif str(distvar.get()) == 'drawing':
            BLayer['state']='disabled'
            BUpdateD['state']='normal'
            RS['state']='normal'
            RL['state']='normal'
            OFlabentries[9]['state']='normal'
            OFlabentries[10]['state']='normal'
            for i in arange(6, 12):
                Labentrys[i]['state']='normal'
            but['state']='normal'
            butrmv['state']='normal'
            butPTE['state']='normal'
            BUpdate['state']='normal'
            for n in arange(0, len(Ebuttons)):
                Ebuttons[n]['state'] = 'normal'

    def call_layers():
        layers()

    # By Layers
    BLayer = tk.Button(Labeldist, text ='Open Layers', command = lambda i = int(Econtrol) : call_layers(), width=15)
    BLayer.pack()
    # By Drawing
    BUpdateD = tk.Button(Labeldist, text = 'Element Distribution', command = lambda i = int(Econtrol) : os.system("python profiler.py %s %s %s %s &" %( Edict[int(Econtrol)]['symbol'], str(methodvar.get()), str(Labentrys[11].get()), str(OFlabentries[17].get()) ) ), width=15)
    BUpdateD.pack()
    # Interpolation methods
    RS = tk.Radiobutton(Labeldist, text="Step", variable=methodvar, value='step')
    RS.pack(side='left')
    RL = tk.Radiobutton(Labeldist, text="Lines", variable=methodvar, value='reta')
    RL.pack(side='right')
    # Distribution methods
    RLay = tk.Radiobutton(Frames[7], text="Layers", command=lambda i=int(Econtrol) :changestate(), variable=distvar, value='layer')
    RLay.pack(side='left')
    RDra = tk.Radiobutton(Frames[7], text="Drawing", command=lambda i=int(Econtrol) :changestate(), variable=distvar, value='drawing')
    RDra.pack(side='right')

##############################################################################
# Experiment variations

    def changemode():
        if str(modevar.get()) == 'IONS':
            for n in range(len(Ebuttons)):
                Ebuttons[n]['state']='normal'
            but['state'] = 'normal'
            butrmv['state'] = 'normal'
            butPTE['state'] = 'normal'
            RLay['state'] = 'normal'
            Labentrys[12]['state'] = 'disabled'

        elif str(modevar.get()) == 'RRNA':
            RDra.invoke()
            elem_select(0,Ebuttons)
            but['state'] = 'disabled'
            butrmv['state'] = 'disabled'
            RLay['state'] = 'disabled'
            Labentrys[12]['state'] = 'normal'
            for n in arange(1, len(Ebuttons)):
                Ebuttons[n]['state'] = 'disabled'

    Rions = tk.Radiobutton(Labelframe, text="Ion Scattering", command=lambda i=i :changemode(), variable=modevar, value='IONS', width=18)
    Rions.pack()
    Rrrna = tk.Radiobutton(Labelframe, text="Resonant RNA", command=lambda i=i :changemode(), variable=modevar, value='RRNA', width=18)
    Rrrna.pack()
    Rions.invoke()

##############################################################################
# Init

    RDra.invoke()
    RS.select()
    Ebuttons[0].invoke()

##############################################################################