import logging as log

from .grid import Grid

class ImageAnalyzer:

	def __init__(self,tresB=30,tresW=60):

		self.board=[[EMPTY]*19 for r in range(19)]

		self.grid=None

		self.tresB=tresB

		self.tresW=tresW

	# let's not concern ourselves with sizecoef and shift here anymore. we want corners to come already properly recomputed

	def analyze(self,image):

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.toMove=BLACK

		self._helper=HelperBoard(self.board)

		self._hashes=[]

		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 doMove(self,color,row,col):

		if color!=self.toMove: log.warning("move by %s out of order",colorNames[color])

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

		self.board[row][col]=color

		# check for suicide and prevent it

		self._helper.clear()

		if not self._helper.floodFill(color,row,col,EMPTY):

			self.board[row][col]=EMPTY

			return False

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

		self.toMove=-1*color

		self._hashes.append(self.hash())

		return True

	def undoMove(self,r,c,captures):

		assert self.board[r][c]==-1*self.toMove, "{0}!={1}".format(self.board[r][c],-1*self.toMove)

		if len(captures)>0:

			self._helper.clear()

		self._hashes.pop()

	def transitionMove(self,board):

		res=transitionMove(self.board,board)

		if not res: return res

		(r,c,color)=res

		return self.doMove(color,r,c)

	def load(self,board):

		for (r,row) in enumerate(board):

			for (c,x) in enumerate(row):

				self.board[r][c]=x

	def hash(self):

		return hashBoard(self.board)

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

	def _remove(self):

		self._fill(EMPTY)

	def _fill(self,filling):

		for (r,c) in self._helper.getContinuousArea():

			self.board[r][c]=filling

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

	return []

class SpecGo(core.Go):

	def __init__(self,boardSize=19):

		super().__init__(boardSize)

	def listRelevantMoves(self,diff):

		"""There can be 3 different changes in the diff: additions, deletions and replacements.

		Additions can be taken as relevant right away.

		Deletions and replacements had to be captured, so we add their liberties.

		Also any non-missing stones of partially deleted (or replaced) groups had to be replayed, so add them too.

		There's no end to what could be theoretically relevant, but such sequences are long and we will pretend they won't happen."""

		res=(set(),set())

		for d in diff:

			(r,c,action,color)=d

			colorKey=(1-color)>>1 # {-1,1}->{1,0}

			if action!="-" and (r,c) not in res[colorKey]:

				res[colorKey].add((r,c))

			# this is rather sloppy but correct. the time will show if it is effective enough

			if action!="+" and (r,c) not in res[colorKey] and (r,c) not in res[1-colorKey]:

				self._helper.clear()

				self._helper.floodFill(color if action=="-" else 1-color, r, c)

				res[colorKey].union(self._helper.getContinuousArea())

				for (ri,ci) in self._helper.getContinuousArea():

					res[colorKey].add((ri,ci))

					res[1-colorKey].add((ri,ci))

		return res

class Engine:

	def __init__(self,g=None):

		self._g=g or SpecGo()

		self._moveList=(set(),set())

	def load(self,state1,diff):

		self._g.load(state1)

		self._moveList=self._g.listRelevantMoves(diff)

		for i in range(1,10):

				self._g.toMove=color

				seq=self.dfs(state2,i)

				if seq:

					seq.reverse()

					return seq

	def dfs(self,state2,limit):

		g=self._g

		for (r,c) in self._moveList[(1-g.toMove)>>1]:

			if g.board[r][c]!=EMPTY: continue

			neighbours=(

				g.board[r-1][c] if r>0 else None,

				g.board[r+1][c] if r+1<g.boardSize else None,

				g.board[r][c-1] if c>0 else None,

				g.board[r][c+1] if c+1<g.boardSize else None

			)

			captured=tuple(

				coords for (i,coords) in enumerate(((r-1,c),(r+1,c),(r,c-1),(r,c+1)))

				if neighbours[i] is not None and neighbours[i]!=EMPTY and g.board[coords[0]][coords[1]]==EMPTY

			)

			if g.hash()==state2.hash(): return [(-1*g.toMove,r,c)]

			if limit>1:

				toMove=-1*g.toMove

				seq=self.dfs(state2,limit-1)

				if seq:

					seq.append((toMove,r,c))

					return seq

			g.undoMove(r,c,captured)

User can change detector parameters, presumably in case the previous don't fit the (current) situation.

In such a case we assume the new parameters are correct from the current position onwards.

But the change might have been appropriate even earlier (before the user detected and fixed an error).

So we try to find the correct crossover point like this:

- construct a sequence S' = s'_i, ..., s'_n by reanalyzing the positions with a new set of parameters, where s_i is the point of previous user intervention or s_0

- for each s'_j:

	- try to append it to S[:j]

	- try to append it to S'[:j]

	- remember the better variant

- linearize the fork back by discarding s'_j-s preceding the crossover and s_j-s following the crossover

"""

from go.engine import transitionSequence

## Crude lower bound on edit distance between states.

def estimateDistance(diff):

	# lot of room for improvements

	additions=sum(1 for d in diff if d[2]=="+")

	deletions=sum(1 for d in diff if d[2]=="-")

	replacements=len(diff)-additions-deletions

	if additions>0: return additions+replacements

	elif replacements==0 and deletions>0: return 2 # take n, return 1

	return replacements+1 # ???

class BoardState:

	def __init__(self,board):

		self._board=tuple(tuple(x for x in row) for row in board)

		self.prev=None

		self._next=None

		self.moves=[]

		self.weight=0

		self.diff2Prev=None

	def hash(self):

		return hashBoard(self._board)

	def __iter__(self): return iter(self._board)

	def __getitem__(self,key): return self._board[key]

	def __sub__(self,x):

		res=[]

		for (r,(row1,row2)) in enumerate(zip(self._board,x)):

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

				if item1==item2: continue

				elif item2==EMPTY: res.append((r,c,"+",item1))

				elif item1==EMPTY: res.append((r,c,"-",item2))

from unittest import TestCase

from go.engine import SpecGo,Engine

from statebag import BoardState

class TestTransitions(TestCase):

	def testBasic(self):

		s1=BoardState([

		])

		s2=BoardState([

		])

		g=SpecGo(3)

		eng=Engine(g)

		eng.load(s1,s2-s1)

		self.assertEqual(eng.dfs(s2,1),[(1,1,1)])

	def testCapture(self):

		s1=BoardState([

		])

		s2=BoardState([

		])

		g=SpecGo(3)

		eng=Engine(g)

		eng.load(s1,s2-s1)

	def testMulti(self):

		s1=BoardState([

		])

		s2=BoardState([

		])

		g=SpecGo(3)

		eng=Engine(g)

		eng.load(s1,s2-s1)

from unittest import TestCase

from go.core import isLegalPosition, Go

class TestLegal(TestCase):

	def testLegal(self):

		board=[

		]

		self.assertTrue(isLegalPosition(board))

	def testIllegal(self):

		board=[

		]

		self.assertFalse(isLegalPosition(board))

class TestMove(TestCase):

	def testCapture(self):

		g=Go(3)

		g.load([

		])

		self.assertEqual(g.board,[

		])

		g._helper.clear()

		for row in g._helper._board:

			for x in row:

				self.assertEqual(x,0)

zobristNums=tuple(

	tuple(

		tuple(rand.getrandbits(32) for i in range(3)) for c in range(19)

	) for r in range(19)

)

def hashBoard(board):

	res=0

	for (r,row) in enumerate(board):

		for (c,item) in enumerate(row):

			res^=zobristNums[r][c][item+1]

	return res