import os
import traceback
import math
import time

print "\nStarting delay scan - Parameters: ",
print START,END,STEP,ENERGIES,RUNTYPE

###############################################################################
# Preparing for the Scan
###############################################################################
LPP_DELAY_NEW = 0
LPP_FINE_DELAY_NEW = 0


def Convert_LPP_Delays(NewDelay):
    global LPP_DELAY_NEW, LPP_FINE_DELAY_NEW
    LPP_DELAY_NEW = math.trunc(((-NewDelay*100.0+DELAY*(1E9/SLS_freq.read())*100+FINEDELAY)/100.0)/(1E9/SLS_freq.read()))
    LPP_FINE_DELAY_NEW = math.trunc(-NewDelay*100.0+DELAY*1E9/SLS_freq.read()*100+FINEDELAY-LPP_DELAY_NEW*(1E9/SLS_freq.read()*100.0))
    
def Timing(New_Time):
    caput (TIME_DELAY_SET, New_Time)
    caput (TIME_DELAY_START, 1)
    Convert_LPP_Delays(New_Time)
    caput (LPP_DELAY, LPP_DELAY_NEW)
    caput (LPP_FINE_DELAY, LPP_FINE_DELAY_NEW)  
    wait_channel(TIME_DELAY_COMPLETE, 'SCAN Complete', timeout=10+abs((caget(TIME_DELAY_SET, type='d')-caget(TIME_DELAY_VAL, type='d')))*10)


if str(SET_DELAY) == "1":
    print "Setting delay"
    Timing(END)
    print "Delay is set"
    import sys
    sys.exit(0)
else:
    print "Running full script"

if str(SET_OFFSETS) == "1":
    print "Setting offsets"
    if RUNTYPE in ["+/-", "+" , "-"]:  
        caput(OTF_MODE1,1) # circ + in ID1 
        caput(OTF_MODE2,2) # circ - in ID2
    elif RUNTYPE in ["LH/LV", "LH", "LV"]:
        caput(OTF_MODE1,0)
        caput(OTF_MODE2,0)
        wait_channel(OTF_DONE, 1, type = 'i')
        caput(OTF_ALPHA1, 0.0)  # LH in ID1
        caput(OTF_ALPHA2, 90.0) # LV in ID2
        wait_channel(OTF_DONE, 1, type = 'i') 
    else:
        raise Exception("Invalid run type: " +  RUNTYPE) 
       
    caput(OTF_OFF1,OFFSET1)
    caput(OTF_OFF2,OFFSET2-40) #detune ID2
    wait_channel(OTF_DONE, 1, type = 'i')
    print "Offsets are set"
    import sys
    sys.exit(0)
else:
    print "Running full script"

"""if ID1 == 1:
    caput ("X11PHS-E:OPT","PGM+ID1")
elif ID2 == 1:
    caput ("X11PHS-E:OPT","PGM+ID2")
else:
    caput ("X11PHS-E:OPT","PGM+ID1+ID2")"""

file_prefix = time.strftime("%y%m%d")
input_path =  PATH+file_prefix+"/"
output_path = input_path

x=ENERGIES
y = []
x=x.split(',')
for i in x:
    y.append(float(i))

def switchpol(activeID, runtype):
    global pol_str
    if activeID == 1:
        caput(OTF_OFF1,OFFSET1)
        caput(OTF_OFF2,OFFSET2-40) #detune ID2
        wait_channel(OTF_DONE, 1, type = 'i')
        if runtype in ["+/-","+,-", "+"]:
            pol_str = "circ +"
        elif runtype in ["LH/LV","LH,LV", "LH"]:
            pol_str = "Lin. Horizontal"
    elif activeID == 2:
        caput(OTF_OFF1,OFFSET1-40) #detune ID1
        caput(OTF_OFF2,OFFSET2)
        wait_channel(OTF_DONE, 1, type = 'i')
        if runtype in ["+/-","+,-", "+"]: 
            pol_str = "circ -"
        elif runtype in ["LH/LV","LH,LV", "LH"]:
            pol_str = "Lin. Vertical"
    else:
        raise Exception("Invalid parameter")

pol_str = NoneMCP_1_
polswitch = 1    
number_of_scans = 1
fid1 = get_next_fid(input_path, "MCP_1_d" + file_prefix)
fid2 = get_next_fid(input_path, "MCP_2_d" + file_prefix)
fid = max(fid1,fid2)

if RUNTYPE in ["+/-","+,-", "+", "-"]:
    caput(OTF_MODE1,1) # circ + in ID1 
    caput(OTF_MODE2,2) # circ - in ID2
    wait_channel(OTF_DONE, 1, type = 'i')
    if RUNTYPE == "+/-":
        number_of_scans = 2 * ROUNDS
    else: 
        number_of_scans = ROUNDS
