"""
Arguments:

"""

MOTORS = [Eph]
POSITIONS = [400.0, 401.0]
LATENCY = 0.0

REGION1 = {'elo': 243.0, 'ehi': 245.0, 'estep': 0.1, 'epass': 50, 'tstep': 0.1, 'iter': 1, 'cis': True}
REGION2 = {'elo': 214.0, 'ehi': 217.0, 'estep': 0.1, 'epass': 50, 'tstep': 0.1, 'iter': 1, 'cis': False}
REGIONS = [REGION1, REGION2]

CLOSE_SHUTTER_AT_END = True

Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept)

class SpectrumReader(ReadonlyRegisterBase, ReadonlyRegisterArray):
    def initialize(self):
        #super(SpectrumReader, self).initialize()
        self.scan_index = -1

    def create_datasets(self):
        path = get_exec_pars().scanPath

        self.channel_begin_dataset_name = path + "ScientaChannelBegin{0}".format(self.region_index + 1)
        self.channel_end_dataset_name = path + "ScientaChannelEnd{0}".format(self.region_index + 1)
        self.pass_energy_dataset_name = path + "ScientaPassEnergy{0}".format(self.region_index + 1)
        self.step_energy_dataset_name = path + "ScientaStepEnergy{0}".format(self.region_index + 1)
        self.step_time_dataset_name = path + "ScientaStepTime{0}".format(self.region_index + 1)
        self.iterations_dataset_name = path + "ScientaIterations{0}".format(self.region_index + 1)
        
        create_dataset(self.channel_begin_dataset_name, 'd')
        create_dataset(self.channel_end_dataset_name, 'd')
        create_dataset(self.pass_energy_dataset_name, 'd')
        create_dataset(self.step_energy_dataset_name, 'd')
        create_dataset(self.step_time_dataset_name, 'd')
        create_dataset(self.iterations_dataset_name, 'd')
        
    def setup(self):
        if self.scan_index != get_exec_pars().index:
            self.scan_index = get_exec_pars().index
            self.create_datasets()
            if self.region_index == 0:
                print "scan {0}".format(self.scan_index)
            
        ephot = Eph.read()
        try:
            if self.region['cis']:
                edelta = ephot - self.ephot_start
            else:
                edelta = 0.0
        except AttributeError:
            self.ephot_start = ephot
            edelta = 0.0
            
        elo = self.region['elo'] + edelta
        ehi = self.region['ehi'] + edelta

        Scienta.lowEnergy.write(elo)
        Scienta.highEnergy.write(ehi)
        Scienta.stepSize.write(self.region['estep'])
        Scienta.setPassEnergy(self.region['epass'])
        Scienta.stepTime.write(self.region['tstep'])
        Scienta.setIterations(self.region['iter'])
        Scienta.update()

        append_dataset(self.channel_begin_dataset_name, elo)
        append_dataset(self.channel_end_dataset_name, ehi)
        append_dataset(self.pass_energy_dataset_name, self.region['epass'])
        append_dataset(self.step_energy_dataset_name, self.region['estep'])
        append_dataset(self.step_time_dataset_name, self.region['tstep'])
        append_dataset(self.iterations_dataset_name, self.region['iter'])

    def read(self):
        self.setup()
        print "Photon energy {ephot} eV. Acquiring spectrum {elo}-{ehi} eV.".format(ephot=Eph.read(), elo=Scienta.lowEnergy.value, ehi=Scienta.highEnergy.value)
        trig_scienta()
        time.sleep(0.5)
        sp = Scienta.getSpectrum().read()
        return sp

    def getSize(self):
        nx = int((self.region['ehi'] - self.region['elo']) / self.region['estep']) + 1
        return nx


class ImageReader(ReadonlyRegisterBase, ReadonlyRegisterMatrix):   
    def read(self):
        return Scienta.getDataMatrix().read()

    def getWidth(self):
        nx = int((self.region['ehi'] - self.region['elo']) / self.region['estep']) + 1
        return nx

    def getHeight(self):
        ny = Scienta.slices.read()
        return ny

# plotting current spectrum
#names = "Scienta spectrum"
#plots = plot(None, names)
global spectrum_series
spectrum_series = None #plots[0].getSeries(0)
task = None

def plot_cur_spectrum():
    global spectrum_series
    try:
        while get_context().state.running:
            if spectrum_series is None:
                print "create new plot"
                names = "Scienta spectrum"
                plots = plot(None, names)
                spectrum_series = plots[0].getSeries(0)
                
            y = Scienta.spectrum.take(100)
            x = Scienta.spectrumX
            spectrum_series.setData(x, y)        
            time.sleep(1.0)
    finally:
        print "Stopping spectrum plotting"        

def do_scan(motors, positions, regions, latency):
    global SENSORS
    
    SENSORS = []
    
    for (index, region) in enumerate(regions):
        reader = SpectrumReader()
        reader.region_index = index
        reader.region = region
        reader.initialize()
        set_device_alias(reader, "ScientaSpectrum{0}".format(index + 1))
        SENSORS.append(reader)

        image = ImageReader()
        image.region_index = index
        image.region = region
        image.initialize()
        set_device_alias(image, "ScientaImage{0}".format(index + 1))
        SENSORS.append(image)

    SENSORS.append(SampleCurrent)
    SENSORS.append(RefCurrent)
    adjust_sensors()
    set_adc_averaging()

    vscan(motors, SENSORS, positions, True, latency,False, before_read=wait_beam, after_read = after_readout)


try:
    #set_preference(Preference.PLOT_TYPES, {'ScientaSpectrum1':1})
    task = fork(plot_cur_spectrum)
    do_scan(MOTORS, POSITIONS, REGIONS, LATENCY)
finally:
    if CLOSE_SHUTTER_AT_END:
        after_scan()