#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

void array(char **table , int dimension);
void food();
char move();
void random(char **table, struct snake new_snake); //int *randomx, int *randomy
void clear_screen();
void eat_food();
//void gotoxy()

typedef struct snake
{
    direction_t *head;
    direction_t *tail;



}snake_t;



typedef struct direction
{
    int x;
    int y;


}direction_t;

int main(int argc, char *argv[])

{   int i,j;
    int score=0;

    if(argc!=2)
    {
        return 1;
    }
    else
    {


        if(argv[1] == NULL)
        {
            return 1;
        }
        else
        {
            int size = atoi(argv[1]); //converting argument to integer

            size += 2; //adding 2 extra lines/colums to array (?)
            char **ground = (char**)malloc(size * sizeof(char*));
            free(**ground);
            void array(char **ground, int size);
        }


            // return 0;
            int length=0;
            char keys[NUM_KEYS] = DEFAULT_KEYS;
            do
            {
                keypress = (char)getchar ();

                /* Move the snake one position. */
                 move (&snake, keys, keypress);

                /* keeps cursor flashing in one place instead of following snake */
                gotoxy (1, 1);

                if (collision (&snake, &screen))
                {
                 keypress = keys[QUIT];
                    break;
                }
                else if (collide_object (&snake, &screen, food))
                {

                    show_score (&screen);
                }



                while (keypress != keys[QUIT]);
                {
                    show_score (&screen);

                    gotoxy (32, 6);
                    textcolor (GREEN);
                    printf ("-G A M E  O V E R-");

                    gotoxy (32, 9);
                    textcolor (GREEN);
                    printf ("Another Game (y/n)? ");
                }
            }
            do
            {
                keypress = getchar ();
            }
            while ((keypress != 'y') && (keypress != 'n'));

            while (keypress == 'y');

            clrscr ();

            void food1();

         }
            return 0;
    }
        return 0;
    }
}

void body(struct snake s)
{
    (char*) s.head->x = rand()%size-1;
    (char*) s.head->y = rand()%size-1;
    if ((char*) s.head->x>0 && (char*) head->y>0)
    {


        if(((char*) s.head->x) > 0 && ((char*) s.head->y)<size-1)
        {
            printf("@", s.head);
            move(snake_t *snake, char keys[], char key);
        }
        else
     {
         return 1;
     }
    }
        else
        {
            return 1;
        }

}
void food(**table)
{
    direction_t food;
    int size = atoi(argv[1]);
    food.x = rand()%(size-2);
    food.y = rand()%(size-2);


    if (food.x >0 && food.y>0)
    {
        if(food.x < size && food.y < size)
        {
            char table[food.x][food.y] = 'X';
        }
    }
    else
    {
        return 1;
    }


}


void eat_food() //GIANNH TO FOOD
{

    direction_t food, head;
    char tail = '*';
    food.x = rand()%(size-2);
    food.y = rand()%(size-2);
    time_t a;
    a=time(0);
    srand(a);

    if(head.x == food.x && head.y == food.y)
    {
        char move(snake_t *snake, char keys[], char key);
        table[food.x][food.y] = '*';
        printf("%c", table[food.x][food.y] );
        void array(char **table, int dimension);



    }
    else
    {


    }

}

void random(char **table, struct snake new_snake ) //(char **table, int *randomX, int *randomY)
{

    new_snake.head = (snake_t*)malloc(sizeof(snake_t));


    int i,j;
    int empty_cell;
    int randomX_void, randomY_void;

    do
    {
        randomX_void=rand()%size-1;//generate a random number from 0 to size -1
        randomY_void=rand()%size-1;

        for(i=0; i<size-1; i++){
            for(j=0; j<size-1; j++){
                if(table[randomX_void][randomY_void] == 'X')
                    {
                        eat_food();
                        score++;
                        emptyCell=1;
                        head->x = randomX_void;//store the result in the address of the randomX
                        head->y = randomY_void;
                    }

                else if(table[randomX_void][randomY_void]== '*')
                return 1;
                else if (table[randomX_void][randomY_void]== '-' )
                return 1;
                else if(table[randomX_void][randomY_void]== '|')
                return 1;
                else
                emptyCell=0;
            }
        }



    } while (emptyCell!=1);


}





char move(snake_t *snake, char keys[], char key)
{
    int i;
    int flags;
    char key[4];

    direction_t prev = snake->dir;

       if (key == keys[D])
   {
      snake->dir = RIGHT;
   }
   else if (key == keys[A])
   {
      snake->dir = LEFT;
   }
   else if (key == keys[W])
   {
      snake->dir = UP;
   }
   else if (key == keys[S])
   {
      snake->dir = DOWN;
   }
   else if (key == keys[LEFT_TURN])
   {
      switch (prev)
      {
         case LEFT:
            snake->dir = DOWN; //S?
            break;

         case RIGHT:
            snake->dir = UP; //W?
            break;

         case UP:
            snake->dir = LEFT; //A?
            break;

         case DOWN:
            snake->dir = RIGHT; //P?
            break;

         default:
            break;
      }
   }
   else if (key == keys[RIGHT_TURN])
   {
      switch (prev)
      {
         case LEFT:
            snake->dir = UP;//W? RWTAME GIANNH
            break;

         case RIGHT:
            snake->dir = DOWN;//S?
            break;

         case UP:
            snake->dir = RIGHT;//P?
            break;

         case DOWN:
            snake->dir = LEFT;//A?
            break;

         default:
            break;
      }
   }

   switch (snake->dir) //RVTAME GIANNH
   {
      case LEFT:
         snake->body[snake->length].row = snake->body[snake->length - 1].row;
         snake->body[snake->length].col = snake->body[snake->length - 1].col - 1;
         break;

      case RIGHT:
         snake->body[snake->length].row = snake->body[snake->length - 1].row;
         snake->body[snake->length].col = snake->body[snake->length - 1].col + 1;
         break;

      case UP:
         snake->body[snake->length].row = snake->body[snake->length - 1].row - 1;
         snake->body[snake->length.col = snake->body[snake->length - 1].col;
         break;

      case DOWN:
         snake->body[snake->length].row = snake->body[snake->length - 1].row + 1;
         snake->body[snake->length.col = snake->body[snake->length - 1].col;
         break;

      default:
         /* NOP */
         break;
   }
    flags = fcntl(STDIN_FILENO, F_GETFL);
    fcntl(STDIN_FILENO, F_SETFL, flags|O_NONBLOCK);

    // To get the input from the terminal without pressing the enter button
    system ("/bin/stty raw");
    read(STDIN_FILENO, key, 4);
    // Reset the "system ("/bin/stty raw")" to display correctly the output
    system ("/bin/stty cooked");

    return key[0];

}

void array(char **table, int dimension, int score)
{

    int i, j, dimension;

      for( i=0; i<dimension; i++)
            {
                table[i] = (char*)malloc(dimension * sizeof(char));

            }
            for(i=0; i<dimension; i++)
            {

                for ( j=0; j < dimension; j++)
                {
                    if(i == 0 || i == dimension-1)
                    {
                        table[i][j] = '-';
                    }
                    else if(j==0 || j == dimension-1)
                    {
                        table[i][j] = '|';
                    }
                    else
                    {
                        table[i][j] = ' ';
                    }
                }

            }
            for (i=0;i<dimension; i++)
            {
                for(j=0;j<dimension; ++j)
                {
                    printf("%c",table[i][j]);
                }

                  printf("\n");
                  printf("score: %d\n",score);
            }
}
void clear_screen()
	{
		system("clear");
		return;
	}