import ch.psi.pshell.epics.Motor 


class WireScanInfo(DeviceBase):
    def __init__(self, name, prefix):
        self.prefix = prefix
        self.status_channels=[]
        for s in ("SCANNING", "SCAN_DONE", "INITIALIZING", "INIT_DONE", "ABORTED", "ERROR"):
            c = Channel(self.prefix + ":" + s, 'i', callback = self.on_status_change);
            c.set_monitored(True)
            self.status_channels.append(c)
        self.on_status_change(None)
        self.initialize()   

    def on_status_change(self, val):
        try:
            if self.status_channels[0].get() == 1: 
                self.setCache("scanning", None)
                self.setState(State.Busy)
            elif self.status_channels[1].get() == 1: 
                self.setCache( "scan done", None)
                self.setState(State.Ready)
            elif self.status_channels[2].get() == 1: 
                self.setCache("traveling", None)
                self.setState(State.Initializing)
            elif self.status_channels[3].get() == 1: 
                self.setCache("at start", None)
                self.setState(State.Ready)
            elif self.status_channels[4].get() == 1: 
                self.setCache("abort", None)
                self.setState(State.Ready)
            elif self.status_channels[5].get() == 1: 
                self.setCache("error", None)
                self.setState(State.Fault)
            else: 
                pass #All zero, a transition
        except:
            self.setCache("offline", None)
            self.setState(State.Offline)    

    def doClose(self):      
        for c in self.status_channels:
            c.close()
                
def newScanInfoDevice(name, prefix): 
    return WireScanInfo(name, prefix)

 
class WireScanner(WireScanInfo):
    Selection = [Garage, W1X, W1Y, W2X, W2Y, Foil] = "GARAGE", "W1X", "W1Y", "W2X", "W2Y", "FOIL"

    def __init__(self, prefix, sel = None,  start=None , end=None, cycles=None, velocity=None, continuous = None):
        WireScanInfo.__init__(self, "Wire Scan " + prefix, prefix)        
        self.motor = ch.psi.pshell.epics.Motor("WireScanner motor", self.prefix + ":MOTOR_1")               
        self.motor.initialize()
        self.motor_bs_readback = Channel(self.prefix + ":ENC_1_BS")
        self.wire_velocity = Channel(self.prefix + ":SCAN_VELO_SP")           #wire coordinates
        self.motor_velocity = Channel(self.prefix + ":SCAN_M_VELO")      #motor coordinates
        self.travel_velocity = Channel(self.prefix + ":TRAVEL_VELO_SP")  #motor coordinates       
        self.nb_cycles = Channel(self.prefix + ":NB_CYCL_SP", 'l')
        self.curr_cycl = Channel(self.prefix + ":CURR_CYCL", 'l', callback = self.on_cycle_change)
        self.curr_cycl.set_monitored(True)
        set_device_alias(self.curr_cycl, "current_cycle")
        self.wire_sel = Channel(self.prefix + ":WIRE_SP", 'l')
        self.current_cycle = self.curr_cycl.get()
        self.selection = None
        self.u0 = None
        self.offset = None
        self.range = None
        self.start = None
        self.end = None
        if sel is not None:
            self.set_selection(sel)
            
        #Setting parameters
        if start is not None: 
            self.start.write(float(start))
        if end is not None: 
            self.end.write(float(end))
        if cycles is not None: 
            self.nb_cycles.write(int(cycles))
        if velocity is not None: 
            self.wire_velocity.write(float(velocity))   
        if continuous is not None: 
            caputq(self.prefix + ":SCAN_MODE_SP", 0 if continuous else 1)
        
        self.cycles = self.nb_cycles.get()
        self.velocity = self.wire_velocity.get()
        self.scan_range = [self.start.get(), self.end.get()]
        self.initialize()   
                
    def on_cycle_change(self, val):
        #print "Wire scan cycle change: ", val
        self.current_cycle = val

    def set_selection(self, sel):
        if not sel in WireScanner.Selection:
            raise Exception("Invalid Wire Scan selection: " + str(sel))
        self.selection = sel
        self.u0 = Channel(self.prefix + ":" + self.selection + "_U0_SP")
        self.offset = Channel(self.prefix + ":" + self.selection + "_OFF_SP")
        self.range = Channel(self.prefix + ":" + self.selection + "_RANGE_SP")
        self.start = Channel(self.prefix + ":" + self.selection + "_START_SP")
        self.end = Channel(self.prefix + ":" + self.selection + "_END_SP")        
        self.wire_sel.put(WireScanner.Selection.index(sel))        

    def doClose(self):  
        WireScanState.doClose(self)
        self.motor.close()
        self.motor_bs_readback.close()
        self.wire_velocity.close()
        self.motor_velocity.close()
        self.travel_velocity.close()
        self.nb_cycles.close()
        self.curr_cycl.close()
        self.wire_sel.close()
        if self.u0 is not None:  self.u0.close()
        if self.offset is not None:  self.offset.close()
        if self.range is not None:  self.range.close()
        if self.start is not None:  self.start.close()
        if self.end is not None:  self.end.close()

    def get_cicle_time(self):
        range = abs(self.start.get() -self.end.get())
        speed = self.motor_velocity.get()
        return (range / speed)

    def get_total_time(self):
        return self.get_cicle_time() * self.cycles

    def abort(self):
        caputq("SINDI01-DWSC090:ABORT.PROC", 1)

    def init(self):
        caputq("SINDI01-DWSC090:INIT.PROC", 1)

    def park(self):
        caputq("SINDI01-DWSC090:GARAGE_SEL.PROC", 1)

    def scan(self):
        self.cycles = self.nb_cycles.get()
        caputq("SINDI01-DWSC090:SCAN_WIRE", 1)