from core.appfw.config import Config
from core.lib.logger import RobotLogger
from sikuli.Constants import FOREVER
from sikuli.Screen import Screen
from core.lib.wrapper import Region
from core.appfw.base import ImageRegion
#import threading
from java.lang import Thread
import sys


class HandleableDialog(object):

    log = None
    observerSets = []
    name = "test"
    thread = None

    def __init__(self):
        self.log = RobotLogger()
        self.log.debug("Handle init for %s" % self.__class__.__name__)
        self.thread = Thread.currentThread() # use java thread instead of python, has methods for sleeping

    def handle(self, event):

        region = None
        image = None

        # Find the region for this thread
        for observerSet in self.observerSets:
            if observerSet[1] == Thread.currentThread():
                region = observerSet[0]
                image = observerSet[2]

        self.log.info('Handler triggered by ["%s"](baseline:%s,actual:%s) on ["%s"](%s)' % (event.match, self.log.image(image), self.log.region(event.match), event.region, self.log.region()))

        # Stop everything!!
        self.stopObserving() # stop all the other observing threads
        self.thread.suspend() # suspend main thread while handling dialog

        # Handle the event
        try:
            self.handleDialog(event)
        except Exception, e:
            print e

        # Re-start everything
        self.thread.resume() #resume main thread
        self.startObserving() # start observing again


        # Restart observation on this region
        try:
            self.log.debug("Resuming observation on thread %s" % Thread.currentThread())
            #region.observe(FOREVER)
        except:
            self.log.error("Unable to resume observation on %s" % Thread.currentThread())

    def handleDialog(self, event):
        self.log.warn("TODO: Implement dialog handler event=%s" % event);

    def register(self):

        # format: Classname[handle].png
        ir = ImageRegion(self, state="handle")
        for filename in ir.getImageNames():

            # Make sure to get pattern in case png has extra attributes
            pattern, attribs = ir.getPatternFromFilename(filename)

            # http://sikuli.org/docx/region.html#Region.observe
            # For each region object, only one observation can be running at a given time.
            region = Region(Config.screen)
            region.onAppear(pattern, self.handle)

            # Get the thread for this observance
            threadsBefore = Thread.getAllStackTraces()
            region.observe(FOREVER, background=True) # thread is created
            threadsAfter = Thread.getAllStackTraces()
            thread = list(set(threadsBefore) ^ set(threadsAfter))[0] # difference of before after
            thread.suspend() # start of suspended

            self.observerSets.append([region, thread, filename])
            self.log.debug("adding handle dialog trigger [%s](%s) thread=%s" % (filename, self.log.image(filename), thread))

        self.startObserving() # automatically start observing ??

    def startObserving(self):

        self.log.debug("starting observing all handleable dialogs")
        for observerSet in self.observerSets:
            observerSet[1].resume()

    def stopObserving(self):

        self.log.debug("stop observing all handleable dialogs")
        # stop observing on all regions by suspending threads
        for observerSet in self.observerSets:

            # If this is the active thread, don't suspend ourself
            if Thread.currentThread() != observerSet[1]:
                observerSet[1].suspend()

    def formatPrefix(self, *args, **args):

        return "[Test] "

class DialogHandlerController(object):
    """ Register dialogs to be handled """

    log = None
    instances = None

    def __init__(self, *args, **kwargs):


        self.instances = []
        self.log = RobotLogger(entity=self)
        self.log.debug("started")

        # Register all classes which subclass HandleableDialog
        for appCls in HandleableDialog.__subclasses__():
            self.log.debug("Adding [%s]" % appCls.__name__)

            instance = appCls() # create instance of the handleable dialog
            instance.register() # register the observation
            self.instances.append(instance) # keep trace of the handler instance



    def formatPrefix(self, *args, **args):

        return "[DialogHandler Controller] "