# TESTIOC:TESTSINUS:SinCalc
# TESTIOC:TESTWF2:MyWF
# TESTIOC:TESTCALCOUT:Input
# TESTIOC:TESTCALCOUT:Output

#get_context().dataManager.provider.embeddedAtributes = False
#get_context().dataManager.provider.ADD_ATTRIBUTE_FILE_TIMESTAMP = True
###################################################################################################
#  EPICS utilities
##############
#####################################################################################

    
if get_context().getScriptType()==ScriptType.cpy:
    def on_ctrl_cmd(cmd):   
        global RE
        print ("Control command: ", cmd)
        if cmd=="abort":
            if "RE" in globals():
                if RE.state not in ['idle','paused', 'pausing']:
                    print ("Run Engine pause request")
                    RE.request_pause()
    abort()
 
def otf(mode="ENERGY", e1=None, e2=None, beta1=None, beta2=None, theta1=None, theta2=None, \
        time=1.0, modulo=1, turn_off_beam=False):
    """
    mode: "ENERGY" or "AMNGLE"
    """    
    run("otf", {"E1":450.0, "E2":460.0})
    run("otf", {            
        "MODE":mode, \
        "E1":float(e1) if e1 is not None else None, \
        "E2":float(e2) if e2 is not None else None, \
        "BETA1":float(beta1) if beta1 is not None else None, \
        "BETA2":float(beta2) if beta2 is not None else None, \
        "THETA1":float(theta1) if theta1 is not None else None, \
        "THETA2":float(theta2) if theta2 is not None else None, \ 
        "TIME":float(time), \
        "MODULO":int(modulo), \
        "ENDSCAN":turn_off_beam, \
        })   

def caget_str(ch):
    return ''.join((chr(i) if i else "") for i in caget(ch))

def caput_str(ch, val):
    ret = [ord(c) for c in val]
    ret = ret + ([0] * (256-len(ret)))
    ret = to_array(ret, 'b')
    caput(ch, ret)
    

SCI_METADATA =  {
        "beamlineParameters": {
            "Monostripe": "Ru/C",
            "Ring current": {
                "v": 0.402246,
                "u": "A"
            },
            "Beam energy": {
                "v": 22595,
                "u": "eV"
            }
        },
        "detectorParameters": {
            "Objective": 20,
            "Scintillator": "LAG 20um",
            "Exposure time": {
                "v": 0.4,
                "u": "s"
            }
        },
        "scanParameters": {
            "Number of projections": 1801,
            "Rot Y min position": {
                "v": 0,
                "u": "deg"
            },
            "Inner scan flag": 0,
            "File Prefix": "817b_B2_",
            "Sample In": {
                "v": 0,
                "u": "m"
            },
            "Number of darks": 10,
            "Rot Y max position": {
                "v": 180,
                "u": "deg"
            },
            "Angular step": {
                "v": 0.1,
                "u": "deg"
            },
            "Number of flats": 120,
            "Sample Out": {
                "v": -0.005,
                "u": "m"
            },
            "Flat frequency": 0,
            "Number of inter-flats": 0
        }
}

###################################################################################################
def on_command_started(info):
    pass #print "Start: " + str(info.script)  
def on_command_finished(info):
    pass #print "Finished: "  + str(info.script) + " Error: " + str(info.error)
def on_change_data_path(path):
    #print "Data path: " + str(path)
    pass
def on_session_started(id):
    #print "Start session: ", id
    get_context().sessionManager.setMetadata("beamlineState", {"sin": sin.take(), "inp": inp.take()})
    get_context().sessionManager.setMetadata("beamlineState2", {"sin": sin.take(), "inp": inp.take()})
def on_session_finished(id):
    #print "Stop session: ", id
    get_context().sessionManager.setMetadata("scientificMetadata",SCI_METADATA)
    get_context().sessionManager.setMetadata("scientificMetadata2",SCI_METADATA)




###################################################################################################
# Image filters 
###################################################################################################
"""
class DataFilter(Filter.DataFilter):       
    def process(self, data):    
        data=data.copy()
        data.mult(2.0)
        return data
                    
data_filter = DataFilter("filter")
image.addListener(data_filter)
proc_data=ColormapAdapter("proc_data", data_filter)
add_device(proc_data, True)


class ImageFilter(Filter.ImageFilter):       
    def process(self, img):                    
        return ImagingUtils.transpose(img)
                    
image_filter = ImageFilter("filter")
image.addListener(image_filter)
#proc_image=ColormapAdapter("proc_image", image_filter)
add_device(image_filter, True)

image.refresh() 
"""
    


    
###################################################################################################
# Layout setup
###################################################################################################

