#include <stdio.h>
#include <stdlib.h>
#include "typedef.h"
#include "tiles.h"
#include "ppm.h"

size_t TILES;
size_t TILE_WIDTH;
size_t TILE_HEIGHT;

small_t *(tiles[TILES_CAP]);
small_t tile_connections[TILES_CAP][SIDES_MAX];

static int rotate(int x, int y, int r, int w)
{
    switch(r) {
    case 0: // no roatate
        return y * w + x;
    case 1: // right
        return (w*w - w) + y - (x * w);
    case 2: // left
        return (w-1) - y + (x * w);
    case 3: // down
        return (w*w-1) - (y * w) - x;
    }

    return -1;
}

static void rotate_tiles(char *t, int i, int r)
{
    tiles[i] = malloc(TILE_WIDTH * TILE_HEIGHT * 3);

    for(size_t y = 0; y < TILE_HEIGHT; y++)
        for(size_t x = 0; x < TILE_WIDTH; x++)
            for(int k = 0; k < 3; k++)
                tiles[i][(y * TILE_WIDTH + x)*3 + k] = t[(rotate(x, y, r, TILE_WIDTH))*3 + k];
}

static void rotate_connections(small_t (*tc)[SIDES_MAX], int i, int n, int r)
{
    for(int y = 0; y < 2; y++)
        for(int x = 0; x < 2; x++)
            tile_connections[n][y*2 + x] = tc[i][rotate(x, y, r, 2)];
}

void load_tiles(FILE *fp)
{
    size_t tid = 0;
    small_t tile_con[TILES_CAP][SIDES_MAX] = {0};
    char tile_sym[TILES_CAP];

    fread(&tid, sizeof(size_t), 1, fp);
    if(tid == 0) {
        err("Tiles could not be loaded");
        exit(EXIT_FAILURE);
    }

    for(size_t i = 0; i < tid; i++) {
        fread(tile_con[i], sizeof(small_t), SIDES, fp);
        fread(&(tile_sym[i]), sizeof(char), 1, fp);
    }


    size_t n = 0;
    for(size_t i = 0; i < tid; i++, n++)
    {
        char file_path[128];
        sprintf(file_path, "%s/tiles/tile_%ld.ppm", PATH, i);
        char *t = load_from_ppm(file_path, &TILE_WIDTH, &TILE_HEIGHT);

        switch(tile_sym[i])
        {
        case 'X':
            rotate_tiles(t, n, 0);
            rotate_connections(tile_con, i, n, 0);
            break;
        case 'T':
            for(int j = 0; j < SIDES; j++) {
                rotate_tiles(t, n, j);
                rotate_connections(tile_con, i, n, j);
                n++;
             } n--;
            break;
        case 'I':
            rotate_tiles(t, n, 0);
            rotate_connections(tile_con, i, n, 0);
            n++;
            rotate_tiles(t, n, 1);
            rotate_connections(tile_con, i, n, 1);
            break;
        case '/':
            rotate_tiles(t, n, 0);
            rotate_connections(tile_con, i, n, 0);
            n++;
            rotate_tiles(t, n, 3);
            rotate_connections(tile_con, i, n, 3);
            break;
        default:
            err("Symetry Character not recognized: '%c'", tile_sym[i]);
            exit(EXIT_FAILURE);
        }

        free_ppm(t);

        if(n > TILES_CAP) {
            err("Too many tiles: %ld\n", n);
            exit(EXIT_FAILURE);
        }
    }

    TILES = n;
}

void free_tiles()
{
    for(size_t i = 0; i < TILES; i++)
        free(tiles[i]);
}

// void print_tiles()
// {
//     for(size_t i = 0; i < TILES; i++)
//     {
//         printf("Tile: %ld\n", i);
//         for(int n = 0; n < 4; n++) {
//             printf("%d", tile_connections[i][n]);
//         } printf("\n");
//         for(size_t y = 0; y < TILE_HEIGHT; y++)
//         {
//             for(size_t x = 0; x < TILE_WIDTH; x++)
//                 putchar((tiles[i][(y * TILE_WIDTH + x)*3 + 0]) == 0 ? '#' : '.');
//             putchar('\n');
//         }
//         putchar('\n');
//     }
// }

int get_tile_pixel(size_t t, size_t x, size_t y, int k)
{
    return tiles[t][(y * TILE_WIDTH + x)*3 + k];
}

small_t (*get_tile_connections())[SIDES_MAX]
{
    return tile_connections;
}