elif RUNTYPE in ["LH/LV","LH,LV", "LH", "LV"]:
    caput(OTF_MODE1,0)
    caput(OTF_MODE2,0)
    wait_channel(OTF_DONE, 1, type = 'i')
    caput(OTF_ALPHA1, 0.0)  # LH in ID1
    caput(OTF_ALPHA2, 90.0) # LV in ID2
    wait_channel(OTF_DONE, 1, type = 'i')
    if RUNTYPE == "LH/LV":
        number_of_scans = 2 * ROUNDS
    else:
        number_of_scans = ROUNDS
else:
    raise Exception("Invalid run type: " +  RUNTYPE)

if RUNTYPE in ["-", "LV"]:
    switchpol(2, RUNTYPE) # tune ID2 --> polarization: C- or LV
    polswitch = 0
elif RUNTYPE in ["+/-","+,-", "+", "LH/LV","LH,LV", "LH"]:
    switchpol(1, RUNTYPE) # tune ID1 --> polarization: C+ or LH
time.sleep(1.0)

caput (TIME_DELAY_SET, START)
caput (TIME_DELAY_START, 1)
if START == 0:
    caput (LPP_DELAY, DELAY)
    caput (LPP_FINE_DELAY, FINEDELAY)
    wait_channel(TIME_DELAY_COMPLETE, 'SCAN Complete', timeout= 10)
else:
    Convert_LPP_Delays(caget(TIME_DELAY_SET, type='d'))
    caput (LPP_DELAY, LPP_DELAY_NEW)
    caput (LPP_FINE_DELAY, LPP_FINE_DELAY_NEW)
    wait_channel(TIME_DELAY_COMPLETE, 'SCAN Complete', timeout= abs((caget(TIME_DELAY_SET, type='d')-caget(TIME_DELAY_VAL, type='d')))*10)


def Scan(Dtime,ser):
    e = energy.read()
    if (MCP_1 == 1 or MCP_2 == 1):
        aK1=keithley_1a.read()
        aP=FillingPattern.read()
        aPr = []
        for z in aP:
            aPr.append(z)
        SumaP=0
        CamaP=0
        for z in xrange(0,480):
            SumaP = SumaP + aPr[z]
        for z in xrange(460,470):
            CamaP = CamaP + aPr[z]
        aK1norm = aK1 * CamaP / SumaP
        t_end = time.time()+ACQTIME
        a1r = [0]*960
        a2r = [0]*960
        while time.time() < t_end:
            a1t = MCPArray1.read().tolist()
            a1r = [a1r[i]+a1t[i] for i in xrange(len(a1t))]
            a2t = MCPArray2.read().tolist()
            a2r = [a2r[i]+a2t[i] for i in xrange(len(a2t))]
            time.sleep(SamplingTime.read()*0.001)        
        if MCP_1 == 1:
            '''a1=MCPArray1.read()
            a1r = []
            for i in a1: 
                a1r.append(i)'''
            Sum1a1 = 0
            Cam1a1 = 0
            Sum2a1 = 0
            Cam2a1 = 0
            MCP1.append(line_sep)
            MCP1.append(Dtime)
            MCP1.append(e)
            MCP1.append(pol_str)
            for i in xrange(0,480):
                Sum1a1 = Sum1a1 + a1r[i]
            for i in xrange(Cam_start,Cam_end+1):
                Cam1a1 = Cam1a1 + a1r[i]
            MCP1.append(Sum1a1)
            MCP1.append(Cam1a1)
            MCP1.append(aK1norm)
            if NrCounters.read() > 460:     
                for i in xrange(480,960):
                    Sum2a1 = Sum2a1 + a1r[i]
                for i in xrange(Cam_start+480,Cam_end+481):
                    Cam2a1 = Cam2a1 + a1r[i]    
                MCP1.append(Sum2a1)
                MCP1.append(Cam2a1)
            if Save_array_data == 1:
                MCP1.append(a1r)
        if MCP_2 == 1:
            '''a2=MCPArray2.read()
            a2r = []
            for j in a2:                    
                a2r.append(j)'''
            while time.time() < t_end:
                
                time.sleep(SamplingTime.read()*0.001)
            Sum1a2 = 0
            Cam1a2 = 0
            Sum2a2 = 0
            Cam2a2 = 0
            MCP2.append(line_sep)
            MCP1.append(Dtime)
            MCP2.append(e)
            MCP2.append(pol_str)
            for j in xrange(0,480):
                Sum1a2 = Sum1a2 + a2r[j]
            for j in xrange(Cam_start,Cam_end+1):
                Cam1a2 = Cam1a2 + a2r[j]
            MCP2.append(Sum1a2)
            MCP2.append(Cam1a2)
            MCP2.append(aK1norm)
            if NrCounters.read() > 460:     
                for j in xrange(480,960):
                    Sum2a2 = Sum2a2 + a2r[j]
                for j in xrange(Cam_start+480,Cam_end+481):
                    Cam2a2 = Cam2a2 + a2r[j]
                MCP2.append(Sum2a2)
                MCP2.append(Cam2a2)
            if Save_array_data == 1:
                MCP2.append(a2r)
            #v = abs((keithley_2a.read() / ((keithley_1a if (type==1) else keithley_3a).read() )))
        ser.appendData(Dtime,Cam1a1)   
    else:
        print "No MCP is selected for acquisition. Select at least one ! ! ! " 
