'''
Created on 24.11.2011

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

# <Command>CntrlBtnTst</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=700
                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
        '''
        threading.Thread.__init__(self)
        super(Prueffunktionen,self).__init__()
        self._EventStop = threading.Event()
        self.iStopTimeout = 3 # Stop Timeout bis zum Kill
        self.iTimeout = 60 # Stop Timeout bis zum Kill
        self.errorcode=700 # Fehlercode vorbelegen, Wenn Ok wird zurueckgesetzt
        self._Thread_name = "CntrlBtnTst"
        self.stout = False
        self.errorcode = 0
        self.isTimeout=False
        self.GoeppelBremse=True

        
        self.O_XmlParser = O_Parser
        self.O_XML_Cmd = O_Serializer
        self.O_Key_Evn = Key_Evn.Treiber()
        self.O_Display = Display.Treiber()
        self.O_Startschalter = StartSchalter.Treiber()
        self.printf("Bedienelemente Test")
        self.O_Display.setHeadlines("diagnosis tools","function buttons")
        self.O_Display.setAction("","","")
        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_Key_Evn)
        del(self.O_Display)
        del(self.O_Startschalter)
        # Belegung der Prueffunktion im Parseer objekt loeschen -> Freigabe
        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("Bedienelemente am Display 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))

        if self.GoeppelBremse:
            time.sleep(3)
        self.Ablauf()
        self.printf("Nach Ablauf")
        self.__del__()
        pass
    def stopped(self):
        return self._EventStop.isSet()


    def Ablauf(self):
        self.O_Display.ResetLastError()
        self.O_Display.setActionLP("Push red buttons")
        self.O_Display.setFortschritt(1)
        print "%s"%self.O_XML_Cmd.BuildProgressbar(1)
        
        # 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=700
                return
            self.printf(char[i])
            self.O_Display.setFortschritt(1+(i*32))
            print "%s"%self.O_XML_Cmd.BuildProgressbar(1+(i*32))
            self.O_Display.clrSelect()
            if char[i] == self.O_Key_Evn.KEY_A:
                self.O_Display.setSelectKey(char[i], "-v- here")
            if char[i] == self.O_Key_Evn.KEY_LEFT:
                self.O_Display.setSelectKey(char[i], "v-- here")
            if char[i] == self.O_Key_Evn.KEY_RIGHT:
                self.O_Display.setSelectKey(char[i], "here --v")
            self.O_Display.paintDisplay()
            self.O_Key_Evn.Wait(char[i], self.O_Key_Evn.KEY_RELEASED,time.sleep(0.1))
            self.O_Display.clrSelect()
            self.O_Display.paintDisplay()


        self.O_Display.setFortschritt(90)
        print "%s"%self.O_XML_Cmd.BuildProgressbar(90)
        self.errorcode=0 # Ok
        self.O_Display.setOKNOK(1)
        #self.O_Display.setAction("","","")
        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")
            self.O_Display.paintDisplay()
            
            #Ergebnis bestaetigen
            self.O_Startschalter.Wait(True,self.stopped)
            # Bildschirm zuruecksetzen auf Default
            self.O_Display.BuildDefaultScreen()

        self.O_Display.setFortschritt(100)
        print "%s"%self.O_XML_Cmd.BuildProgressbar(100)
        
            
        self.printf("Bedienelemente Test -> Ende")
        

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

    pass

pass