#LayoutSF.setExperimentArguments([pv, motor, pe, cv, energy, sin])



#Librariesenergy
#import Jama.Matrix
#sys.path.append('/Users/gobbo_a/dev/pshell/config/home/script/Lib/diffcalc')



crlogic_config = {}
crlogic_config["class"] = "ch.psi.pshell.crlogic.CrlogicScan"
crlogic_config["prefix"] = "MTEST-HW3-CRL"
crlogic_config["ioc"] = "MTEST-VME-HW3.psi.ch"
crlogic_config["integrationTime"] = 0.01
crlogic_config["additionalBacklash"] = 0.0


#LOCAL DEFINITIONS


"""
old  = ov if globals().has_key("ov") else  None
r = show_panel(img)
ov1 = Text(Pen(Color.ORANGE), "TEXT", Font("Verdana", Font.PLAIN, 12) , Point(20,20), )
ov2 = Rect(Pen(Color.ORANGE),Point(50,50), Point(100,100),  )
ov3 = Rect(Pen(Color.RED),Point(150,150), Point(200,200),  )
ov4 = Rect(Pen(Color.GREEN),Point(250,250), Point(300,300),  )
ov5 = Text(Pen(Color.ORANGE), "TEXT 2", Font("Verdana", Font.PLAIN, 12) , Point(-50,-50), )
ov5.setAnchor(Overlay.ANCHOR_VIEWPORT_OR_IMAGE_BOTTOM_RIGHT)
ov5.setFixed(True)
ov1.setFixed(True)
ov2.setFixed(True)
ov2.setAnchor(Overlay.ANCHOR_VIEWPORT_TOP_LEFT)
ov2.setMovable(True)
ov2.setSolid(True)
ov3.setFixed(True)
ov3.setMovable(True)
ov3.setSolid(True)
ov4.setMovable(True)
ov4.setSolid(True)
ov=[ov1,ov2, ov3, ov4, ov5]
r.updateOverlays(ov, old)
"""

#from jeputils import *

#det.data.monitored=True
import random

#State listener: cleanup can be made at end of execution
def onStateChange(state, former, script):
    #print state
    if state == State.Closing:
        #print "Closing the app"
        pass
    elif script is not None: 
        if state.isProcessing():
            #print "Started script " + script
            pass
        elif former.isProcessing():
            #print "Finished script " + script
            pass             


class Listener(ContextListener):
    def onContextStateChanged(self, state, former):
        onStateChange(state, former, get_context().runningScriptName)


def scan_e(start, end, step, settling_time = 0, accumulation_time = None, name = None):
    """
    """
    if name is not None:
        set_exec_pars(name = name)
    print get_exec_pars().path
    lscan(inp,out, start, end, step,settling_time)
    

#Simulated Devices

#run("tutorial/devices")
#run("src/main/assembly/help/Tutorial/devices")
#run("devices")

class SimulatedOutput(Writable):
    def write(self, value):
        pass

    def getName(self):        
        return "sout"

#class SimulatedInput(Readable):
class SimulatedInput(ReadonlyRegisterBase):
    def __init__(self):
        self.x = 0.0

    #def read(self):
    def doRead(self):    
        self.x = self.x + 0.1
        noise = (random.random() - 0.5) / 20.0
        return math.sin(self.x)  + noise

    def getName(self):        
        return "sinp"
        
sout = SimulatedOutput()
sinp = SimulatedInput()
add_device(sinp, True)
#for m in mu, delta, gamma, eta, chi, phi:
#    m.setSpeed(m.config.defaultSpeed)
#Controler Evenrt Listener




clistener = Listener()
get_context().addListener(clistener)



def trig_scienta():
    time.sleep(1.0)

en_val = None
class SimulatedEnergy(Writable):
    def write(self, value):
        self.put(value)

    def put(self, value, timeout = None):
        global en_val
        en_val = value

    def close(self):
        pass

    @staticmethod
    def test ():
        return "asd"


class SimulatedEnergyReadback(Readable):
    def read(self):
        global en_val
        return en_val;
    
    def get(self):
        return self.read()

    def close(self):
        pass

sim_energy = SimulatedEnergy()
sim_energy_readback = SimulatedEnergyReadback()


