#include "map.hpp"
#include <cstdlib>
#include <allegro5/allegro_primitives.h>
#include <allegro5/allegro_native_dialog.h>
#include "ai.hpp"

map *init_map(const int size, const int window_wh, const int margin_map)
{
    map *m = (map *)malloc(sizeof(map));

    float map_wh = 0;                             // размер карты с учётом отступов
    float cell_width = 0;                         // ширина ячейки
    float cell_margin = 0;                        // отступ внутри ячейки
    float line_count = 0;                         // количество линий на одно направление
    float line_width = 0;                         // ширина линии
    float cell_sym_width = 0;                     // ширина сивола внутри ячейки

    m->size = size;
    m->window_wh = window_wh;
    m->margin_map = margin_map;
    m->toWin = size;

    line_count = size - 1;
    map_wh = window_wh - margin_map * 2;
    line_width = map_wh * 0.0036;
    cell_width = map_wh / size;
    cell_margin = cell_width * 0.0538;
    cell_sym_width = cell_width - (line_width * 2) - (cell_margin * 2);

    m->sym_width = cell_sym_width;

    m->cells = (cell ***)malloc(sizeof(cell **) * (size * size));

    for (int i = 0; i < size; ++i)
    {
        m->cells[i] = (cell **)malloc(sizeof(cell *) * size);

        for (int j = 0; j < size; ++j)
        {
            m->cells[i][j] = create_cell(j, i, cell_width, cell_margin, line_width, margin_map);
        }
    }

    m->grid = (line ***)malloc(sizeof(line **) * (line_count * line_count));

    for (int i = 0; i < 2; ++i)
    {
        m->grid[i] = (line **)malloc(sizeof(line *) * line_count);

        DIRECTION d = (i == 0 ? HORIZONTAL : VERTICAL);

        for (int j = 0; j < line_count; ++j)
        {
            m->grid[i][j] = create_line(d, j, line_width, map_wh, cell_width, margin_map);
        }
    }

    return m;
}

cell *create_cell(const float row, const float col, const float cell_width, const float cell_margin, const float line_width, const float margin_map)
{
    cell *c = (cell *)malloc(sizeof(cell));
    c->select = false;
    c->is_draw = false;
    c->pos_x = row * cell_width + margin_map;
    c->pos_y = col * cell_width + margin_map;
    c->width = cell_width;
    c->sym_pos_x = c->pos_x + line_width + cell_margin;
    c->sym_pos_y = c->pos_y + line_width + cell_margin;
    c->p = EMPTY;
    return c;
}

line *create_line(DIRECTION d, const float row, const float line_width, const float map_wh, const float cell_width, const float margin_map)
{
    line *l = (line *)malloc(sizeof(line));
    l->d = d;
    l->height = map_wh;
    l->width = line_width;
    if (d == HORIZONTAL)
    {
        l->pos_x = margin_map;
        l->pos_y = (row + 1) * cell_width + margin_map - line_width;
    }
    else
    {
        l->pos_x = (row + 1) * cell_width + margin_map - line_width;
        l->pos_y = margin_map;
    }

    return l;
}

void draw_map(const map *m, ALLEGRO_BITMAP *bx, ALLEGRO_BITMAP *bo)
{
    int size = m->size;

    int swh = al_get_bitmap_width(bx);

    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < size; ++j)
        {
            cell *c = m->cells[i][j];

            if (c->is_draw)
            {
                if (c->p == HUMAN)
                    al_draw_scaled_bitmap(bx, 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
                else
                    al_draw_scaled_bitmap(bo, 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
            }

            if (c->select)
            {
                if (c->is_draw)
                    al_draw_tinted_scaled_bitmap(bx, al_map_rgba_f(255, 0, 0, 0.3), 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
                else
                    al_draw_tinted_scaled_bitmap(bx, al_map_rgba_f(0, 255, 0, 0.3), 0, 0, swh, swh, c->sym_pos_x, c->sym_pos_y, m->sym_width, m->sym_width, 0);
            }
        }
    }

    for (int i = 0; i < 2; ++i)
    {
        for (int j = 0; j < size - 1; ++j)
        {
            line *l = m->grid[i][j];

            if (l->d == HORIZONTAL)
                al_draw_filled_rectangle(l->pos_x, l->pos_y, l->pos_x + l->height, l->pos_y + l->width, al_map_rgb(0, 0, 0));
            else
                al_draw_filled_rectangle(l->pos_x, l->pos_y, l->pos_x + l->width, l->pos_y + l->height, al_map_rgb(0, 0, 0));
        }
    }
}

void select_cell(map *m, const int mouse_x, const int mouse_y)
{
    int size = m->size;

    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < size; ++j)
        {
            cell *c = m->cells[i][j];

            if ((mouse_x >= c->pos_x && mouse_y >= c->pos_y) &&
                    (mouse_x <= (c->pos_x + c->width) && mouse_y <= (c->pos_y + c->width)) && c->p != HUMAN)
                c->select = true;
            else
                c->select = false;
        }
    }
}

bool enter_cell(map *m, const int mouse_x, const int mouse_y, PLAYER p)
{
    int size = m->size;

    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < size; ++j)
        {
            cell *c = m->cells[i][j];

            if (!c->is_draw && (mouse_x >= c->pos_x && mouse_y >= c->pos_y) &&
                    (mouse_x <= (c->pos_x + c->width) && mouse_y <= (c->pos_y + c->width)))
            {
                c->is_draw = true;
                c->p = p;
                return true;
            }
        }
    }

    return false;
}

void clear_map(map *m)
{
    int size = m->size;

    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < size; ++j)
        {
            cell *c = m->cells[i][j];

            c->is_draw = false;
            c->select = false;
            c->p = EMPTY;
        }
    }
}

bool game_check(map *m, ALLEGRO_DISPLAY *d)
{
    int answer = -1;

    if (checkWin(m, HUMAN))
        answer = al_show_native_message_box(d, "Игра окончена!", "Вы победили!",
                        "Начать игру сначала?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);

    if (checkWin(m, AI))
        answer = al_show_native_message_box(d, "Игра окончена!", "Вы проиграли!",
                        "Начать игру сначала?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);

    if (isDraw(m))
        answer = al_show_native_message_box(d, "Игра окончена!", "Ничья!",
                        "Начать игру сначала?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);

    if (answer == 1)
        clear_map(m);
    else if (answer == 0 || answer == 2)
        return true;

    return false;
}

void free_map(map *m)
{
    for (int i = 0; i < m->size; ++i)
    {
        for (int j = 0; j < m->size; ++j)
        {
            free(m->cells[i][j]);
        }
        free(m->cells[i]);
    }
    free(m->cells);

    for (int i = 0; i < 2; ++i)
    {
        for (int j = 0; j < m->size - 1; ++j)
        {
            free(m->grid[i][j]);
        }
        free(m->grid[i]);
    }
    free(m->grid);

    free(m);
}

bool exit_game(ALLEGRO_DISPLAY *d)
{
    int answer = al_show_native_message_box(d, NULL, "Выход из игры",
            "Вы хотите закончить игру?", NULL, ALLEGRO_MESSAGEBOX_YES_NO);

    if (answer == 1)
        return true;
    else
        return false;
}