import os

import logging

import json

logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', level=logging.DEBUG)

	cfgFile=json.load(f)

class misc:

	file=cfgFile["misc"]

	version=(0,0,0)

	defaultImage=file.get("defaultImage", 0)

class gui:

	file=cfgFile["gui"]

	showBigPoints=file.get("showBigPoints", False)

	showGrid=file.get("showGrid", True)

import os

import multiprocessing

import threading

import logging as log

import PIL

from util import MsgQueue

from gui import gui

from imageanalyzer import ImageAnalyzer

from go 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._imgIndex=cfg.misc.defaultImage

		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)

		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)

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

		self._ownMessages.send("!kill")

	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)

"""

class Point:

	def __init__(self,c,r):

		self.r=r

		self.c=c

	def __iter__(self):

		yield self.c

		yield self.r

	def __str__(self):

		a=ord("a")

		return chr(a+self.c)+chr(a+self.r)

class GameRecord:

	def __init__(self):

		self.playerB=""

		self.playerW=""

		self.root=Node()

		self.currNode=self.root

	def move(self,color,row,col):

		if color not in colorNames:

			raise ValueError("invalid color: {0}".format(color))

		colorName=colorNames[color]

		res=Node()

		res.properties[colorName]=Point(col,row)

		self.currNode.children.append(res)

		self.currNode=res

		return res

	def __str__(self):

		res=["("]

		stack=[self.root]

		while len(stack)!=0:

			v=stack.pop()

			res.append(v)

			if v==")": continue

			if len(v.children)>1:

				res.append("(")

				stack.append(")")

			stack.extend(reversed(v.children))

		res.append(")")

		return "".join(str(x) for x in res)

class Node:

	def __init__(self):

		self.properties=dict()

		self.parent=None

		self.children=[]

	## Returns textual representation of the Node itself, but disregards its children.

	def __str__(self):

		return ";" + "".join("{0}[{1}]".format(k,str(p)) for (k,p) in self.properties.items())

import logging as log

from gamerecord import GameRecord

class Go:

	## Initializes self.board to a list[r][c]=EMPTY.

	def __init__(self,boardSize=19):

		self.boardSize=boardSize

		self.board=[[EMPTY]*boardSize for x in range(boardSize)]

		self._temp=[[EMPTY]*boardSize for x in range(boardSize)]

		self.toMove=BLACK

		self._record=GameRecord()

	## Executes a move.

	#

	#  Doesn't check for kos. Suicide not allowed.

	#

	#  @param color BLACK or WHITE

	#  @return True on success, False on failure (illegal move)

	def move(self,color,row,col):

		if self.board[row][col]!=EMPTY: return False

		self.board[row][col]=color

		# capture neighbors

		for r,c in ((-1,0),(1,0),(0,-1),(0,1)):

			self._clearTemp()

			if not self._floodFill(-color,row+r,col+c): self._remove()

		# check for suicide

		self._clearTemp()

		if not self._floodFill(color,row,col):

			self.board[row][col]=EMPTY

			return False

		self._record.move(color,row,col)

		self.toMove=-1*color

		return True

	def transitionMove(self,board):

		res=transitionMove(self.board,board)

		if not res: return res

		(r,c,color)=res

		return self.move(color,r,c)

	## Checks for liberties of a stone at given coordinates.

	#

	#  The stone's group is marked with True in self.temp, ready for capture if needed. Recursively called for stone's neighbors.

	#

	#  @return True if alive, False if captured

	def _floodFill(self,color,row,col):

		if col<0 or col>=self.boardSize or row<0 or row>=self.boardSize: return False # out of range

		if self._temp[row][col]: return False # already visited

		if self.board[row][col]==EMPTY: return True # found a liberty

		if self.board[row][col]!=color: return False # opponent's stone

		self._temp[row][col]=True # set visited

		return self._floodFill(color,row,col-1) or self._floodFill(color,row,col+1) or self._floodFill(color,row-1,col) or self._floodFill(color,row+1,col) # check neighbors

	## Removes stones at coordinates marked with True in self.temp.

	def _remove(self):

		for r in range(self.boardSize):

			for c in range(self.boardSize):

				if self._temp[r][c]: self.board[r][c]=EMPTY

	def _clearTemp(self):

		for i in range(self.boardSize):

			for j in range(self.boardSize):

				self._temp[i][j]=EMPTY

def exportBoard(board):

	substitutions={EMPTY:".", BLACK:"X", WHITE:"O"}

	return "\n".join("".join(substitutions.get(x,"?") for x in row) for row in board)

def isLegalPosition(board):

	boardSize=len(board)

	temp=[[None]*boardSize for x in range(boardSize)]

	for r in range(boardSize):

		for c in range(boardSize):

			if board[r][c]==EMPTY: continue

			if temp[r][c]: continue

			if not dfs([(r,c)],board,temp): return False

	return True

def transitionMove(state1,state2):

	moves=[]

	for (r,(row1,row2)) in enumerate(zip(state1,state2)):

		for (c,(item1,item2)) in enumerate(zip(row1,row2)):

			if item1==EMPTY and item2!=EMPTY:

				moves.append((r,c,item2))

	if len(moves)==0:

		log.info("no new stone")

		return None

	elif len(moves)==1:

		log.info("new stone: %s",moves[0])

		return moves[0]

	else:

		log.warning("too many new stones: %s",moves)

		return False

def dfs(stack,board,mask):

	boardSize=len(board)

	(r,c)=stack[0]

	color=board[r][c]

	while len(stack)>0:

		(r,c)=stack.pop()

		if board[r][c]==EMPTY: return True

		elif board[r][c]!=color: continue

		elif mask[r][c]: return True

		mask[r][c]=True

		for (x,y) in ((0,-1),(-1,0),(0,1),(1,0)):

			if 0<=r+y<boardSize and 0<=c+x<boardSize:

				stack.append((r+y,c+x))

	return False

import multiprocessing

import logging as log

class MsgQueue:

	def __init__(self,handler=None):

		self._queue=multiprocessing.Queue()

		self._event=multiprocessing.Event()

		self._handleEvent=handler

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

		if kwargs is None: kwargs=dict()

		self._queue.put((actionName,args,kwargs))

		self._event.set()

	def listen(self,handleEvent=None):

		if handleEvent is not None: self._handleEvent=handleEvent

		while True:

			self._event.wait()

			msg=self._queue.get()

			if self._queue.empty():

				self._event.clear()

			log.info(msg)

			if msg[0]=="!kill": break

			self._handleEvent(msg)

	def setHandler(self,handler):

		self._handleEvent=handler