class beam_ok(ReadonlyRegisterBase):
    def doRead(self):
        return True
add_device(beam_ok(), True)

#Device utilities
def integrate_image():
    data = scienta.data.read()
    #Integrate and plot
    (width,height) = scienta.getImageSize().tolist()
    integration = []
    for i in range(width):
        p=0.0
        for j in range(height):
            p=p+data[j*width+i]
        integration.append(p)
    return integration

def trig_scienta():
    #scienta.start()
    #scienta.waitReady(-1)
    print "Trig Scienta"
    time.sleep(0.1)
    pass


#Pseudo-Devices
class ImageIntegrator(ReadableArray):
    def getSize(self):
        (width,height) = scienta.getImageSize().tolist()
        return width

    def read(self):
        return to_array(integrate_image(),'d')

integration = ImageIntegrator()


"""
class Interlock(DeviceAdapter):
     def onValueChanging(self, device, value, former):
        if value > 5.0:
            raise Exception("Interlocked")
    


motor.addListener(Interlock())
"""

#This procedude is used to emulate file names generated by FDA
"""
import ch.psi.pshell.data.LayoutTable
class Layout( ch.psi.pshell.data.LayoutTable):
    def getLogFileName(self):        
        return time.strftime('%Y%m%d%H%M%S') + '_' + get_exec_pars().name + '_logs'
    
    def getDatasetName(self, scan):        
        return time.strftime('%Y%m%d%H%M%S') + '_' + get_exec_pars().name + '_' +  str(get_exec_pars().index).zfill(4)
        
get_context().dataManager.setLayout(Layout())

"""

"""
import ch.psi.pshell.data.LayoutTable
class DataLayout( ch.psi.pshell.data.LayoutTable):
    def getLogFileName(self):
        return time.strftime('%Y%m%d_%H%M') + '_' + get_exec_pars().script + '_logs'
    
    def getDatasetName(self, scan):
        print get_exec_pars().count
        data_file =  time.strftime('%Y%m%d_%H%M') + '_' + get_exec_pars().name  + '_' + str(get_exec_pars().count).zfill(4)        
        print "Opened data file: " + get_exec_pars().path + "/" + data_file
        return data_file
get_context().dataManager.setLayout(DataLayout())
"""

#Interlocks
"""
class MyInterlock1 (Interlock):
#Motor and Positioners
    def __init__(self):
        Interlock.__init__(self, (motor, pe))

    def check(self, (m, p)):
        if p>50.0 and (m<50 and m>40):
            return False
        return True

interlock1 = MyInterlock1()
"""

"""
#Motor group
class MyInterlock2(Interlock):
    def __init__(self):
        Interlock.__init__(self, (table, pe))

    def check(self, ((m1,m2), p)):
        if p<500 and (m1>4 and m2>4):
            return False
        return True

interlock2 = MyInterlock2()

"""

"""
#Discrete Positioner
class MyInterlock3(Interlock):
    def __init__(self):
        Interlock.__init__(self,  (tab, pe))

    def check(self, (tab, p)):
        if p<500 and tab=="Out":
            return False
        return True

interlock3 = MyInterlock3()
"""
"""

import ch.psi.pshell.data.LayoutTable
class DataLayout( ch.psi.pshell.data.LayoutTable):
    def getLogFileName(self):
        return time.strftime('%Y%m%d_%H%M') + '_' + get_exec_pars().name + '_logs'
    
    def getDatasetName(self, scan):
        print get_exec_pars().count
        data_file =  time.strftime('%Y%m%d_%H%M') + '_' + get_exec_pars().name  + '_' + str(get_exec_pars().count).zfill(4)        
        print "Opened data file: " + get_exec_pars().path + "/" + data_file
        return data_file
get_context().dataManager.setLayout(DataLayout())
"""


#run("CPython/wrapper")

class SimulatedImage(ReadonlyRegisterBase, ReadonlyRegisterMatrix, ReadableCalibratedMatrix):
    def __init__(self, size_x=1280, size_y=960, number_of_dead_pixels=100, noise=0.1, beam_size_x=100, beam_size_y=20):        
        self.size_x, self.size_y, self.number_of_dead_pixels, self.noise, self.beam_size_x, self.beam_size_y = \
                    size_x, size_y, number_of_dead_pixels, noise, beam_size_x, beam_size_y 
        self.sc = None
        
    def doRead(self):
        if self.sc is None:
            self.sc = new_simulated_camera(self.size_x, self.size_y, self.number_of_dead_pixels, self.noise, self.beam_size_x, self.beam_size_y)
        ret = get_image()
        return Convert.reshape(ret,self.size_y, self.size_x)

    def getWidth(self):
        return self.width

    def getHeight(self):
        return self.height

    def getCalibration(self):
        return MatrixCalibration(-1.0, 1.0, 0.0, 0.0)

