# -*- coding: cp1252 -*-
'''
Created on 24.11.2011

@author: sth2mt
'''
import time
import threading
import thread
from ctypes import pythonapi, py_object, c_char
import FertigungsTest.GUI.Display as Display
import FertigungsTest.Hardware.StartSchalter as StartSchalter
import FertigungsTest.Hardware.BedienTasten as Key_Evn
import FertigungsTest.Hardware.LtInterface as LtInterface


# <Command>LedTst</Command>
# <Command>exit</Command>

def kill(thread,iStopTimeout,tid):
    if thread:
        thread.printf ("kill iStopTimeout=%d"%iStopTimeout)
        time.sleep(iStopTimeout)
        #nach 30s hart beenden
        if thread.isAlive():
            
            res = pythonapi.PyThreadState_SetAsyncExc(tid,py_object(SystemExit))
            if res == 0:
                raise ValueError("nonexistent thread id (%s)" % thread._Thread_name)
            elif res > 1:
                pythonapi.PyThreadState_SetAsyncExc(tid,0)
                raise SystemError("PyThreadState_SetAsyncExc failed")
            else :
                thread.printf ("kill Thread %s" % thread._Thread_name)
                thread.errorcode=900
                thread.isTimeout=True
                thread.__del__()
        else:
            thread.printf ( "kill %s not allive" % thread._Thread_name)
    else:
        print "kill: no handle"
   
        

