#!/user/bin/env python

import sys
import os
import pygame
from pygame.locals import *

#--- Init pygame
os.environ["SDL_VIDEO_CENTERED"] = "1"
pygame.init

#--- Variables
res = (32, 32)
clock = pygame.time.Clock()

#--- Display
pygame.display.set_caption("Rectangle Man: Story of a Square")
screen = pygame.display.set_mode((20 * res[0], 17 * res[1]))


class Entity(object):
    def __init__(self, Size):
        self.rect = Size#pygame.Rect(Size[0], Size[1], Size[2], Size[3])
        self.permSize = Size


class Player(Entity):

    def __init__(self, Size, Speed):
        Entity.__init__(self, Size)
        self.topSpeed = Speed
        self.speed = [0, 0]
        self.uc = 16
        self.currentJump = 0
        self.totJumpNum = 2
        self.jIncrement = 1
        self.jumping = False

    def tick(self):
        self.move(self.speed[0], self.speed[1])
        if self.speed[1] < self.topSpeed[1]:
            if self.speed[1] < 0:
                self.speed[1] += self.increment * levels.res[1]
            else:
                self.speed[1] += 1 * levels.res[1]
        if self.jumping:
            if (self.speed[1] >= 0) and (self.currentJump <= self.totJumpNum - 1):
                self.jumping = False

    def move(self, dx, dy):
        if dx != 0:
            self.move_single_axis(dx, 0)
        if dy != 0:
            self.move_single_axis(0, dy)

    def move_single_axis(self, dx, dy):
        self.rect.x += dx
        self.rect.y += dy

        tx, ty = int(player.rect.x / res[0]), int(player.rect.y / res[1])
        rects = [[tx, ty], [tx + 1, ty], [tx, ty + 1], [tx + 1, ty + 1]]

        for h in rects:
            if levels.map[int(h[0])][int(h[1])].tNum == 1:
                wam = levels.map[int(h[0])][int(h[1])].rect
                if self.rect.colliderect(wam):
                    if dx > 0:
                        self.rect.right = wam.left
                    if dx < 0:
                        self.rect.left = wam.right
                    if dy > 0:
                        self.rect.bottom = wam.top
                        self.currentJump = 0
                        self.speed[1] = 0
                    if dy < 0:
                        self.rect.top = wam.bottom
                        self.speed[1] = 0
                    return

    def input(self, type, keys):
        if type == KEYDOWN:
            if keys == K_UP:
                if self.jumping == False:
                    self.jumping = True
                    self.currentJump += 1
                    self.speed[1] = -self.topSpeed[1]
                    self.increment = 1
            if keys == K_DOWN:
                self.rect = pygame.Rect(self.rect.x, self.rect.y + self.permSize[1] / 2, self.permSize[0], self.permSize[1] / 2)
            if keys == K_LEFT:
                self.speed[0] = -self.topSpeed[0]
            if keys == K_RIGHT:
                self.speed[0] = self.topSpeed[0]
        if type == KEYUP:
            if keys == K_UP:
                self.increment = 2
            if keys == K_DOWN and self.speed[1] > 0:
                q = self.rect.x
                self.move(0, -res[1]/2)
                if self.rect.x == q:
                    self.move(0, res[1]/2)
                    self.rect = pygame.Rect(self.rect.x, self.rect.y - self.permSize[1] / 2, self.permSize[0], self.permSize[1])
            if keys == K_LEFT and self.speed[0] < 0:
                self.speed[0] = 0
            if keys == K_RIGHT and self.speed[0] > 0:
                self.speed[0] = 0


class Wall(object):

    def __init__(self, pos):
        self.rect = pygame.Rect(pos[0], pos[1], pos[2], pos[3])
        self.tNum = pos[4]
        self.tile = pos[5]


class Level(object):

    def __init__(self, (size, resolution, mapArray, playerStart)):
        self.size = size
        self.res = resolution
        self.map =  mapArray
        self.start = playerStart


class Camera(Entity):

    def __init__(self, Size, Target):
        Entity.__init__(self, Size)
        self.target = Target

    def tick(self):
        self.rect.x = self.target.rect.x - (self.rect.width / 2)
        if self.x < 0:
            self.x = 0
        if self.x + self.rect.width > len(levels.map) * res[0]:
            self.x = (len(levels.map) * res[0]) - self.rect.width

        self.y = self.target.rect.y - (self.rect.height / 2)
        if self.y < 0:
            self.y = 0
        if self.y + self.rect.height > len(levels.map[0]) * res[1]:
            self.y = (len(levels.map[0]) * res[1]) - self.rect.height


def translate(rect, Cam):
    return pygame.Rect(rect.x - Cam.x, rect.y - Cam.y, rect.w, rect.h)

def getEvents():
    for event in pygame.event.get():
        if event.type == KEYDOWN or event.type == KEYUP:
            player.input(event.type, event.key)
        if event.type == pygame.QUIT:
            gameRunning = False
            sys.exit()

def parseLevel(filename):
    COMMA_ITER = 6
    pos, walls, tot = [], [], []
    fileObj = open(filename)
    s = fileObj.read()
    fileObj.close()
    mRes = s.find(".", 0)
    tot = [float(res[0]) / float(s[0: mRes]), float(res[1]) / float(s[0: mRes])]
    mx = s.find(".", mRes + 1)
    my = s.find("(", mx)
    strPart = 0
    for i in range(0, int(s[mRes + 1: mx])):
        walls.append([])
        for e in range(0, int(s[mx + 1: my])):
            strPart = s.find("(", strPart) + 1
            strPart2 = s.find(")", strPart)
            for la in range(0, COMMA_ITER):
                final = s.find(",", strPart, strPart2)
                pos.append(int(s[strPart: final]))
                strPart = final + 1
            if pos[4] == 2:
                pos[4] = 0
                star = (pos[0] * tot[0], pos[1] * tot[1])
            walls[i].append(Wall((pos[0] * tot[0], pos[1] * tot[1], pos[2] * tot[0], pos[3] * tot[1], pos[4], pos[5])))
            pos = []
    return ((mx, my), tot, walls, star)

#--- Object Creation
levels = Level(parseLevel("level.txt"))
player = Player((levels.start[0], levels.start[1], res[0] - 1, res[1]), (4 * levels.res[0], 10 * levels.res[1]))
#player = Player((res[0] - 1, res[1]), (4 * levels.res[0], 10 * levels.res[1]))
#player.rect.x, player.rect.y = levels.start[0], levels.start[1]
camera = Camera((screen.get_width(), screen.get_height()), player)
tileset = pygame.transform.scale(pygame.image.load("tileset.bmp"), (res[0], res[1] * 9)).convert()

#--- Main Loop
gameRunning = True
while gameRunning:
    #ballbuff = pygame.Rect(player.rect.x, player.rect.y, res[0], player.rect.bottom - player.rect.top)
    getEvents()

    player.tick()
    camera.tick()


    screen.fill((0, 0, 0))
    for i in range(0, len(levels.map)):
        for e in range(0, len(levels.map[i])):
            rect = translate(levels.map[i][e].rect, camera)
            til = pygame.surface.Surface((res[0],res[1]))
            til.set_colorkey((73,154,191))
            til.blit(tileset, (0, -levels.map[i][e].tile * res[1], res[0], res[1]))
            screen.blit(til, rect)

    rect = translate(player.rect, camera)
    pygame.draw.rect(screen, (255, 200, 0), rect)

    clock.tick(30)
    pygame.display.flip()