/*
    Copyright 2019 YorKnEz
*/

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

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

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;

char zero[5][4] = {
    "111",
    "1 1",
    "1 1",
    "1 1",
    "111"
},
one[5][4] = {
    "11 ",
    " 1 ",
    " 1 ",
    " 1 ",
    "111"
},
two[5][4] = {
    "111",
    "  1",
    "111",
    "1  ",
    "111"
},
three[5][4] = {
    "111",
    "  1",
    "111",
    "  1",
    "111"
},
four[5][4] = {
    "  1",
    " 11",
    "1 1",
    "111",
    "  1"
},
five[5][4] = {
    "111",
    "1  ",
    "111",
    "  1",
    "111"
},
six[5][4] = {
    "111",
    "1  ",
    "111",
    "1 1",
    "111"
},
seven[5][4] = {
    "111",
    "  1",
    " 1 ",
    "1  ",
    "1  "
},
eight[5][4] = {
    "111",
    "1 1",
    "111",
    "1 1",
    "111"
},
nine[5][4] = {
    "111",
    "1 1",
    "111",
    "  1",
    "111"
},
digit1[5][4] = {
    "  1",
    " 11",
    "1 1",
    "111",
    "  1"
},
digit2[5][4] = {
    "111",
    "1 1",
    "1 1",
    "1 1",
    "111"
},
digit3[5][4] = {
    "  1",
    " 11",
    "1 1",
    "111",
    "  1"
};

uint fps = 10;
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;
}

void digit_update (char digit[5][4], char new_digit[5][4]) {
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            digit[i][j] = new_digit[i][j];
        }
    }
}

void update_digits () {
    int len_cpy = len;
    int digit_cnt = 0;

    digit_update(digit1, zero);
    digit_update(digit2, zero);
    digit_update(digit3, zero);

    while (len_cpy != 0) {
        if (len_cpy % 10 == 0) {
            if (digit_cnt == 0) {
                digit_update(digit1, zero);
            } else if (digit_cnt == 1) {
                digit_update(digit2, zero);
            } else if (digit_cnt == 2) {
                digit_update(digit3, zero);
            }
        } else if (len_cpy % 10 == 1) {
            if (digit_cnt == 0) {
                digit_update(digit1, one);
            } else if (digit_cnt == 1) {
                digit_update(digit2, one);
            } else if (digit_cnt == 2) {
                digit_update(digit3, one);
            }
        } else if (len_cpy % 10 == 2) {
            if (digit_cnt == 0) {
                digit_update(digit1, two);
            } else if (digit_cnt == 1) {
                digit_update(digit2, two);
            } else if (digit_cnt == 2) {
                digit_update(digit3, two);
            }
        } else if (len_cpy % 10 == 3) {
            if (digit_cnt == 0) {
                digit_update(digit1, three);
            } else if (digit_cnt == 1) {
                digit_update(digit2, three);
            } else if (digit_cnt == 2) {
                digit_update(digit3, three);
            }
        } else if (len_cpy % 10 == 4) {
            if (digit_cnt == 0) {
                digit_update(digit1, four);
            } else if (digit_cnt == 1) {
                digit_update(digit2, four);
            } else if (digit_cnt == 2) {
                digit_update(digit3, four);
            }
        } else if (len_cpy % 10 == 5) {
            if (digit_cnt == 0) {
                digit_update(digit1, five);
            } else if (digit_cnt == 1) {
                digit_update(digit2, five);
            } else if (digit_cnt == 2) {
                digit_update(digit3, five);
            }
        } else if (len_cpy % 10 == 6) {
            if (digit_cnt == 0) {
                digit_update(digit1, six);
            } else if (digit_cnt == 1) {
                digit_update(digit2, six);
            } else if (digit_cnt == 2) {
                digit_update(digit3, six);
            }
        } else if (len_cpy % 10 == 7) {
            if (digit_cnt == 0) {
                digit_update(digit1, seven);
            } else if (digit_cnt == 1) {
                digit_update(digit2, seven);
            } else if (digit_cnt == 2) {
                digit_update(digit3, seven);
            }
        } else if (len_cpy % 10 == 8) {
            if (digit_cnt == 0) {
                digit_update(digit1, eight);
            } else if (digit_cnt == 1) {
                digit_update(digit2, eight);
            } else if (digit_cnt == 2) {
                digit_update(digit3, eight);
            }
        } else if (len_cpy % 10 == 9) {
            if (digit_cnt == 0) {
                digit_update(digit1, nine);
            } else if (digit_cnt == 1) {
                digit_update(digit2, nine);
            } else if (digit_cnt == 2) {
                digit_update(digit3, nine);
            }
        }

        digit_cnt++;

        len_cpy /= 10;
    }
}

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);

        move_snake();

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

            update_digits();

            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);
        }
    }

    //176, 158, 106

    for (int k = 0; k < 3; k++) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                if (k == 0) {
                    if (digit3[i][j] == '1') {
                        SDL_Rect rect = { ((j+(k*3)) * 10), (i * 10), 10, 10 };
                        SDL_SetRenderDrawColor(renderer, 176, 158, 106, 255);
                        SDL_RenderFillRect(renderer, &rect);
                    }
                } else if (k == 1) {
                    if (digit2[i][j] == '1') {
                        SDL_Rect rect = { ((j+(k*3)+1) * 10), (i * 10), 10, 10 };
                        SDL_SetRenderDrawColor(renderer, 176, 158, 106, 255);
                        SDL_RenderFillRect(renderer, &rect);
                    }
                } else if (k == 2) {
                    if (digit1[i][j] == '1') {
                        SDL_Rect rect = { ((j+(k*3)+2) * 10), (i * 10), 10, 10 };
                        SDL_SetRenderDrawColor(renderer, 176, 158, 106, 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);
}