#add_device(RegisterMatrixSource("sim", SimulatedImage()), True)
#sim.polling = -250




def get_next_fid(folder, prefix, ext):
    try:
        import glob   
        files = glob.glob(folder + prefix + '*_*.dat')
        last = max(files)
        index = int (last[last.rfind('_')+1 : last.rfind('.')]) + 1
        return index
    except:
        return 0

def wait_channel(name, value, timeout =None, type='s'):
    print "Waiting " + str(name) + " = " + str(value)
    cawait(name, value, timeout = timeout, type=type)
    print "Done waiting"

def convert_file(input_file_name, output_file_name, field = 0, pol = 0, keithley_3 = False):   
    sep = "\t"
    line_sep = "\n"
    with open(input_file_name) as inp:
        lines = inp.readlines()
        with open(output_file_name, "wb") as out:
            out.write("Energy" + sep + "rbkenergy" + sep + "Mag" + sep + "Pol" + sep + "Io" + sep + "TEY" + sep + "Norm" + line_sep)
            s = sep + " "    #File format has a space before numeric values
            for line in lines[1:]:
                line = line.strip()
                if line=="": break
                try:                   
                    (Ecrbk,CADC1, CADC2, NORM, CADC3, CADC4, MCurr, cffrbk, ID1Erbk, ID2Erbk, vTime) = line.split(" ")                   
                    #out.write(Ecrbk + sep + Ecrbk + sep + str(field) + sep + str(pol) + sep + CADC1 + sep + CADC2 + sep + (CADC3 if keithley_3 else NORM) + line_sep)
                    out.write(" " + Ecrbk + s + Ecrbk + s + str(field) + s + str(pol) + s + CADC1 + s + CADC2 + s + (CADC3 if keithley_3 else NORM) + line_sep)
                except:
                    traceback.print_exc()           

def plot_file(file, title = None):
    """
    """
    table = Table.load(file, "\t", '#')
    plots = plot(table, title = title)


    


from mathutils import estimate_peak_indexes, fit_gaussians, create_fit_point_list, Gaussian,fit_harmonic,HarmonicOscillator
import java.awt.Color as Color

def fit(ydata, xdata = None):
    if xdata is None:
        xdata = frange(0, len(ydata), 1)
    max_y= max(ydata)    
    index_max = ydata.index(max_y)    
    max_x= xdata[index_max]
    print "Max index:" + str(index_max),
    print " x:" + str(max_x),
    print " y:" + str(max_y)
    
    gaussians = fit_gaussians(ydata, xdata, [index_max,])
    p = plot([ydata],["data"],[xdata], title="Fit" )[0] 

    if gaussians[0] is None:  #Fitting error
        p.addMarker(max_x, None, "Max="+str(round(max_x,2)), Color.GRAY)
        print "Fitting error - using max value"
        return (None, max_x, None)
    
    (norm, mean, sigma) = gaussians[0]

    fitted_gaussian_function = Gaussian(norm, mean, sigma)    
    scale_x = [float(min(xdata)), float(max(xdata)) ]
    points = max((len(xdata)+1), 100)
    resolution = (scale_x[1]-scale_x[0]) / points    
    fit_y = []
    fit_x = frange(scale_x[0],scale_x[1],resolution, True)
    for x in fit_x:
        fit_y.append(fitted_gaussian_function.value(x))    
    p.addSeries(LinePlotSeries("fit"))
    p.getSeries(1).setData(fit_x, fit_y)    
    
    if abs(mean - xdata[index_max]) < ((scale_x[0] + scale_x[1])/2):
        print "Mean -> " +  str(mean)
        p.addMarker(mean, None, "Mean="+str(round(norm,2)), Color.MAGENTA.darker())
        return (norm, mean, sigma)
    else:
        p.addMarker(max_x, None, "Max="+str(round(max_x,2)), Color.GRAY)
        print "Invalid gaussian fit: " +  str(mean) + " - using max value"
        return (None, max_x, None)

