#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <ncurses.h>
#include <unistd.h>
#include <termios.h>
#include <limits.h>
#include <time.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>

#include "hash.h"
#include "structure.h"
#include "base.h"
#include "generation.h"
#include "display.h"
#include "move.h"

double speed = 0.5 ;
int precision = 12 ;

double εx = 0.0;
double εy = 0.0;

bool checkCollision() {
    return (unpack_coord(gridGet(map, player_cx, player_cy)->chdata.lines, player_x, player_y));
}

bool checkCollision2(int cx, int cy, int x, int y) {
    return (unpack_coord(gridGet(map, cx, cy)->chdata.lines, y, x));
}

void normalize(int* ch_coord, int* coord, double* ε) {
    if(*ε >= 1.0) {
        *ε -= 1.0 ;
        *coord += 1 ;
        if(*coord >= 8) {
            *coord -= 8 ;
            *ch_coord += 1;
        }
    } else if(*ε < 0.0) {
        *ε += 1.0 ;
        *coord -= 1 ;
        if(*coord < 0) {
            *coord += 8 ;
            *ch_coord -= 1;
        }
    }
}

bool checkCollisionSquare(double square_size) {
    double εxmin = εx - square_size;
    double εxmax = εx + square_size;
    double εymin = εy - square_size;
    double εymax = εy + square_size;

    int xmin = player_x ;
    int xmax = player_x ;
    int ymin = player_y ;
    int ymax = player_y ;

    int cxmin = player_cx ;
    int cxmax = player_cx ;
    int cymin = player_cy ;
    int cymax = player_cy ;

    normalize(&cxmin, &xmin, &εxmin);
    normalize(&cxmax, &xmax, &εxmax);
    normalize(&cymin, &ymin, &εymin);
    normalize(&cymax, &ymax, &εymax);

    return (
        checkCollision2(cxmin, cymin, xmin, ymin) ||
        checkCollision2(cxmin, cymax, xmin, ymax) ||
        checkCollision2(cxmax, cymin, xmax, ymin) ||
        checkCollision2(cxmax, cymax, xmax, ymax)
    );
}

void increment_x(double dx) {
    εx = εx + dx ;
    if(εx >= 1.0) {
        εx -= 1.0 ;
        player_x += 1 ;
        if(player_x >= 8) {
            player_x -= 8 ;
            player_cx += 1;
        }
    } else if(εx < 0.0) {
        εx += 1.0 ;
        player_x -= 1 ;
        if(player_x < 0) {
            player_x += 8 ;
            player_cx -= 1;
        }
    }
}

void increment_y(double dy) {
    εy += dy ;
    if(εy >= 1.0) {
        εy -= 1.0 ;
        player_y += 1 ;
        if(player_y >= 8) {
            player_y -= 8 ;
            player_cy += 1;
        }
    } else if(εy < 0.0) {
        εy += 1.0 ;
        player_y -= 1 ;
        if(player_y < 0) {
            player_y += 8 ;
            player_cy -= 1;
        }
    }
}

bool moveRequest(double dx, double dy) {
    increment_x(dx);
    increment_y(dy);
    if(checkCollisionSquare(0.15)) {
        increment_x(-dx);
        increment_y(-dy);
        return false;
    };
    return true;
}

void moveControl(bool* halt) {
    SDL_Event event;
    int i = 0;
    while(SDL_PollEvent(&event)) {
        switch (event.type) {
            case SDL_QUIT:
                break;
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym) {
                    case SDLK_z:
                        while(i < precision && moveRequest(0.0, -speed/precision)) {
                            i += 1;
                        };
                        break;
                    case SDLK_q:
                        while(i < precision && moveRequest(-speed/precision, 0.0)) {
                            i += 1;
                        };
                        break;
                    case SDLK_s:
                        while(i < precision && moveRequest(0.0, speed/precision)) {
                            i += 1;
                        };
                        break;
                    case SDLK_d:
                        while(i < precision && moveRequest(speed/precision, 0.0)) {
                            i += 1;
                        };
                        break;
                    case SDLK_TAB:
                        *halt = true;
                        break;
                    case SDLK_m:
                        zoom = max(25, zoom-25);
                        break;
                    case SDLK_p:
                        zoom = min(2250, zoom+25);
                        break;
                }
        }
    }
}

void moveFunctionMaster(SDL_Renderer* renderer) {
    bool halt = false ;
    while(!halt) {
        moveControl(&halt);
        resetRenderer(renderer);
        drawMapToRenderer(renderer, -300 * 250/zoom + to_int(50 * (8*player_cx + player_x + εx)), 300 * 250/zoom + to_int(50 * (8*player_cx + player_x + εx)), -300 * 250/zoom + to_int(50 * (8*player_cy + player_y + εy)), 300 * 250/zoom + to_int(50 * (8*player_cy + player_y + εy)));
        //drawMapToRendererV2(renderer, -300 * 250/zoom + to_int(50 * (8*player_cx + player_x + εx)), 300 * 250/zoom + to_int(50 * (8*player_cx + player_x + εx)), -300 * 250/zoom + to_int(50 * (8*player_cy + player_y + εy)), 300 * 250/zoom + to_int(50 * (8*player_cy + player_y + εy)));
        drawNumberToRenderer(renderer, digits, player_cx, 10, 10, 50, 70, 0);
        drawNumberToRenderer(renderer, digits, player_cy, 10, 80, 50, 70, 0);
        drawNumberToRenderer(renderer, digits, player_x, __width__ / 3, 10, 50, 70, 0);
        drawNumberToRenderer(renderer, digits, player_y, __width__ / 3, 80, 50, 70, 0);
        drawNumberToRenderer(renderer, digits, to_int(εx*100), 2 * __width__ / 3, 10, 50, 70, 0);
        drawNumberToRenderer(renderer, digits, to_int(εy*100), 2 * __width__ / 3, 80, 50, 70, 0);
        updateRenderer(renderer);
        //exit(1);
        draw_par += 1 ;
        //usleep(20000);
    }
}