#include "snake.h"
#include <stdlib.h>
#include <stdbool.h>

struct snake* add_snake(struct snake* snake,int x,int y)
{
    //vytvori novu prazdnu instanciu a alokujee jej pamat
   struct snake* newSnake = (struct snake*)malloc(sizeof(struct snake));
   //prida X,Y suradnice do polia do novej hlavicky
   newSnake->x = x;
   newSnake->y = y;

   //nalinkuje ju na staru hlavicku
   newSnake->next = snake;
   
   return newSnake;
}

struct snake* remove_snake(struct snake* snake){

    struct snake* currentPtr = snake;
    struct snake* prevPtr;
    
    if (snake == NULL)
    {
        return NULL;
    }
    while (1)
    {
        //pomocny pointer -> ulozenie predoslej casti/node-u
        prevPtr = currentPtr;
        //skontroluje, ze ci dalsia cast je PRAZDNA.
        if (currentPtr->next == NULL)
        {
            //uprava listu -> odlinkje tuto cast (tak aby prevPtr->next NEFERENCOVAL na uz uvolnenu cast)
            prevPtr->next = NULL;
            //uvolni pamat pre akt. cast (uvolni pamat)
            free(currentPtr);
            break;
        }
        //iteruj ku dalsiej casti (node)
        currentPtr = currentPtr->next;
    }
    return snake;
}

void free_snake(struct snake* sn)
{
    //pomocna smernikova premenna
    struct snake* currentPtr = sn;
    while (currentPtr != NULL)
    {
        //uloz dalsiu cast, zmaz aktualnu a posun sa na dalsiu
        struct snake* nextPtr = currentPtr->next;
        free(currentPtr);
        currentPtr = nextPtr;
    }
}

int is_snake(struct snake* snake,int x,int y){
    
    //helper pointer/smernikova premena
    struct snake* currentPtr = snake;
    
    //iteracia cez vsetky casti az dokial sa nenajde cast/node s rovnakymi X,Y suradncami 
    while (currentPtr != NULL)
    {
        if (currentPtr->x == x && currentPtr->y == y)
        {
            return 1;
        }
        //prejde/iteruje na dalsiu cast
        currentPtr = currentPtr->next;
    }
    return 0;
}

/* Funguje na zaklade viacerych faz, ktore sa opakuju kazdy cyklus
    FAZY: 1. -> Kontrola kolizie (seba + vs. stien)
          2. -> Kontrola logiky zobratia jedla (resp. kolizie s jedlom, update statusu, pripadny narast hada)
          3. -> Realizacia pohybu  
          4. -> finalna kontrola poctu jedla */
int step_state(struct state* st){
	int nx = (st->snake->x + st->sx);
    int ny = (st->snake->y + st->sy);

    //helper lok. premena na kontrolovanie, ci uz jedlo bolo zjedene v tomto update cykle
    bool hasEatenFoodinThisCycle = false;

    //** 1. faza
    //ak je snake (nejak) mimo hracieho pola:
    if (nx < 0 || ny < 0)
    {
        return END_WALL;
    }
    //vrati END_WALL, ak had narazi do steny (a jeho X,Y suradnice su mimo hrac. polia)
    if (nx >= st->height || ny >= st->width)
    {
        return END_WALL;
    }

    //** kontrola seba kolizie
    if (is_snake(st->snake, nx, ny)) { return END_SNAKE;}

    //** 2. faza kontroly (zobratia) jedla:
    for (int i = 0; i < FOOD_COUNT; i++)
    {   
        //zoberie jedlo (AK sa X,Y suradnice rovnaju)
        if (st->foodx[i] == nx && st->foody[i] == ny)
        {
            //updatne stav/state hry (-1 stav signalizuje, ze jedlo bolo uz zobrate)
            st->foodx[i] = -1;
            st->foody[i] = -1;
            
            add_snake(st->snake, nx, ny);

            hasEatenFoodinThisCycle = true;
            
            break;
        }
        //hra bude pokracovat normalne dalej, ak NIE JE vsetko jedlo zobrate
        if (st->foodx[i] != -1) 
        {
            return END_CONTINUE;
        }
    }

    //normalny pohyb snake-a (ak jedlo nebolo zjedene v tomto update cykle)
    if (!hasEatenFoodinThisCycle)
    {
        st->snake = add_snake(st->snake, nx, ny);
        st->snake = remove_snake(st->snake);
    }

    //faza kontrola poctu jedla 
    for (int i = 0; i < FOOD_COUNT; i++)
    {
        if (st->foodx[i] != -1)
        {
            return END_CONTINUE;
        }
    }
    return END_FOOD;
}