def SaveData():
    global output_file_MCP1, output_file_MCP2
    output_file_MCP1 = output_path+"MCP_1_"+"d"+file_prefix+"_" + suffix + ".dat"
    output_file_MCP2 = output_path+"MCP_2_"+"d"+file_prefix+"_" + suffix + ".dat"
    if MCP_1 == 1:
        MCP1out = open(output_file_MCP1, "a+")
        sMCP1 = sep.join(str(x) for x in MCP1) + line_sep       #    MCP1.write("%s" + sep % i)
        sMCP1out = sep + "Delay_Time" + sep + "rbkenergy" + sep + "pol"+ sep + "Sum1" + sep + "Cam1" + sep + "Keithley1_norm"
        if NrCounters.read() > 460:     
            sMCP1out = sMCP1out + sep + "Sum2" + sep  + "Cam2"
        if Save_array_data == 1:
            sMCP1out = sMCP1out + sep + "Array"
        sMCP1out = sMCP1out + line_sep + sMCP1                
        MCP1out.write(sMCP1out)
        MCP1out.close()
        print "Saved MCP signal data"
    if MCP_2 == 1:     
        MCP2out = open(output_file_MCP2, "a+")
        sMCP2 = sep.join(str(y) for y in MCP2) + line_sep      
        sMCP2out = sep + "Delay_Time" + sep + "rbkenergy"+ sep + "pol" + sep + "Sum1" + sep + "Cam1" + sep + "Keithley1_norm"
        if NrCounters.read() > 460:     
            sMCP2out = sMCP2out + sep + "Sum2" + sep  + "Cam2"
        if Save_array_data == 1:
            sMCP2out = sMCP2out + sep + "Array"
        sMCP2out = sMCP2out + line_sep + sMCP2                
        MCP2out.write(sMCP2out)
        MCP2out.close()  
        print "Saved MCP I_0 data"
        
###############################################################################
# Scanning
###############################################################################

sep = "\t"
line_sep = "\r\n"

def startPlot():
    sep = "\t"
    line_sep = "\r\n"
    print "Starting plot"
    p = plot(None,name="Delay")[0]
    s = p.getSeries(0)
    Delay_Time = START
    if RUNTYPE in ["+,-", "LH,LV"]:
        polperscan=2
    else:
        polperscan=1
    
    while Delay_Time <= END:
        Timing(Delay_Time)
        for en in y:
            caput(OTF_ESET,en)
            wait_channel(OTF_DONE, 1, type = 'i')
            Scan(Delay_Time,s)
            if polperscan==2:
                switchpol(2,RUNTYPE)
                Scan(Delay_Time,s)
                switchpol(1,RUNTYPE)
        Delay_Time += STEP
    SaveData()
    print "Done Plotting and Saving Data"
   
'''def startPlot(type = 1):
    global task
    task = fork((_startPlot,(type,)),)        

def stopPlot():
    global task    
    ret = join(task)'''


for scan_no  in range(number_of_scans):
    suffix = ("%03d" % fid)
    MCP1 = []
    MCP2 = []
    print "Running scan " + str(scan_no+1) + " out of " + str(number_of_scans)
    startPlot()
    if MCP_1 == 1:
        #output_file_MCP1 = output_path+"MCP_1_"+"d"+file_prefix+"_" + suffix + ".dat"
        plot_file(output_file_MCP1, file_prefix+"_" + suffix) 
    elif MCP_2 == 1:
        #output_file_MCP2 = output_path+"MCP_2_"+"d"+file_prefix+"_" + suffix + ".dat"
        plot_file(output_file_MCP2, file_prefix+"_" + suffix)     
    else:
        pass
    print "Finished scan " + str(scan_no+1) + " out of " + str(number_of_scans)
    if RUNTYPE in ["+/-", "LH/LV"]:
        if polswitch == 1:
            switchpol(2, RUNTYPE) # tune ID2 --> polarization: C- or LV
            polswitch = 0
        else:
            polswitch = 1
            switchpol(1, RUNTYPE) # tune ID1 --> polarization: C+ or LH
    else:
        print "running in one polarization mode or in +,- mode"
    fid = fid + 1

print "Finished Delay scan"

print("Success")