def hfit(ydata, xdata = None):
    if xdata is None:
        xdata = frange(0, len(ydata), 1)

    max_y= max(ydata)    
    index_max = ydata.index(max_y)    
    max_x= xdata[index_max]
        
    start,end = min(xdata), max(xdata)
    (amplitude, angular_frequency, phase) = fit_harmonic(ydata, xdata)
    fitted_harmonic_function = HarmonicOscillator(amplitude, angular_frequency, phase)
    
    print "amplitude = ", amplitude
    print "angular frequency = ", angular_frequency
    print "phase = ", phase

    f = angular_frequency/ (2* math.pi)  
    print "frequency = ", f  

    resolution = 0.01
    fit_y = []
    for x in frange(start,end,resolution, True):
        fit_y.append(fitted_harmonic_function.value(x))
    fit_x = frange(start, end+resolution, resolution)

    p = plot(ydata,"data", xdata, title="HFit")[0]
    p.addSeries(LinePlotSeries("fit"))
    p.getSeries(1).setData(fit_x, fit_y)    

    #m = (phase + math.pi)/ angular_frequency
    m = -phase / angular_frequency
    if (m<start):
        m+=(1.0/f)
        
    if start <=m <=end:
        print "fit = ", m
        p.addMarker(m, None, "Fit="+str(round(m ,2)), Color.MAGENTA.darker())
        return (amplitude, angular_frequency, phase, True, m)
    else:
        print "max = ",max_x
        p.addMarker(max_x, None, "Max="+str(round(max_x ,2)), Color.MAGENTA.darker())        
        return (amplitude, angular_frequency, phase, False, max_x)

from mathutils import fft, get_modulus

def plot_spectrum(signal, sampling_freq, plots = None):
    signal = to_list(signal) 
    number_of_samples = len(signal)
    time_vector = [x / sampling_freq for x in frange(0, number_of_samples, 1)]    
    tranform = fft(signal)
    two_side_spectrum = [x / number_of_samples for x in get_modulus(tranform)]
    spectrum = [two_side_spectrum[0],] + [x * 2 for x in two_side_spectrum[1:len(two_side_spectrum)/2 + 1] ]
    number_of_samples = len(tranform)    # Signal may have been padded to next power of two
    freq_vector = [x * sampling_freq / float(number_of_samples) for x in frange(0, len(spectrum) , 1)]
    if plots is None:
        plots = plot([signal,spectrum], ["signal", "spectrum"],[time_vector, freq_vector], title = "Spectrum")
    else:
        plots[0].getSeries(0).setData(time_vector,signal)
        plots[1].getSeries(0).setData(freq_vector,spectrum)
    return plots
     

def elog(title, message, attachments = [], author = get_context().getUser().name, category = "Info", domain = "", logbook = "SwissFEL test", encoding=1):
    typ = "pshell"
    entry = ""    
    cmd = 'G_CS_ELOG_add -l "' + logbook+ '" '
    cmd = cmd + '-a "Author=' + author + '" '
    cmd = cmd + '-a "Type=' + typ + '" '
    cmd = cmd + '-a "Entry=' + entry + '" '
    cmd = cmd + '-a "Title=' + title + '" '
    cmd = cmd + '-a "Category=' + category + '" '
    cmd = cmd + '-a "Domain=' + domain + '" '
    for attachment in attachments:
        cmd = cmd + '-f "' + attachment + '" '
    cmd = cmd + '-n ' + str(encoding)
    cmd = cmd + ' "' + message + '"'
    print cmd
    print exec_cmd(cmd)


#CAS
class ArrayDevice(ReadonlyRegisterBase, ReadonlyRegisterArray):
    def doRead(self):
        return self.take()

    def getSize(self):
        global scan_result
        return len(self.take())   

    def append(self, value):
        c = self.take()
        c.append(value)
        self.set(c)
        
    def set(self, value):
        self.onReadout(to_array(value, 'd'))


class ScalarDevice(RegisterBase):    
    def doRead(self):
        return self.val if hasattr(self, 'val') else 0.0 

    def doWrite(self, val):
        self.val = val        

    def test(self):
        self.setCache(1.0, None)

