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

@author: sth2mt
'''

import time
import threading
import thread
from ctypes import pythonapi, py_object
import FertigungsTest.GUI.Display as Display
import FertigungsTest.Hardware.StartSchalter as StartSchalter
import FertigungsTest.Hardware.Sound as Sound
import FertigungsTest.Hardware.BedienTasten as Key_Evn

# <Command>LdSpkTst</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=800
                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 = "LdSpkTst"
        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=800 # Fehlercode vorbelegen, Wenn Ok wird zurueckgesetzt
        self.isTimeout=False
        self.iWiederholungen=2 # Max 2 Versuche
        self.sWavFiles = ["Button Left Man.wav","Button Left Woman.wav",
                          "Button Middle Man.wav","Button Middle Woman.wav",
                          "Button Right Man.wav","Button Right Woman.wav"]
        self.sWavPath = "/home/tool/bin/sounds/"        
        
        self.O_XmlParser = O_Parser
        self.O_XML_Cmd = O_Serializer
        self.O_Display = Display.Treiber()
        self.O_Startschalter = StartSchalter.Treiber()
        self.O_Sound = Sound.Treiber()
        self.O_Key_Evn = Key_Evn.Treiber()
        self.O_Display.setHeadlines("diagnosis tools","loudspeaker")
        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_Sound)
        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("Lautsprecher 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))

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


    def Ablauf(self):
        self.printf("Lautsprecher Test")
        self.O_Display.ResetLastError()
        self.O_Display.setActionLP("Please follow_voice instruction !")
        #self.O_Display.setAction("Bitte", "Sprachanweisung","folgen !")
        
        self.O_Display.setFortschritt(1)
        print "%s"%self.O_XML_Cmd.BuildProgressbar(1)
       
        self.O_Display.setSelectMiddle("start")
        # Wiederholungzaehler herunterzaehlen
        self.iWiederholungen = self.iWiederholungen - 1

        # 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_Sound.setVolume(100)

        # 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,2,1):
            if self.stopped():
                self.errorcode=800
                return
            self.printf(char[i])
            self.O_Display.setFortschritt(25+(i*32))
            print "%s"%self.O_XML_Cmd.BuildProgressbar(25+(i*32))
            self.O_Display.clrSelect()
            if char[i] == self.O_Key_Evn.KEY_A:
                self.O_Sound.playSound(self.sWavPath+self.sWavFiles[2+i])
                if self.stout:
                    self.O_Display.setSelectKey(char[i], "-v- here")
            if char[i] == self.O_Key_Evn.KEY_LEFT:
                self.O_Sound.playSound(self.sWavPath+self.sWavFiles[i])
                if self.stout:
                    self.O_Display.setSelectKey(char[i], "v-- here")
            if char[i] == self.O_Key_Evn.KEY_RIGHT:
                self.O_Sound.playSound(self.sWavPath+self.sWavFiles[4+i])
                if self.stout:
                    self.O_Display.setSelectKey(char[i], "here --v")
            self.O_Display.paintDisplay()
            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=800
                break #Abbruch
            else:
                self.errorcode = 0
                                
                
        self.O_Display.clrSelect()
        if self.errorcode==0: # Lautsprecher OK
            self.O_Display.setOKNOK(1)
        else:
            self.O_Display.setOKNOK(0)


        self.O_Display.setFortschritt(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")
            # Keine Wiederholung mehr notwendig -> auf 0 setzen
            self.iWiederholungen=0
            
            #Ergebnis bestaetigen
            self.O_Startschalter.Wait(True,self.stopped)
            # Bildschirm zuruecksetzen auf Default
            self.O_Display.BuildDefaultScreen()
        else:
            if self.iWiederholungen:
                self.O_Display.setSelectLeft("NOK",self.O_Display.sColorWhite,self.O_Display.sColorBlack)
                self.O_Display.setSelectMiddle(" ")
                self.O_Display.setSelectRight("again",self.O_Display.sColorWhite,self.O_Display.sColorBlack)
                #Ergebnis bestaetigen
                Taste=self.O_Key_Evn.Wait(self.O_Key_Evn.KEY_LEFT|self.O_Key_Evn.KEY_RIGHT, self.O_Key_Evn.KEY_PRESS)
                if Taste == self.O_Key_Evn.KEY_LEFT:
                    # Abbruch mit NOK
                    self.iWiederholungen=0
                    self.O_Display.setSelectLeft(" ",self.O_Display.sColorWhite,self.O_Display.sColorBlack)
                    self.O_Display.setSelectMiddle(" ",self.O_Display.sColorWhite,self.O_Display.sColorBlack)
                    self.O_Display.setSelectRight(" ",self.O_Display.sColorWhite,self.O_Display.sColorBlack)
                else :
                    # Bildschirm zuruecksetzen auf Default
                    self.O_Display.BuildDefaultScreen()

        self.O_Display.setFortschritt(100)
        print "%s"%self.O_XML_Cmd.BuildProgressbar(100)
        
        
        self.printf("Lautsprecher P\xc3\xbcfung -> Ende")

        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