import os

import re

from jinja2 import Environment,FileSystemLoader

import config as cfg

import go

from go import BLACK,WHITE,EMPTY

from sgfParser import ParserError

from sgfParser.collection import Collection

from drawer.svg import Svg

from drawer.tikz import Tikz

curDir=os.path.dirname(__file__)

templateDir=os.path.join(curDir,"templ")

env=Environment(loader=FileSystemLoader(templateDir))

def collectMoves(root):

	node=root

	while len(node.children)>0:

		b=node.getProp("B")

		w=node.getProp("W")

		if b is not None: yield ("b",b)

		elif w is not None: yield ("w",w)

		# else: yield None # !! not really robust

		node=node.children[0]

class SourceFile:

	def __init__(self,fileName):

		self.fileName=fileName

		self._shortName= "".join(re.split(r'[/\\]', fileName)[-1].split('.')[:-1])

		self._game=go.Go()

		self._moveNumber=0

		self._record=None

		self._moves=[]

	def process(self):

		print("{0}... ".format(self.fileName), end="")

		try:

			games=Collection(open(self.fileName, 'r', encoding=cfg.encoding).read()).listGames()

		except ParserError as e:

			print("Couldn't parse {0}, following error occured: {1}".format(self.fileName,e))

			return False

		self._record=list(games)[0]

		self._moves=list(collectMoves(self._record.root))

		diagramsNeeded=(len(self._moves)-cfg.minMovesPerDiagram)//cfg.movesPerDiagram+1

		for i in range(diagramsNeeded):

			self.createDiagram(i+1)

		notes=open(os.path.join(cfg.outputDir,"{0}.txt".format(self._shortName)), 'w')

		notes.write(self.createGameInfo())

		notes.close()

		print("done")

	def createDiagram(self,diagramNumber):

		# initialize the diagram

		template=Svg()

		overlays=[]

		letters=dict()

		letter="a"

		for lineNumber,line in enumerate(self._game.board):

			for itemNumber,item in enumerate(line):

				if item==BLACK: template.addStone(itemNumber,lineNumber,"b")

				if item==WHITE: template.addStone(itemNumber,lineNumber,"w")

			localBoard={(a,b):self._game.board[b][a]-1 for a in range(19) for b in range(19) if self._game.board[b][a]!=EMPTY}

		for j in range(cfg.movesPerDiagram):

			# draw the moves

			if self._moveNumber>=len(self._moves): break

			c,move=self._moves[self._moveNumber]

			c=c.lower()

			if move==tuple():

				overlays.append("{0} pass".format(self._moveNumber))

				self._moveNumber+=1

				continue

			else:

				(x,y)=move

			if not self._game.move(BLACK if c=='b' else WHITE, x,y):

				# !! we do not honor http://red-bean.com/sgf/ff5/m_vs_ax.htm at the moment

				msg="illegal move: {0} at {1},{2}".format(self._moveNumber+1,x,y)

				if cfg.keepBroken:

					print(msg)

					self._moveNumber+=1

					continue

				else:

					msg+=". aborted"

					print(msg)

					return False

			# draw the move on an empty intersection

			if not (x,y) in localBoard:

				localBoard[(x,y)]=self._moveNumber+1

				template.addMove(x,y,c,self._moveNumber+1)

			# intersection occupied by an unlabeled stone

			elif localBoard[(x,y)]<1:

				# intersection not labeled even by a letter

				if not (x,y) in letters:

					letters[(x,y)]=letter

					color='b' if localBoard[(x,y)]==EMPTY else 'w'

					template.addMove(x,y,color,letter)

					letter=chr(ord(letter)+1)

				overlays.append("{0} = {1}".format(self._moveNumber+1,letters[(x,y)]))

			# intersection occupied by a numbered stone

<?xml version="1.0" encoding="utf-8"?>

{% set cellSize=boardSize/18 %}

{% if not labeledPoint %}

	{% macro labeledPoint(p) %}

	<g class="{{p.color or 'e'}}" transform="translate({{(p.x*cellSize) | round(2)}},{{(p.y*cellSize) | round(2)}})">

		<circle cx="0" cy="0" r="{{stoneRadius|round(2)}}"/>

		<text y="0.35em" font-size="{{adjustFont(cellSize,p.label)}}">{{p.label}}</text>

	</g>

	{% endmacro %}

<svg width="{{boardSize+padding*2}}" height="{{boardSize+padding*2}}" version="1.1" xmlns="http://www.w3.org/2000/svg">

	<defs>

		<style type="text/css"><![CDATA[

		{% block style %}

			rect{fill:white;stroke:black;stroke-width:1px}

			text{font-family:"DejaVu Sans";text-anchor:middle}

			line{stroke:black;stroke-width:0.7px}

			circle{stroke:black}

			circle.b, .b circle, .w text, .e text{fill:black}

			circle.w, .w circle, .b text{fill:white}

			.e circle {stroke:none;fill:white}

		{% endblock %}

		]]></style>

	</defs>

	<g transform="translate({{padding}},{{padding}})">

		<rect x="0" y="0" width="{{boardSize}}" height="{{boardSize}}"/>

		{# grid #}

		{% for i in range(1,18) %}

			<line x1="0" x2="{{boardSize}}" y1="{{(i*cellSize) | round(2)}}" y2="{{(i*cellSize) | round(2)}}"/>

			<line x1="{{(i*cellSize) | round(2)}}" x2="{{(i*cellSize) | round(2)}}" y1="0" y2="{{boardSize}}"/>

		{% endfor %}

		{# stars #}

		{% for y in [3,9,15] %}

			{% for x in [3,9,15] %}

		  <circle cx="{{(x*cellSize) | round(2)}}" cy="{{(y*cellSize) | round(2)}}" r="2" class="b"/>

			{% endfor %}

		{% endfor %}

		{# stones #}

		{% for p in stones %}

			<circle cx="{{(p.x*cellSize) | round(2)}}" cy="{{(p.y*cellSize) | round(2)}}" r="{{stoneRadius|round(2)}}" class="{{p.color}}"/>

		{% endfor %}

		{# moves #}

			{{labeledPoint(p)}}

		{% endfor %}

		{# labels #}

			{{labeledPoint(p)}}

		{% endfor %}

	</g>

</svg>