## Euclidean 2D plane point: (x,y).

class EPoint:

	def __init__(self,x,y):

		self.x=x

		self.y=y

	def fromProjective(point):

		if point.item(0)==0: return None

		return EPoint(point.item(1)/point.item(0),point.item(2)/point.item(0))

	def toProjective(self):

		return (1,self.x,self.y)

from util import EMPTY,BLACK,WHITE, colorNames,hashBoard,diffHash

from .helperboard import HelperBoard

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

		self._helper=HelperBoard(self.board)

		self._freshHash=hashBoard(self.board) # always reflecting current state of the board

		self._hashes=[self._freshHash]

		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,r,c):

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

		if self.board[r][c]!=EMPTY: return False

		self.board[r][c]=color

		self._freshHash^=diffHash(r,c,EMPTY,color)

		# capture neighbors

		for dr,dc in ((-1,0),(1,0),(0,-1),(0,1)):

			self._helper.clear()

		# check for suicide and prevent it

		self._helper.clear()

		if not self._helper.floodFill(color,r,c,EMPTY):

			self.board[r][c]=EMPTY

			self._freshHash=self._hashes[-1]

		self._record.move(color,r,c)

		self.toMove=-1*color

		self._hashes.append(self._freshHash)

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

			for (ri,ci) in captures:

				self._helper.floodFill(EMPTY,ri,ci)

from . import core

class SpecGo(core.Go):

	def __init__(self,boardSize=19):

		super().__init__(boardSize)

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

		Needs to handle snapback, throw-in.

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

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

				for (ri,ci) in self.listNeighbours(r,c): # in case a stone was played and captured. !! might want to add even more

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

	def load(self,state1,diff):

		self._g.load(state1)

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

				seq=self.dfs(state2,i)

				if seq:

					seq.reverse()

					return seq

	def dfs(self,state2,limit):

		g=self._g

		moveSet=self._moveList[(1-g.toMove)>>1]

			if g.hash()==state2.hash():

			if limit>1:

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

				if seq:

					return seq

		return False

eng=Engine()

		self._visited=[0]*(self._boardSize**2)*2

		self._visitedCount=0

		self._libs=[0]*(self._boardSize**2)*2

		self._libCount=0

	def floodFill(self,filling,r,c,needle=None):

		if c<0 or c>=self._boardSize or r<0 or r>=self._boardSize: return False # out of range

		if self._board[r][c]: return False # already visited

		if self._refBoard[r][c]==needle: return True # found something

		if self._refBoard[r][c]!=filling:

			if self._refBoard[r][c]==EMPTY: # remember group liberties

- 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

"""

## 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]=="+")

	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.diff2Prev=None

		self._hash=None

	def hash(self):

		if self._hash is None: self._hash=hashBoard(self._board)

		return self._hash

	def export(self):

		return exportBoard(self._board)

				else: res.append((r,c,"*",item1)) # ->to

		return res

	def __eq__(self,x):

		return self.hash()==x.hash()

class StateBag:

	def __init__(self):

		self._states=[]

	def pushState(self,board):

		sn=BoardState(board)

		if self._states and sn==self._states[-1]: return # no change

		for s in reversed(self._states):

		self._states.append(sn)

	def merge(self,branch):

		pass

		for f in files:

			moves=simpleLoadSgf(os.path.join(cfg.srcDir,"tests/data",f))

			states=listStates(moves)

			for k in range(1,4):

				toMove=B

					diff=s2-s1

					eng.load(s1,diff)

					msg="\n"+s1.exportDiff(s2)

					self.assertIsNotNone(seq,msg)

					self.assertLessEqual(len(seq),k,msg)

					if len(seq)!=k: _log.warning("shorter than expected transition sequence:" + msg + "\n" + str(seq))

					toMove*=-1