"""
add_device(ArrayDevice("scan_pos"), True)
add_device(ArrayDevice("scan_val"), True)
add_device(ScalarDevice("scan_start"), True)
add_device(ScalarDevice("scan_stop"), True)
add_device(ScalarDevice("scan_step"), True)

scan_start.write(0.0)
scan_stop.write(40.0)
scan_step.write(1.0)



import ch.psi.pshell.epics.CAS as CAS
#CAS.setServerPort(12345)
cas1=CAS("PSHELL:scanpos",scan_pos, "double")
cas2=CAS("PSHELL:scanval",scan_val, "double")
cas3=CAS("PSHELL:scanstart",scan_start, "double")
cas4=CAS("PSHELL:scanstop",scan_stop, "double")
cas5=CAS("PSHELL:scanstep",scan_step, "double")

#scan_pos.set([] )
#scan_val.set([])
#TODO: this is workaround to CAS not supporting dynamic arrays
MAX_ARRAY_DEV_SIZE = 5000
scan_pos.set([0.0,] * MAX_ARRAY_DEV_SIZE )
scan_val.set([0.0,] * MAX_ARRAY_DEV_SIZE )


#cas6= CAS("PSHELL:var",sin)
"""

#show_panel(master)


def plot_numpy_array(na, title = None):
    plot( Convert.reshape(na.getData(),na.getDimensions()),title=title)



def run_fda(file_name, arguments={}):
    """
    Run FDA loop
    """
    import ch.psi.fda.ProcessorFDA as ProcessorFDA
    ProcessorFDA().execute(file_name,arguments)



#Convex hull plots
def clear_convex_hull_plot(title):
    plots = get_plots(title = title)
    if len(plots)>0:
        plots[0].clear() 
 
def add_convex_hull_plot(title, x,y, name=None, clear = False, x_range = None, y_range = None):
    plots = get_plots(title = title)
    p = None
    if len(plots)==0:
        p = plot(None,name=name, title = title)[0]       
        if x_range is not None:
            p.getAxis(p.AxisId.X).setRange(x_range[0], x_range[1])
        if y_range is not None:
            p.getAxis(p.AxisId.Y).setRange(y_range[0], y_range[1])
        p.setLegendVisible(True)       
    else:
        p = plots[0]   
        if clear:
            p.clear()
        p.addSeries(LinePlotSeries(name))                   
    s = p.getSeries(name)       
    s.setLinesVisible(False)
    s.setPointSize(3)
    x, y = to_array(x,'d') , to_array(y,'d')
    s.setData(x, y)   

    #Convex Hull
    #In the first time the plot shows, it takes some time for the color to be assigned
    timeout = 0
    while s.color is None and timeout<1000:
        time.sleep(0.001)
        timeout = timeout + 1
    hull = LinePlotSeries(name + "Hull", s.color)   
    p.addSeries(hull)    
    #Bounding box
    #x1,x2,y1,y2 = min(x), max(x), min(y), max(y)   
    #(hx,hy) = ([x1,x2, x2, x1, x1], [y1, y1, y2, y2, y1])            
    (hx,hy) = convex_hull(x=x, y=y)
    hx.append(hx[0]); hy.append(hy[0])                                
    hull.setLineWidth(2)
    hull.setData(to_array(hx,'d') , to_array(hy,'d'))    
    hull.setColor(s.color)
    return [hx,hy]




class CamtoolValue(Readable):
    def __init__(self, channel, alias = None):        
        self.channel=channel
        set_device_alias(self, channel if (alias is None) else alias)
        
    def read(self):
        return  camtool.getValue(self.channel)

class CamtoolArray(ReadableArray):
    def __init__(self, channel, alias = None):              
        self.channel=channel
        set_device_alias(self, channel if (alias is None) else alias)
        
    def read(self):
        return  camtool.getValue(self.channel)        

    def getSize(self):
        return len(camtool.getValue(self.channel))



class CamtoolImage(ReadableMatrix):
    def __init__(self, alias = None):             
        set_device_alias(self, camtool.getCurrentCamera() + " image" if (alias is None) else alias)
        
    def read(self):
        return camtool.getData().matrix

    def getWidth(self):
        return camtool.getData().width

    def getHeight(self):
        return camtool.getData().height   


def wait_camtool_message(number_messages = 1, timeout = 10000):
    for i in range (number_messages):
        if not camtool.stream.waitCacheChange(timeout): raise Exception("Timeout receiving from Camtool")


