#include "2048.h"
#include <stdlib.h>
#include <time.h>

void game_add_block(Game game) {
    size_t x, y;
    int value;
    do {
        x = rand() % game.field_size_x; 
        y = rand() % game.field_size_y;
        value = (rand() % 2) + 1;
    } while (game.field[x][y] != 0);
    game.field[x][y] = value * 2;
}

Game game_init(size_t field_size_x, size_t field_size_y) {
    Game game;
    game.field_size_x = field_size_x;
    game.field_size_y = field_size_y;
    game.score = 0;
    game.field = malloc(sizeof(uint16_t *) * field_size_y);
    for (size_t i = 0; i < field_size_y; i++) {
        game.field[i] = calloc(field_size_x, sizeof(uint16_t) * field_size_x);
    }

    time_t t;
    srand((unsigned) time(&t));
    game_add_block(game);

    return game;
}

void game_destroy(Game game) {
    for (size_t i = 0; i < game.field_size_y; i++) {
        free(game.field[i]);
    }
    free(game.field);
    game.field = NULL;
}

uint8_t game_move(Game *game, Direction direction) {
    // just one direction for testing purposes
    for (int i = 0; i < game->field_size_y; i++) {
        uint16_t **field = game->field;
        // move everything on one side
        for (int j = 0; j < game->field_size_x - 1; j++) {
            // a, b is the same as i and j. It is just flipped when
            // it does not go horizontally so I can access stuff vertically
            int a = i;
            int b = j;
            if (direction == Up || direction == Down) {
                a = j;
                b = i;
            }
            
            // make it so it can work with different directions
            int directionality = b; // TODO: rename ugly name
            if (direction == Down) {
                directionality = a;
            }
            int movement = 1;
            if (direction == Left || direction == Up) {
                if(direction == Left) {
                    directionality = game->field_size_x - b  - 1;
                } else {
                    directionality = game->field_size_y - a  - 1;
                }
                movement = -1;
            }

            if(direction == Left || direction == Right) {
                if(field[a][directionality + movement] == 0) {
                    field[a][directionality+movement] = field[a][directionality];
                    field[a][directionality] = 0;
                }
            } else {
                if(field[directionality + movement][b] == 0) {
                    field[directionality + movement][b] = field[directionality][b];
                    field[directionality][b] = 0;
                }
            }
        }

        // combine same numbers
        for (int j = 0; j < game->field_size_x - 1; j++) {
            int a = i;
            int b = j;
            if (direction == Up || direction == Down) {
                a = j;
                b = i;
            }
            int directionality = b; // TODO: rename ugly name
            if (direction == Down) {
                directionality = a;

            }
            int movement = 1;
            if (direction == Left || direction == Up) {
                if(direction == Left) {
                    directionality = game->field_size_x - b  - 1;
                } else {
                    directionality = game->field_size_y - a  - 1;
                }
                movement = -1;
            }
            // TODO: fix 444 <- 48, should be 84
            if (direction == Left || direction == Right) {
                if(field[a][directionality + movement] == field[a][directionality]) {
                    field[a][directionality+movement] = field[a][directionality]*2;
                    field[a][directionality] = 0;
                    j++;
                }
            } else {
                if(field[directionality + movement][b] == field[directionality][b]) {
                    field[directionality + movement][b] = field[directionality][b]*2;
                    field[directionality][b] = 0;
                    j++;
                }
            }
        }

        // move everything again
        for (int j = 0; j < game->field_size_x - 1; j++) {
            int a = i;
            int b = j;
            if (direction == Up || direction == Down) {
                a = j;
                b = i;
            }
            int directionality = b; // TODO: rename ugly name
            if (direction == Down) {
                directionality = a;
            }
            int movement = 1;
            if (direction == Left || direction == Up) {
                if(direction == Left) {
                    directionality = game->field_size_x - b  - 1;
                } else {
                    directionality = game->field_size_y - a  - 1;
                }
                movement = -1;
            }
            if(direction == Left || direction == Right) {
                if(field[a][directionality + movement] == 0) {
                    field[a][directionality+movement] = field[a][directionality];
                    field[a][directionality] = 0;
                }
            } else {
                if(field[directionality + movement][b] == 0) {
                    field[directionality + movement][b] = field[directionality][b];
                    field[directionality][b] = 0;
                }
            }
        }
    }

    game_add_block(*game);
    return 0;
}