import pygame
import os
import sys
import random
import math


def draw_grid(grid,screen):
    for yi in range(18):
        for xi in range(24):
            if grid[yi+1][xi+1] == 1:
                pygame.draw.rect(screen,(100,100,100),(xi*50,yi*50,50,50),2)

def render_tiles(tiles, tile_size, screen, scale):
    i = 0
    for tile in tiles:
        screen.blit(pygame.transform.scale(tile, 
                                           (int(tile_size[0]*scale), 
                                            int(tile_size[1]*scale))),
                    (i*int(tile_size[0]*scale), 0))
        i += 1

def render_map(grid, tiles, tile_size, screen, scale):
    for i in range(len(grid)):
        for j in range(len(grid[i])):
            screen.blit(pygame.transform.scale(tiles[grid[i][j]],
                                               (int(tile_size[0]*scale), 
                                                int(tile_size[1]*scale))),
                        (j*int(tile_size[0]*scale),
                         (i+2)*int(tile_size[1]*scale)))

def render_selected_tile(sel_tile, tile_size, screen, scale):
    pygame.draw.rect(screen,(200,0,0),
                     (sel_tile*int(tile_size[0]*scale),0,
                      int(tile_size[0]*scale),int(tile_size[0]*scale)),1)
    
def render_click(coord, sel_tile, grid, tile_size, screen, scale):
    
    screen.blit(pygame.transform.scale(tiles[grid[i][j]],
                                       (int(tile_size[0]*scale), 
                                        int(tile_size[1]*scale))),
                (j*int(tile_size[0]*scale),
                 (i+2)*int(tile_size[1]*scale)))

def save_grid(grid):
    print(grid)

if __name__ == "__main__":

    # initializations
    pygame.init()
    screen = pygame.display.set_mode((1024,768))
    clock = pygame.time.Clock()
    # tile parameters
    tileset_file = os.path.join('images', 'derechos-tileset-fondos.png')
    tile_default = 0 # tile # that will be used as default
    tile_border = 30 # tile # for the border (outside the screen)
    tile_size = (50, 50) # (x, y) in pixels
    tileset_size = (8, 4) # (x, y) in tiles
    screen_size = (1200, 900) # (x, y) in pixels
    # scale
    scale = 0.5
    # selected tile
    sel_tile = 0
    # check for consistency
    if screen_size[0] % tile_size[0] != 0 \
            or screen_size[0] % tile_size[0] != 0:
        print("Dimensions of the screen are not multiples of the tile size.")
        sys.exit()
    map_size = (screen_size[0]/tile_size[0], screen_size[1]/tile_size[1])
    # load tileset
    tiles = []
    tileset_image = pygame.image.load(tileset_file).convert_alpha()
    w, h = tileset_image.get_size()
    if tile_size[0]*tileset_size[0] != w \
            or tile_size[1]*tileset_size[1] != h:
        print("Dimensions of the tileset_file don't agree with size.")
        sys.exit()
    for i in xrange(tileset_size[1]):
        for j in xrange(tileset_size[0]):
            tiles.append(tileset_image.subsurface((j*tile_size[0],
                                                   i*tile_size[1],
                                                   tile_size[0],
                                                   tile_size[1])))
    # create initial grid
    grid = [ [tile_default]*(map_size[0]+2) for i in xrange(map_size[1]+2)]
    grid[0] = [tile_border]*(map_size[0]+2)
    grid[map_size[1]+1] = [tile_border]*(map_size[0]+2)
    for i in xrange(map_size[1]):
        grid[i+1][0] = tile_border
        grid[i+1][map_size[0]+1] = tile_border
    # render initial screen
    render_tiles(tiles, tile_size, screen, scale) 
    render_map(grid, tiles, tile_size, screen, scale) 
    render_selected_tile(sel_tile, tile_size, screen, scale)
    pygame.display.flip()

    font24 = pygame.font.Font(None, 24)

    playing = True
    
    while playing:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                playing = False
            elif event.type == pygame.MOUSEBUTTONDOWN:
                coord = pygame.mouse.get_pos()
                if coord[1] < tile_size[1]*scale \
                        and coord[0] < len(tiles)*tile_size[0]*scale:
                    sel_tile = int(coord[0]/(tile_size[0]*scale))
                elif coord[0] < (map_size[0]+2)*tile_size[0]*scale \
                        and coord[1] < ((map_size[1]+4)*tile_size[1])*scale \
                        and coord[1] > 2*tile_size[1]*scale:
                    grid[int(coord[1]-2*tile_size[1]*scale)/int(tile_size[1]*scale)]\
                        [coord[0]/int(tile_size[0]*scale)] = sel_tile
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_UP:
                    pass
                elif event.key == pygame.K_DOWN:
                    pass
                elif event.key == pygame.K_LEFT:
                    if sel_tile > 0:
                        sel_tile -= 1
                elif event.key == pygame.K_RIGHT:
                    if sel_tile < len(tiles)-1:
                        sel_tile += 1
                elif event.key == pygame.K_s:
                    save_grid(grid)
                elif event.key == pygame.K_ESCAPE \
                        or event.key == pygame.K_q:
                    playing = False

        time_passed = clock.tick(20)

        render_tiles(tiles, tile_size, screen, scale) 
        render_map(grid, tiles, tile_size, screen, scale) 
        render_selected_tile(sel_tile, tile_size, screen, scale)
        pygame.display.flip()