import multiprocessing
import threading
import logging
import PIL
from util import MsgQueue
from gui import gui
from analyzer import ImageAnalyzer
from analyzer.framecache import FrameCache
from go.core import Go, isLegalPosition
from statebag import StateBag
from video import capVideo
import config as cfg

log=logging.getLogger(__name__)


class Core:
	def __init__(self):
		self.grid=None
		self.go=Go()
		self.detector=ImageAnalyzer()
		self._cache=FrameCache()
		self.states=StateBag()

		self._ownMessages=MsgQueue(self._handleEvent)
		self._guiMessages=MsgQueue()
		self._vidMessages=MsgQueue()

		self._frame=None

		self._guiProc=multiprocessing.Process(name="gui", target=gui, args=(self._guiMessages,self._ownMessages))
		self._guiProc.start()
		self._vidProc=multiprocessing.Process(
			name="video",
			target=capVideo,
			args=(cfg.misc.video, self._vidMessages,self._ownMessages)
		)
		self._vidProc.start()

	def showFrame(self,key):
		frame=self._cache.get(key)
		if frame is None:
			(key,frame)=self._cache.getRelative(10)
		self._guiMessages.send("setCurrentFrame", (frame.copy(), gui.PREVIEW, key))

	def putFrame(self,frame):
		self._frame=PIL.Image.fromarray(frame)
		k=self._cache.put(self._frame)
		self._guiMessages.send("setCurrentFrame", (self._frame, gui.RECORDING, k))
		self.analyze()

	def sendParams(self):
		self._guiMessages.send("setParams",(self.detector.params.copy(),))

	def setParams(self,params):
		self.detector.setParams(params)

	def analyze(self):
		if self.detector.analyze(self._frame):
			if isLegalPosition(self.detector.board):
				state=self.states.pushState(self.detector.board)
				rec=[]
				if state:
					rec=state.exportRecord()
					log.debug("progressive game record: %s",rec)
				self._guiMessages.send("setGameState", (self.detector.board,rec))

				self.go.transitionMove(self.detector.board)
				log.debug("conservative 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 joinChildren(self):
		self._guiProc.join()
		self._vidMessages.send("shutDown")
		self._vidProc.join()
		self._ownMessages.send("!kill",("core",))

	def _handleEvent(self,e):
		actions={
			"prevFrame": lambda: self.relativeFrame(-1),
			"nextFrame": lambda: self.relativeFrame(1),
			"putFrame": self.putFrame,
			"fetchParams": self.sendParams,
			"setParams": self.setParams
		}
		(actionName,args,kwargs)=e

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

if __name__=="__main__":
	core=Core()
	core.listen()
	log.info("OneEye started.")
	core.joinChildren()
	log.info("Exited correctly.")

"""
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)
"""