from collections import deque

from . import skipWhitespace, ParserWarning

from .property import Property, GAME_INFO

class Node:

	def __init__(self):

		self.properties=dict()

		self.parent=None

		self.children=[]

	@staticmethod

	def fits(s,i):

		return i<len(s) and s[i]==";"

	@staticmethod

	def create(s,start):

		assert Node.fits(s,start)

		res=Node()

		i=skipWhitespace(s,start+1)

		while Property.fits(s,i):

			i,x=Property.create(s,i)

			if x.name in res.properties:

			else:

				res.properties[x.name]=x

			i=skipWhitespace(s,i)

		return (i,res)

	def listGINodes(self):

		if self.isGINode(): yield self

		empty=not self.isGINode()

		node=self

		while node.parent:

			node=node.parent

			if node.isGINode():

				empty=False

				yield node

		queue=deque(self.children)

		while len(queue)>0:

			node=queue.popleft()

			if node.isGINode():

				empty=False

				yield node

			queue.extend(node.children)

		if empty: yield self # always yield at least self, can work as GINode as well as any other

	def isGINode(self):

		return any(prop.type==GAME_INFO for prop in self.properties.values())

	def setProp(self,name,value):

		self.properties[name]=value

		# zkontrolovat typ value

	def setChildren(self,children):

		self.children=children

		for child in children: child.parent=self

	def addChild(self,node):

		if node in self.children: return node

		node.parent=self

		self.children.append(node)

		return node

	def removeChild(self,node):

		if node not in self.children:

			return None

		del self.children[self.children.index(node)]

		node.parent=None

		return node

import re

from .propValues import choose, singleton, listOf, compose, number, real, double, color, text, empty, anything, point, move, stone

from . import skipWhitespace, ParserError

GAME_INFO=1

UNKNOWN=99

class Property:

	identRegexp=re.compile(r"[A-Z]+")

	def __init__(self):

		self.name=""

		self.value=""

	@staticmethod

	def fits(s,i):

		return i<len(s) and s[i].isupper()

	@staticmethod

	def create(s,start):

		assert Property.fits(s,start)

		res=Property()

		i,res.name=Property.ident(s,start)

		i=skipWhitespace(s,i)

		i,x=Property.createValue(s,i,res.name)

		res.value=x

		i=skipWhitespace(s,i)

		return (i,res)

	@staticmethod

	def ident(s,start):

		m=Property.identRegexp.match(s,start)

		if m is None: raise ParserError("expected a property identifier matching '[A-Z]+'",s,start)

		return (m.end(),m.group())

	@staticmethod

	def createValue(s,start,name):

		if name in Property.patterns:

			return Property.patterns[name](s,start)

		else:

			# !! raise or log or ignore

			# print('warning, unknown property "{0}" at position {1}'.format(name,start))

			return choose(listOf(anything), singleton(anything))(s,start)

	@property

	def type(self):

		gameInfo={"AN","BR","BT","CP","DT","EV","GN","GC","ON","OT","PB","PC","PW","RE","RO","RU","SO","TM","US","WR","WT"}

		if self.name in gameInfo: return GAME_INFO

		else: return UNKNOWN

	def copy(self):

		res=Property()

		res.name=self.name

		res.value=self.value if not isinstance(self.value,list) else self.value[:]

		return res

	def __str__(self):

		val="[{0}]".format(self.value) if not isinstance(self.value,list) else "".join("[{0}]".format(x) for x in self.value)

		return "{0}{1}".format(self.name,val)

	patterns={

		"B":singleton(move),

		"KO":singleton(empty),

		"MN":singleton(number),

		"W":singleton(move),

		"AB":listOf(stone), #

		"AE":listOf(point), #

		"AW":listOf(stone), #

		"PL":singleton(color),

		"C":singleton(text(simple=False)),

		"DM":singleton(double),

		"GB":singleton(double),

		"GW":singleton(double),