import tkinter as tk
from PIL import ImageTk
import PIL
from corners import *
from grid import *
from image_analyzer import *
from go import *

showBigPoints=True
showGrid=False


class Application(tk.Frame):
	def __init__(self, master=None):
		self.corners=Corners()
		self.boardGrid=None

		tk.Frame.__init__(self, master)
		self.grid(column=0,row=0)
		self.createWidgets()

	def createWidgets(self):
		# a captured frame with overlay graphics
		self.imgView=tk.Canvas(self)
		self.imgView.configure(width=480,height=360)
		self.imgOrig=PIL.Image.open("../images/7.jpg")

		self.img=ImageTk.PhotoImage(self.imgOrig.resize((int(self.imgView['width']),int(self.imgView['height'])),resample=PIL.Image.BILINEAR))

		self.imgView.bind('<1>',lambda e: self.addCorner(e.x,e.y))

		self.imgView.grid(column=0,row=0)

		# board with detected stones
		self.boardView=BoardView(self)
		self.boardView.grid(column=1,row=0)

		# more controls below the board
		self.scaleTresB=tk.Scale(self, orient=tk.HORIZONTAL, length=200, from_=0.0, to=100.0, command=lambda x: self.redrawImgView())
		self.scaleTresW=tk.Scale(self, orient=tk.HORIZONTAL, length=200, from_=0.0, to=100.0, command=lambda x: self.redrawImgView())
		self.scaleTresB.set(30.0)
		self.scaleTresW.set(60.0)
		self.scaleTresB.grid(column=0,row=1,columnspan=2)
		self.scaleTresW.grid(column=0,row=2,columnspan=2)

		# render everything
		self.redrawImgView()

	## Stores a grid corner located at x,y coordinates.
	def addCorner(self,x,y):
		self.corners.add(x,y)
		if self.corners.canonizeOrder():
			self.boardGrid=Grid(self.corners)
			self.boardView.setBoardGrid(self.boardGrid)

		self.redrawImgView()

	## Redraws the current image and its overlay.
	def redrawImgView(self):
		self.imgView.create_image(2,2,anchor="nw",image=self.img)

		origWidth,origHeight=self.imgOrig.size
		widthRatio=origWidth/self.img.width()
		heightRatio=origHeight/self.img.height()
		sizeCoef=max(widthRatio,heightRatio)
		tresB=self.scaleTresB.get()
		tresW=self.scaleTresW.get()

		for corner in self.corners.corners:
			self.markPoint(corner.x,corner.y)

		if self.boardGrid!=None and showGrid:
			for r in range(19):
				a=self.boardGrid.intersections[r][0]
				b=self.boardGrid.intersections[r][-1]
				self.imgView.create_line(a.x,a.y,b.x,b.y,fill='#00ff00')
			for c in range(19):
				a=self.boardGrid.intersections[0][c]
				b=self.boardGrid.intersections[-1][c]
				self.imgView.create_line(a.x,a.y,b.x,b.y,fill='#00ff00')

		if self.boardGrid!=None and showBigPoints:
			for r in range(19):
				for c in range(19):
					((r1,c1),(r2,c2))=self.boardView.detector.relevantRect(self.boardGrid.intersections[r][c],*(self.boardGrid.stoneSizeAt(r,c,sizeCoef)))
					self.imgView.create_rectangle(r1,c1,r2,c2,outline="#00ffff")

		self.imgView.grid()

		shift=EPoint(origWidth-self.img.width()*sizeCoef,origHeight-self.img.height()*sizeCoef)/2

		self.boardView.redrawState(self.imgOrig,sizeCoef,shift,tresB,tresW)

	## Marks a point at the image with a green cross. Used for corners.
	def markPoint(self,x,y):
		self.imgView.create_line(x-3,y-3,x+4,y+4,fill="#00ff00")
		self.imgView.create_line(x-3,y+3,x+4,y-4,fill="#00ff00")

		self.imgView.grid()


## Handles and presents the game state as detected by the program.
class BoardView(tk.Canvas):
	def __init__(self, master=None):
		self.detector=ImageAnalyzer()
		self.boardGrid=None

		tk.Canvas.__init__(self, master)
		self.configure(width=360,height=360,background="#ffcc00")

		self.drawGrid()

		self.grid()

	## Redraws and reananalyzes the board view.
	#
	# @param tresB upper intensity treshold for a pixel to be considered black, [0-100]
	# @param tresW lower intensity treshold for a pixel to be considered white, [0-100]
	def redrawState(self,img,sizeCoef,shift,tresB,tresW):
		self.create_rectangle(0,0,360,360,fill="#ffcc00")
		self.drawGrid()

		self.detector.analyze(img,tresB,tresW,sizeCoef,shift)

		for r,row in enumerate(self.detector.board):
			for c,point in enumerate(row):
				self.drawStone(r,c,point)

		self.grid()

	def drawGrid(self):
		for i in range(19):
			self.create_line(18,18*(i+1),360-18,18*(i+1),fill="#000000") # rows
			self.create_line(18*(i+1),18,18*(i+1),360-18,fill="#000000") # cols

		self.drawStars()

	def drawStars(self):
		for r in range(4,19,6):
			for c in range(4,19,6):
				self.create_oval(r*18-2,c*18-2,r*18+2,c*18+2,fill='#000000')

	## Draws a stone at provided coordinates.
	#
	#  For an unknown color draws nothing and returns False.
	#
	#  @param r row coordinate, [0-18], counted from top
	#  @param c column coordinate, [0-18], counted from left
	#  @param color color indicator, Go.BLACK or Go.WHITE
	def drawStone(self,r,c,color):
		if color==Go.BLACK: hexCode='#000000'
		elif color==Go.WHITE: hexCode='#ffffff'
		else: return False
		r+=1
		c+=1
		self.create_oval(c*18-9,r*18-9,c*18+9,r*18+9,fill=hexCode)

	def setBoardGrid(self,boardGrid):
		self.boardGrid=boardGrid
		self.detector.setGrid(boardGrid)


root = tk.Tk()
app = Application(master=root)
app.mainloop()