def get_camtool_stats(number_images=1, async = True, interval=-1, good_region = False):
    #return  [CamtoolValue("gr_x_fit_mean"), CamtoolValue("gr_y_fit_mean"),  CamtoolValue("gr_x_fit_standard_deviation"),  CamtoolValue("gr_y_fit_standard_deviation")]        
    ret = []
    wait_camtool_message()
    prefix = "gr_" if good_region else ""
    for ident in [prefix+"x_fit_mean", prefix+"y_fit_mean", prefix+"x_fit_standard_deviation", prefix+"y_fit_standard_deviation"]:        
        child = camtool.stream.getChild(ident)
        av = create_averager(child, number_images, interval)
        av.monitored = async
        ret.append(av)
    return ret



"""
import ch.psi.fda.LayoutFDA
class DataLayout( ch.psi.fda.LayoutFDA):
    def getLogFileName(self):
        return time.strftime('%Y%m%d_%H%M') + '_' + get_exec_pars().name + '_logs'
    
    def getDatasetName(self, scan):
        return  time.strftime('%Y%m%d_%H%M') + '_' + get_exec_pars().name  + '_' + str(get_exec_pars().count-1).zfill(4)        
get_context().dataManager.setLayout(DataLayout())

"""


def is_panel():
    return get_exec_pars().source == CommandSource.plugin

def is_ui():
    return get_exec_pars().source == CommandSource.ui


class AnalogOutput(RegisterBase):    
    def doRead(self):
        return self.val if hasattr(self, 'val') else 0.0 

    def doWrite(self, val):
        self.val = val

class Sinusoid(ReadonlyRegisterBase):
    def doRead(self):
        noise = (random.random() - 0.5) * 0.15
        return round(math.sin(1.0*time.time())  + noise , 3)

class Bpm(ReadonlyRegisterBase):
    def doRead(self):
        noise = (random.random() - 0.5) * 0.15
        return round(math.sin(0.5*math.radians(phase.read()))  + noise , 3)

class SinusoidWaveform(ReadonlyRegisterBase, ReadonlyRegisterArray):
    def doRead(self):
        time.sleep(0.001)
        ret = []
        x = random.random()
        for i in range (20):
            ret.append(math.sin(x))
            x = x + 0.1
        return ret

    def getSize(self):
        return len(self.take(-1))    #only reads if cache is None

class SinusoidImage(ReadonlyRegisterBase, ReadonlyRegisterMatrix):
    def doRead(self):
        time.sleep(0.001)
        (width, height) = (200, 100)
        ret = []
        x = random.random();
        base = []        
        for i in range (width):
            base.append( math.sin(x))
            x = x + 0.05
        for i in range (height):
            noise = (random.random() - 0.5)/5.0 
            ret.append([x+noise for x in base])
        return to_array(ret,'d')
    def getWidth(self):
        return len(self.take(-1)[0])

    def getHeight(self):
        return len(self.take(-1))
"""        

add_device(Bpm("bpm_x"), True)
add_device(Sinusoid("amplitude"), True)
add_device(Sinusoid("power"), True)
add_device(SinusoidWaveform("waveform1"), True)
add_device(SinusoidImage("detector1"), True)
import ch.psi.pshell.imaging.RegisterMatrixSource as RegisterMatrixSource
add_device(RegisterMatrixSource("image1", detector1), True)

bpm_x.setPolling(100)
waveform1.setPolling(1000)
image1.setPolling(-200)

add_device(DummyPositioner("phase"),True)
"""

class DigitalInput(ReadonlyRegisterBase):
    def doRead(self):
        return  False if (int(time.time()) %2 == 0 ) else True

add_device(DigitalInput("di"),True)      
#di.polling=1000



###  Diffcalc
GEOMETRY_PREFERENCE = "geometry"

def get_geometry():
    """
    """
    setting = get_setting(GEOMETRY_PREFERENCE)
    if setting is None or (len(setting.strip()) == 0):
        return None
    return setting

def set_geometry(value, apply = None):
    """
    """
    if value is None or  (len(value.strip()) == 0):
        set_setting(GEOMETRY_PREFERENCE, "" )
        for name in "wavelength", "hkl_group", "h", "k", "l":
            dev = get_device(name)
            if dev is not None:
                remove_device(dev)
        return
    filename = expand_path("{script}/geometry/"+ str(value)+".py")
    if not os.path.isfile(filename):
        raise Exception("Invalid geometry file: " + value)
    former = get_geometry()
    if ((apply is None) and former != value) or (apply==True) :
        set_setting(GEOMETRY_PREFERENCE, value )
        run(filename)       