class Prueffunktionen(threading.Thread):
    '''
    classdocs
    '''
    def __init__(self, O_Parser,O_Serializer,param=None):
        '''
        Constructor
        '''
        self._Thread_name = "LedTst"
        self.stout = False
        self.printf( "Constructor %s" % self._Thread_name)
        threading.Thread.__init__(self)
        super(Prueffunktionen,self).__init__()
        self._EventStop = threading.Event()
        self.iStopTimeout = 3 # Stop Timeout bis zum Kill
        self.iTimeout = 60 # Timeout bis Abbruch
        self.errorcode=900 # Fehlercode vorbelegen, Wenn Ok wird zurueckgesetzt
        self.isTimeout=False
        self.Leuchtdauer = 4 #in s
        
        self.O_XmlParser = O_Parser
        self.O_XML_Cmd = O_Serializer
        self.O_Display = Display.Treiber()
        self.O_Startschalter = StartSchalter.Treiber()
        self.O_Key_Evn = Key_Evn.Treiber()
        self.O_LT = LtInterface.Treiber()

        self.O_Display.setHeadlines("diagnosis tools","LEDs")
        self.O_Display.paintDisplay()
        
        pass
    
    def __del__(self):
        
        '''
        Destructor
        '''
        if self.errorcode==0:
            sAbruchGrund="OK"
        else:
            sAbruchGrund="NOK"
        self.printf( "Destructor %s" % self._Thread_name)
        # Belegung der Prueffunktion im Parseer objekt loeschen -> Freigabe
        self.printf( "Timeout %i, self._EventStop.isSet() %i"%(self.isTimeout,self._EventStop.isSet()))

        # Display bedienen
        if (self.isTimeout | self._EventStop.isSet()):
            #Abbruch der Funktion -> Fehler anzeigen
            if self._EventStop.isSet():
                sAbruchGrund="Abort"
                self.O_Display.setAction(sAbruchGrund,"","")
            else:
                #Timeout der Funktion -> Fehler anzeigen
                sAbruchGrund="Timeout"
                self.O_Display.setAction(sAbruchGrund,"","")
            self.O_Display.setOKNOK(0)
            self.O_Display.clrSelect()

        print "%s"%self.O_XML_Cmd.BuildRueckgabewert(self._Thread_name,"%s %s"%(self._Thread_name,sAbruchGrund),None,self.errorcode,None)

        self.O_Display.paintDisplay()

        del(self.O_LT)
        del(self.O_Key_Evn)
        del(self.O_Startschalter)
        del(self.O_Display)


        self.O_XmlParser.AktivePrueffunktion=None
        pass

        
    
    def stop(self):
        # Thread normal beenden
        self.printf("stop")
        if self.isAlive():
            self._EventStop.set()
            # Kill-thread falls dieser thread sich nicht nach 30s beendet
            for tid, tobj in threading._active.items():
                if tobj is self:
                    thread.start_new_thread(kill,(self,self.iStopTimeout,tid))
        #print "stop Ende"
        pass
    
    def run(self):
        # Ablauf starten
        self.printf("Ablauf starten")
        print "%s"%self.O_XML_Cmd.BuildTimeout(self.iTimeout,self._Thread_name)
        print "%s"%self.O_XML_Cmd.BuildPrintMainText("LED's pruefen")
        
        # Watchdogtimer anstarten -> beendet Thread anch timeout
        for tid, tobj in threading._active.items():
            if tobj is self:
                thread.start_new_thread(kill,(self,self.iTimeout-self.iStopTimeout-1,tid))

        self.Ablauf()
        self.printf("Nach Ablauf")
        self.__del__()
        pass
    
    def stopped(self):
        return self._EventStop.isSet()


    def Ablauf(self):
        self.printf("Test LED's")
        self.O_Display.ResetLastError()
        self.O_Display.setFortschritt(1)
        print "%s"%self.O_XML_Cmd.BuildProgressbar(1)
        self.O_Display.setActionLP("Look_at_LEDs and_confirm_with gui_buttons")
        #self.O_Display.setAction("Auf LED schauen", "und mit richtiger","Taste best\xc3\xa4tigen")
        
        
        self.O_Display.setSelectMiddle("start")
            
        # Warten auf Betätigung Button "Start der Prüfung
        self.O_Key_Evn.Wait(self.O_Key_Evn.KEY_A, self.O_Key_Evn.KEY_RELEASED)
        self.O_Display.clrSelect()

        
        
        self.O_Display.setFortschritt(5)
        self.printf( ("merker %d prozent %d"%(5,5)))
        print "%s"%self.O_XML_Cmd.BuildProgressbar(5)
        
        time.sleep(1.0)
        if self.TstWhiteLED():
            time.sleep(1.0)
            self.O_Key_Evn.ReadTasten()
            self.TstColorLED()
        
        
                              
                
        self.O_Display.clrSelect()
        if self.errorcode==0: # Led's OK
            self.O_Display.setOKNOK(1)
        else:
            self.O_Display.setOKNOK(0)


        self.O_Display.setFortschritt(90)
        self.printf( ("merker %d prozent %d"%(90,90)))
        print "%s"%self.O_XML_Cmd.BuildProgressbar(90)
        if self.errorcode==0: # Startschalter OK
            self.O_Display.setSelectLP("Confirm with_to ol_switch")
            #self.O_Display.setSelectLeft("Weiter ")
            #self.O_Display.setSelectMiddle("mit Start")
            #self.O_Display.setSelectRight("schalter")
            
            #Ergebnis bestaetigen
            self.O_Startschalter.Wait(True,self.stopped)
            # Bildschirm zuruecksetzen auf Default
            self.O_Display.BuildDefaultScreen()

        self.O_Display.setFortschritt(100)
        self.printf( ("merker %d prozent %d"%(100,100)))
        print "%s"%self.O_XML_Cmd.BuildProgressbar(100)
            

        self.printf("LED's Pr\xc3\xbcfung -> Ende")

        pass

    def TstWhiteLED(self):
        
        self.O_Display.setActionLP("Thigtening position illumination_?")
        #self.O_Display.setAction("Schraubstellen-", "LED","?")
        
        # Zufalls Reihenfolge aus Systemzeit in sec ermittel
        Tastenfolge = [self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_A,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_A,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_A,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_A]
        char = [Tastenfolge[ord(time.strftime("%S")[1])-48]] #Zufallszahl zwischen 1 und 10 erzeugen
        for i in range (0,Tastenfolge.count(char[0])):
            Tastenfolge.remove(char[0])# gezogenes Zeichen aus Liste entfernen da nur einmal verwendet werden darf
        char.append(Tastenfolge[ord(time.strftime("%S")[0])-48]) #Zufallszahl zwischen 0 und 6 erzeugen
        for i in range (0,Tastenfolge.count(char[1])):
            Tastenfolge.remove(char[1])# gezogenes Zeichen aus Liste entfernen da nur einmal verwendet werden darf
        char.append(Tastenfolge[0])
        
        self.printf(char)
        for i in range (0,1,1):
            if self.stopped():
                self.errorcode=901
                return
            self.printf(char[i])
            self.O_Display.setFortschritt(10+(i*13))
            print "%s"%self.O_XML_Cmd.BuildProgressbar(10+(i*13))
            self.O_Display.clrSelect()
            if char[i] == self.O_Key_Evn.KEY_RIGHT:
                self.dimming(self.Leuchtdauer)
            if char[i] == self.O_Key_Evn.KEY_LEFT:
                self.flashing(self.Leuchtdauer)
            if char[i] == self.O_Key_Evn.KEY_A:
                self.an(self.Leuchtdauer)
            self.O_Display.setSelectKey(self.O_Key_Evn.KEY_A, "/ on \\",self.O_Display.sColorBlack,self.O_Display.sColorWhite)
            self.O_Display.setSelectKey(self.O_Key_Evn.KEY_LEFT, "<-flash",self.O_Display.sColorBlack,self.O_Display.sColorGrey)
            self.O_Display.setSelectKey(self.O_Key_Evn.KEY_RIGHT, "sweep->",self.O_Display.sColorBlack,self.O_Display.sColorLightGrey)
            Taste=self.O_Key_Evn.Wait(self.O_Key_Evn.KEY_A|self.O_Key_Evn.KEY_LEFT|self.O_Key_Evn.KEY_RIGHT, self.O_Key_Evn.KEY_PRESS)
            self.printf( ("%s.Ablauf Taste =0x%x char[%i]=0x%x"%(self._Thread_name, Taste,i,char[i])))
            if Taste != char[i]:
                self.printf( ("%s.Ablauf error=%d "%(self._Thread_name, self.errorcode)))
                self.errorcode=902
                return False #Abbruch
            else:
                self.errorcode = 0
        self.O_Display.setFortschritt(10+(3*13))
        print "%s"%self.O_XML_Cmd.BuildProgressbar(10+(3*13))
       
        return True

    def TstColorLED(self):
        
        self.O_Display.setActionLP("color_of LED_?")
        #self.O_Display.setAction("", "LED","Farbe ?")
        
        # Zufalls Reihenfolge aus Systemzeit in sec ermittel
        Tastenfolge = [self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_A,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_A,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_LEFT,self.O_Key_Evn.KEY_A,self.O_Key_Evn.KEY_RIGHT,self.O_Key_Evn.KEY_A]
        char = [Tastenfolge[ord(time.strftime("%S")[1])-48]] #Zufallszahl zwischen 1 und 10 erzeugen
        for i in range (0,Tastenfolge.count(char[0])):
            Tastenfolge.remove(char[0])# gezogenes Zeichen aus Liste entfernen da nur einmal verwendet werden darf
        char.append(Tastenfolge[ord(time.strftime("%S")[0])-48]) #Zufallszahl zwischen 0 und 6 erzeugen
        for i in range (0,Tastenfolge.count(char[1])):
            Tastenfolge.remove(char[1])# gezogenes Zeichen aus Liste entfernen da nur einmal verwendet werden darf
        char.append(Tastenfolge[0])
        
        self.printf(char)
        for i in range (0,3,1):
            if self.stopped():
                self.errorcode=903
                return
            self.printf(char[i])
            self.O_Display.setFortschritt(50+(i*13))
            print "%s"%self.O_XML_Cmd.BuildProgressbar(50+(i*13))
            self.O_Display.clrSelect()
            if char[i] == self.O_Key_Evn.KEY_RIGHT:
                self.O_LT.SetLEDBlue(255)
            if char[i] == self.O_Key_Evn.KEY_LEFT:
                self.O_LT.SetLEDGreen(255)
            if char[i] == self.O_Key_Evn.KEY_A:
                self.O_LT.SetLEDRed(255)
            time.sleep(2.0)
            self.O_Display.setSelectKey(self.O_Key_Evn.KEY_A, "red",None,self.O_Display.sColorRed)
            self.O_Display.setSelectKey(self.O_Key_Evn.KEY_LEFT, "<-green",None,self.O_Display.sColorGreen)
            self.O_Display.setSelectKey(self.O_Key_Evn.KEY_RIGHT, "blue->",None,self.O_Display.sColorLightBlue)
            Taste=self.O_Key_Evn.Wait(self.O_Key_Evn.KEY_A|self.O_Key_Evn.KEY_LEFT|self.O_Key_Evn.KEY_RIGHT, self.O_Key_Evn.KEY_PRESS)
            self.O_LT.SetLEDRGB(0, 0, 0)
            self.printf( ("%s.Ablauf Taste =0x%x char[%i]=0x%x"%(self._Thread_name, Taste,i,char[i])))
            if Taste != char[i]:
                self.printf( ("%s.Ablauf error=%d "%(self._Thread_name, self.errorcode)))
                self.errorcode=904
                return False #Abbruch
            else:
                self.errorcode = 0
        
        return True



    def dimming(self,dauer):
        cycletime = 1
        
        nmal=int(dauer/cycletime)
        while 0 < nmal:
            self.O_LT.LEDSoftBlink(cycletime)
            nmal=nmal-1
        pass
    
    def an(self,dauer,LEDNr=0):
        self.O_LT.SetLED(255)
        time.sleep(dauer)
        self.O_LT.SetLED(0)

        pass
    
    def flashing(self,dauer,LEDNr=0):
        cycletime = 0.25
        
        nmal=int(dauer/cycletime)
        while 0 < nmal:
            self.O_LT.SetLED(255)
            time.sleep(cycletime/100)
            self.O_LT.SetLED(0)
            time.sleep(cycletime/100*99)
            nmal=nmal-1
        
        pass

    
    def printf(self,string):
        if self.stout:
            print string
        pass


            
    
    def TestMenue(self,O_Paint):
        if O_Paint:
            O_Paint.SetTestText(["Startschalter bet\xc3\xa4tigen"])
            O_Paint.Update()
            Input = ' '
            while Input!= "z":
                Input=O_Paint.TestfunktionsEingabe()
                O_Paint.Update()
            
                O_Paint.Update()
                O_Paint.ClearTestText()
                return Input

        pass

    
    pass