import os

import multiprocessing

import threading

import logging as log

import PIL

from util import MsgQueue

from gui import gui

from analyzer import ImageAnalyzer

from go.core import Go, isLegalPosition

from statebag import StateBag

import config as cfg

class Core:

	def __init__(self):

		self.grid=None

		self.go=Go()

		self.detector=ImageAnalyzer()

		self.states=StateBag()

		self._ownMessages=MsgQueue(self._handleEvent)

		self._guiMessages=MsgQueue()

		self._imgs=sorted(os.listdir(cfg.misc.imgDir))

		self._imgIndex=cfg.misc.defaultImage

		imgPath=os.path.join(cfg.misc.imgDir,self._imgs[self._imgIndex])

		self._frame=PIL.Image.open(imgPath)

		self._guiProc=multiprocessing.Process(name="gui", target=gui, args=(self._guiMessages,self._ownMessages))

		self._guiProc.start()

		self.relativeFrame(0)

	def setCorners(self,corners):

		self.detector.setGridCorners(corners)

		self.analyze()

	def setTresholds(self,tresB=None,tresW=None):

		if tresB is not None: self.detector.tresB=tresB

		if tresW is not None: self.detector.tresW=tresW

		self.analyze()

	def relativeFrame(self,step):

		self._imgIndex=(self._imgIndex+step)%len(self._imgs)

		imgPath=os.path.join(cfg.misc.imgDir,self._imgs[self._imgIndex])

		self._frame=PIL.Image.open(imgPath)

		self._guiMessages.send("setCurrentFrame",(self._frame.copy(),))

		self.analyze()

	def analyze(self):

		if self.detector.analyze(self._frame):

			if isLegalPosition(self.detector.board):

				self.states.pushState(self.detector.board)

				self._guiMessages.send("setGameState",(self.detector.board,))

				self.go.transitionMove(self.detector.board)

				log.debug("game record: %s",self.go._record)

			else:

				log.info("illegal position detected")

	def listen(self):

		listenerThread=threading.Thread(target=lambda: self._ownMessages.listen())

		listenerThread.start()

	def joinGui(self):

		self._guiProc.join()

	def _handleEvent(self,e):

		actions={

			"setCorners": self.setCorners,

			"setTresholds": self.setTresholds,

			"prevFrame": lambda: self.relativeFrame(-1),

			"nextFrame": lambda: self.relativeFrame(1)

		}

		(actionName,args,kwargs)=e

		return actions[actionName](*args,**kwargs)

core=Core()

core.listen()

core.joinGui()

"""

core

====

grid

go

imageAnalyzer

gui

===

corners

a) keeps references to important objects and uses them

b) gets and sets all relevant data through method calls with core

GUI

<- addCorner(corner)

-> redrawImgView(img,grid)

<- refreshTresholds(tresB,tresW)

BoardView

-> redrawState(go)

core-gui: just pass messages with relevant data (!! always pass object copies, don't share instances)

"""

import threading

import tkinter as tk

import config

from .mainwindow import MainWindow

from .boardview import BoardView

from .settings import Settings

class GUI:

	def __init__(self):

		self.root = tk.Tk()

		self.root.title("OneEye {0}.{1}.{2}".format(*config.misc.version))

		self.root.option_add('*tearOff',False) # for menu

		self._coreMessages=None

		self.mainWindow = MainWindow(self, master=self.root)

		self.root.columnconfigure(0,weight=1)

		self.root.rowconfigure(0,weight=1)

		self.root.bind("<<redrawImgView>>", lambda e: self.mainWindow.redrawImgView())

		self.root.bind("<Left>",lambda e: self.sendMsg("prevFrame"))

		self.root.bind("<Right>",lambda e: self.sendMsg("nextFrame"))

		self.root.bind("<F12>",lambda e: Settings(self))

	def __call__(self,ownMessages,coreMessages):

		self._coreMessages=coreMessages

		self.listenerThread=threading.Thread(target=lambda: ownMessages.listen(self._handleEvent))

		self.listenerThread.start()

		self.mainWindow.mainloop()

	def sendMsg(self,actionName,args=tuple(),kwargs=None):

		self._coreMessages.send(actionName,args,kwargs)

	def _handleEvent(self,e):

		actions={"setCurrentFrame":self._frameHandler, "setGameState":self._stateHandler}

		(actionName,args,kwargs)=e

		return actions[actionName](*args,**kwargs)

	def _frameHandler(self,newFrame):

		self.mainWindow.setCurrentFrame(newFrame)

		self.root.event_generate("<<redrawImgView>>")

	def _stateHandler(self,gameState):

		self.mainWindow.boardView.redrawState(gameState)

gui=GUI()