import os, sys, time, threading
from getch import my_getch
import random

class Terminal(object):
	def writeXY(x=0, y=0, s=''):
		print("\033[" + str(x) + ";" + str(y*2) + "H" + str(s), end='\r')
	def reset():
		rows, columns = os.popen('stty size', 'r').read().split()
		Terminal.writeXY(0, 0, ' '*int(columns)*int(rows))


class Game(object):
	def __init__(self):
		self.snake = None
		self.food = None
		self.end = False
		self.score = 0

	def drawScore(self):
		Terminal.writeXY(0, 16, 'Score: ' + str(self.score))

	def defineSnake(self, snake):
		self.snake = snake

	def Over(self):
		Terminal.writeXY(12, 14, 'Game Over! Score: ' + str(self.score))
		self.end = True
		return False

	def Pause(self):
		Terminal.writeXY(12, 16, 'Pause!')

	def drawFrame(self):
		if not self.end:
			Terminal.reset()
			self.snake.draw()
			self.food.draw()
			self.drawScore()

	def getRandomXY(self):
		rows, columns = os.popen('stty size', 'r').read().split()
		x = random.randint(2, int(columns)-2)
		y = random.randint(2, int(rows)-2)
		return x, y

	def createFood(self):
		x, y = self.getRandomXY()
		while (self.snake.isColision(x, y)):
		 	x, y = self.getRandomXY()
		self.food = Point(x, y, '$')


class Point(object):
	def __init__(self, x, y, ch):
		self.x = x
		self.y = y
		self.ch = ch

	def get(self):
		return (self.x, self.y, self.ch)

	def draw(self):
		Terminal.writeXY(self.x, self.y, self.ch)


class Snake(object):
	directions = {
		'up'    :[-1,  0],
		'down'  :[ 1,  0],
		'left'  :[ 0, -1],
		'right' :[ 0,  1] }
	def __init__(self, game, headX=10, headY=10, lenth=5):
		self.game = game
		self.direction = 'left'
		self.body = (Point(headX, headY, '@'), ) + tuple([Point(headX, headY + x, '#') for x in range(1, lenth)])

	def __repr__(self):
		return str([x.get() for x in self.body])

	def draw(self):
		for x in self.body:
			x.draw()

	def isColision(self, x, y):
		if (x < 0) or (x > 24) or (y < 0) or (y > 40):
			return True
		for point in self.body:
			if point.x == x and point.y == y:
				return True
		return False

	def checkMoveInBody(self, x, y):
		if x == self.body[1].x and y == self.body[1].y:
			return True
		return False

	def getNewDirectionPosition(self, dir):
		x = self.body[0].x + Snake.directions[dir][0]
		y = self.body[0].y + Snake.directions[dir][1]
		return x, y

	def move(self, dir):
		if self.game.end: return False
		newHeadx, newHeady = self.getNewDirectionPosition(dir)
		if self.checkMoveInBody(newHeadx, newHeady):
			return False
		self.direction = dir

		if self.isColision(newHeadx, newHeady):
			self.game.Over()
			return False

		doBigger = self.isFoodColision(newHeadx, newHeady)
		newHead = Point(newHeadx, newHeady, '@')
		self.body[0].ch = '#'
		self.body = (newHead, ) + self.body[:doBigger]
		return True

	def isFoodColision(self, x, y):
		food = self.game.food
		if food.x == x and food.y == y:
			self.game.createFood()
			self.game.score += 1
			return len(self.body)
		return -1


class perpetualTimer():
	def __init__(self, t, hFunction):
		self.t = t
		self.hFunction = hFunction
		self.thread = threading.Timer(self.t, self.handle_function)
	def handle_function(self):
		self.hFunction()
		self.thread = threading.Timer(self.t,self.handle_function)
		self.thread.start()
	def start(self):
		self.thread.start()
	def cancel(self):
		self.thread.cancel()

myGame = Game()
snake = Snake(myGame, 15, 15, 5)
myGame.defineSnake(snake)
myGame.createFood()
myGame.drawFrame()


def render():
	myGame.drawFrame()
	myGame.snake.move(snake.direction)

t = perpetualTimer(0.1, render)
t.start()


tmp = ''
keys = {
	'a' : 'up',
	'b' : 'down',
	'c' : 'right',
	'd' : 'left' }

while True:
	tmp = my_getch()
	if tmp == '\r':
		t.cancel()
		myGame.Over()
		input()
		break
	if tmp == 'p':
		t.cancel()
		myGame.Pause()
		tmp = my_getch()
		t = perpetualTimer(0.1, render)
		t.start()
	if tmp in keys:
		x, y = snake.getNewDirectionPosition(keys[tmp])
		if not snake.checkMoveInBody(x, y):
			snake.direction = keys[tmp]