def is_geometry_set():
    return get_device("wavelength") is not None

#mu.moveAsync(0.0)
#eta.moveAsync(0.0)
#delta.moveAsync(45.0)
#gamma.moveAsync(0.0)
#energy.write(9.5) 


 
class Counter(ReadonlyRegisterBase):
    def __init__(self, name):
        ReadonlyRegisterBase.__init__(self,name)
        self.start = time.time()
    def doRead(self):
        return int((time.time()-self.start)*1000)

add_device(Counter("counter"), True)        



def trigger_scienta():
    """
    Trigger new acquisition
    """
    scienta.start()
    #scienta.waitNewImage(-1)



###################################################################################################
# Handlig diagnostics 
###################################################################################################

###################################################################################################
# Handlig diagnostics 
###################################################################################################

class AcquisitionMode(Readable.ReadableString):
    def read(self):        
        return str(scienta.getAcquisitionMode())
_acquisition_mode=AcquisitionMode()
        
class EnergyMode(Readable.ReadableString):
    def read(self):        
        return str(scienta.getEnergyMode())
_energy_mode=EnergyMode()        
        
class LensMode(Readable.ReadableString):
    def read(self):        
        return str(scienta.getLensMode())
_lens_mode=LensMode()                
        
class DetectorMode(Readable.ReadableString):
    def read(self):        
        return str(scienta.getDetectorMode())
_detector_mode=DetectorMode()   
        
class PassEnergy(Readable):
    def read(self):        
        return scienta.getPassEnergy()
_pass_energy=PassEnergy()
   
class ElementSet(Readable.ReadableString):
    def read(self):        
        return str(scienta.getElementSet())
_element_set=ElementSet()   

diag_channels = []
 
diag_channels.append(scienta.lowEnergy)    
diag_channels.append(scienta.centerEnergy) 
diag_channels.append(scienta.highEnergy)  
diag_channels.append(scienta.energyWidth)  

diag_channels.append(_acquisition_mode)
diag_channels.append(_energy_mode)
diag_channels.append(_lens_mode)
diag_channels.append(_detector_mode)
diag_channels.append(_pass_energy)
diag_channels.append(_element_set)


diag_channels = sorted(diag_channels, key=lambda channel: channel.name)

def get_diag_name(diag):
    return ch.psi.utils.Str.toTitleCase(diag.getName()).replace(" ", "").replace("Readback", "")
    
def print_diag():
    for f in diag_channels:
        print "%-25s  %s" % (get_diag_name(f) ,  str(f.read()))

def create_diag_datasets(parent = None):
    if parent is None: 
        parent = get_exec_pars().group
    group = parent + "attrs/"
    for f in diag_channels:        
        create_dataset(group+get_diag_name(f) , 's' if (issubclass(type(f), Readable.ReadableString)) else 'd')

def append_diag_datasets(parent = None):
    if parent is None: 
        parent = get_exec_pars().group
    group = parent + "attrs/"
    for f in diag_channels:
        try:
            x = f.read()
            if x is None:
                x = '' if (type(f) is ch.psi.pshell.epics.ChannelString) else float('nan')
            append_dataset(group+get_diag_name(f), x)
        except:
            log("Error sampling " + str(get_diag_name(f)) + ": " + str(sys.exc_info()[1]))


def handle_diagnostics(rec):
    #if beam_ok:     
      if get_exec_pars().save:
          #Saving only once the diag data
          if rec.index == 0:              
              create_diag_datasets()
              append_diag_datasets()


def scan_2d(range_x, range_y, steps_x, steps_y, exposures=None, settling_time=0.1, zigzag=True, compression=False, dry_run=False):
    if type(range_x)==float: range_x =[-range_x, range_x] 
    if type(range_y)==float: range_y =[-range_y, range_y] 
    return run("templates/Scan2D", { \
        "DRY_RUN": dry_run, \
        "RANGE_X": range_x, \
        "RANGE_Y": range_y, \
        "STEPS": [steps_x, steps_y], \
        "EXPOSURES": exposures, \
        "SETTLING_TIME": settling_time, \
        "ZIGZAG": zigzag, \
        "COMPRESSION": compression
    })


"""
add_device(PipelineStream("p","localhost:8889", "simulation_sp"), True)
p.monitored=True

s=p.createSubsampled(1.0)
#show_panel(s)
show_panel(p)
"""

print "Finished initialization"