#include <SDL2/SDL.h>
#include <stdio.h>
#include <cstdlib>
#include <time.h>

#define TITLE "Snake"
#define SQUARE_SIZE 20
#define BOARD_SIZE 20

typedef unsigned int uint;

bool quit = false;

uint16_t window_size = BOARD_SIZE * BOARD_SIZE;

typedef struct SnakePiece {
    int x;
    int y;
    SnakePiece *next;
} SnakePiece;

SnakePiece *head = NULL;

int headx, heady,
    tailx, taily,
    len;

int x_increment = 0, y_increment = -1;

int fruitx, fruity;

uint fps = 15;
uint minframetime = 1000 / fps;

SDL_Keycode keycode = SDLK_w;

void events(SDL_Window *window);

void draw(SDL_Renderer *renderer);

void add_piece (int x_data, int y_data) {
    SnakePiece *new_piece = (SnakePiece *) malloc (sizeof(SnakePiece));

    new_piece->x = x_data;
    new_piece->y = y_data;

    tailx = x_data;
    taily = y_data;

    new_piece->next = head;
    head = new_piece;

    len++;
}

void initialize_snake () {
    headx = tailx = (BOARD_SIZE)/2-1;
    heady = taily = (BOARD_SIZE)/2-1;

    add_piece (headx, heady);

    for (int i = 0; i < 3; i++) {
        add_piece (tailx, taily+1);
    }
}

void move_snake () {

    SnakePiece *ptr;

    ptr = head;

    int old_x, old_y;

    for (int i = 0; i < len; i++) {
        if (i == len-1) {
            old_x = ptr->x;
            old_y = ptr->y;

            if (x_increment == -1 && (headx + x_increment) == -1) {
                ptr->x = BOARD_SIZE-1;

                headx = ptr->x;
            } else if (x_increment == 1 && (headx + x_increment) == BOARD_SIZE) {
                ptr->x = 0;

                headx = ptr->x;
            } else if (y_increment == -1 && (heady + y_increment) == -1) {
                ptr->y = BOARD_SIZE-1;

                heady = ptr->y;
            } else if (y_increment == 1 && (heady + y_increment) == BOARD_SIZE) {
                ptr->y = 0;

                heady = ptr->y;
            } else {
                ptr->x += x_increment;
                ptr->y += y_increment;

                headx = ptr->x;
                heady = ptr->y;

                break;
            }
        }

        ptr = ptr->next;
    }

    ptr = head;

    int old_x2, old_y2;

    for (int i = 0; i < len-1; i++) {
        for (int j = 0; j < (len-1)-i; j++) {
            if (j == (len-2)-i) {
                old_x2 = ptr->x;
                old_y2 = ptr->y;

                ptr->x = old_x;
                ptr->y = old_y;

                old_x = old_x2;
                old_y = old_y2;
            }

            ptr = ptr->next;
        }

        ptr = head;
    }

    tailx = ptr->x;
    taily = ptr->y;
}

void is_overlapping () {
    SnakePiece *ptr;

    ptr = head;

    for (int i = 0; i < len-1; i++) {
        if (headx == ptr->x && heady == ptr->y) {
            quit = true;

            break;
        }

        ptr = ptr->next;
    }
}

bool can_gen_fruit () {
    SnakePiece *ptr;

    ptr = head;

    for (int i = 0; i < len ; i++) {
        if (fruitx == ptr->x && fruity == ptr->y) {
            return false;
        }

        ptr = ptr->next;
    }

    return true;
}

void generate_fruit () {
    fruitx = rand() % (BOARD_SIZE-2) + 1;
    fruity = rand() % (BOARD_SIZE-2) + 1;
}

int main(int argc, char **argv) {
    srand(time(NULL));

    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);

    SDL_Window *window =
        SDL_CreateWindow(
            TITLE,
            SDL_WINDOWPOS_CENTERED,
            SDL_WINDOWPOS_CENTERED,
            window_size,
            window_size,
            SDL_WINDOW_SHOWN);

    SDL_Renderer *renderer =
        SDL_CreateRenderer(
            window,
            -1,
            SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

    initialize_snake();

    generate_fruit();

    while (!quit) {
        int start = SDL_GetTicks();

        events(window);

        is_overlapping();

        move_snake();

        if (headx == fruitx && heady == fruity) {
            add_piece(tailx, taily);

            while (!can_gen_fruit()) {
                SDL_Rect rect = { (fruitx * 20), (fruity * 20), 20, 20 };
                SDL_SetRenderDrawColor(renderer, 255, 236, 179, 255);
                SDL_RenderFillRect(renderer, &rect);
                generate_fruit();
            }
        }

        draw(renderer);

        SDL_RenderPresent(renderer);

        int time = SDL_GetTicks() - start;
        int sleepTime = minframetime - time;
        if (sleepTime > 0) {
            SDL_Delay(sleepTime);
        }
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

void events(SDL_Window *window) {
    SDL_Event event;

    while (SDL_PollEvent(&event) != 0) {
        if (event.type == SDL_QUIT) {
            quit = true;
        }
        else if (event.type == SDL_KEYDOWN) {
            SDL_Keycode new_keycode = event.key.keysym.sym;

            if (new_keycode == SDLK_d && keycode != SDLK_a) {
                x_increment = 1;
                y_increment = 0;

                keycode = new_keycode;

                break;
            } else if (new_keycode == SDLK_a && keycode != SDLK_d) {
                x_increment = -1;
                y_increment = 0;

                keycode = new_keycode;

                break;
            } else if (new_keycode == SDLK_w && keycode != SDLK_s) {
                x_increment = 0;
                y_increment = -1;

                keycode = new_keycode;

                break;
            } else if (new_keycode == SDLK_s && keycode != SDLK_w) {
                x_increment = 0;
                y_increment = 1;

                keycode = new_keycode;

                break;
            }
        }
    }
}

void draw(SDL_Renderer *renderer) {
    SDL_SetRenderDrawColor(renderer, 255, 236, 179, 255);
    SDL_RenderClear(renderer);

    for (int i = 0; i < 20; i++) {
        for (int j = 0; j < 20; j++) {
            SDL_Rect rect = { (i * 20), (j * 20), 20, 20 };
            SDL_SetRenderDrawColor(renderer, 255, 236, 179, 255);
            SDL_RenderFillRect(renderer, &rect);
        }
    }

    SnakePiece *ptr;

    ptr = head;

    while (ptr) {
        SDL_Rect rect = { (ptr->x * 20), (ptr->y * 20), 20, 20 };
        SDL_SetRenderDrawColor(renderer, 100, 221, 23, 255);
        SDL_RenderFillRect(renderer, &rect);

        ptr = ptr->next;
    }

    SDL_Rect rect = { (fruitx * 20), (fruity * 20), 20, 20 };
    SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
    SDL_RenderFillRect(renderer, &rect);
}