#include "function.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

unsigned short int **
creatArea2D (const unsigned int N)
{
  unsigned short int **tab2d;
  tab2d = calloc (N, sizeof (unsigned short int *));
  if (tab2d == NULL)
    {
      return NULL;
    }

  bool fail = false;
  unsigned int i;
  for (i = 0; i < N && !fail; ++i)
    {
      tab2d[i] = calloc (N, sizeof (unsigned short int));
      if (tab2d[i] == NULL)
        {
          fail = true;
        }
    }

  if (fail)
    {
      unsigned int j;
      for (j = 0; j < i; ++j)
        {
          free (tab2d[j]);
        }
      free (tab2d);
      return NULL;
    }
  return tab2d;
}

short int
canIGoDirection (short int valueOfNCase, short int valueOfNPlusOneCase)
{
  if (valueOfNCase != WALL)
    {
      if ((valueOfNCase == BOX && valueOfNPlusOneCase == EMPTY)
          || (valueOfNCase == BOX && valueOfNPlusOneCase == TARGET))
        {

          if (valueOfNPlusOneCase == TARGET)
            {
              // Box on target
              return 3;
            }
          // move the box
          return 2;
        }
      if ((valueOfNCase == BOX_ON_TARGET && valueOfNPlusOneCase == EMPTY)
          || (valueOfNCase == BOX_ON_TARGET && valueOfNPlusOneCase == TARGET))
        {

          if (valueOfNPlusOneCase == TARGET)
            {
              // Box on target and player on target too
              return 6;
            }
          // move the box but player on a target
          return 5;
        }
      if (valueOfNCase == TARGET)
        {
          // move player on target
          return 4;
        }

      if (valueOfNCase == EMPTY)
        {
          // move player
          return 1;
        }
    }

  return 0;
}

void
move (unsigned short int **tab, vect *playerPos, vect direction)
{
  short int valueOfNCase
      = tab[playerPos->x + direction.x][playerPos->y + direction.y];
  short int valueOfNPlusOneCase
      = tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2];

  short int returnValue = canIGoDirection (valueOfNCase, valueOfNPlusOneCase);
  short int playerState = tab[playerPos->x][playerPos->y];

  switch (returnValue)
    {
    case 0:

      break;
    case 1:
      // move player
      tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
      break;
    case 2:
      // move player and the box

      tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
      tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
          = BOX;
      break;
    case 3:
      // move player and the box is well-placed

      tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
      tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
          = BOX_ON_TARGET;
      break;
    case 4:
      // move player on a target

      tab[playerPos->x + direction.x][playerPos->y + direction.y]
          = PLAYER_ON_TARGET;
      break;
    case 5:
      // move box and player on a target

      tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
          = BOX;
      tab[playerPos->x + direction.x][playerPos->y + direction.y]
          = PLAYER_ON_TARGET;
      break;
    case 6:
      // move player on a target and box on a target

      tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
          = BOX_ON_TARGET;
      tab[playerPos->x + direction.x][playerPos->y + direction.y]
          = PLAYER_ON_TARGET;
      break;
    default:
      printf ("Commande inconnue !\n");
    }

  if (returnValue != 0)
    {
      if (playerState == PLAYER_ON_TARGET)
        {
          tab[playerPos->x][playerPos->y] = TARGET;
        }
      else
        {
          tab[playerPos->x][playerPos->y] = EMPTY;
        }
      playerPos->x = playerPos->x + direction.x;
      playerPos->y = playerPos->y + direction.y;
    }
}

void
inGameLoop (unsigned short int **tab2d, int N, vect *playerPos, vect *targets,
            int nbr_targets)
{
  vect direction = { 0, 0 };
  char input;
  bool finish = false;
  while (!finish)
    {

      printf ("Utilisez Z/Q/S/D pour bouger, X pour quitter : ");

      input = getchar ();

      if (input == 'x')
        {
          break; // Quitter le jeu
        }

      switch (input)
        {
        case 'd':
          direction.y = 1;
          direction.x = 0;

          break;
        case 'q':
          direction.y = -1;
          direction.x = 0;
          break;
        case 'z':
          direction.x = -1;
          direction.y = 0;
          break;
        case 's':
          direction.x = 1;
          direction.y = 0;
          break;
        default:
          direction.x = 0;
          direction.y = 0;
        }

      //system ("clear");
      move (tab2d, playerPos, direction);

      printf ("\n");
      if (isWin (tab2d, targets, nbr_targets))
        {
          puts("Win!");
          finish = true;
        }
      if (islose(tab2d, N))
        {
          puts("lose!");
          finish = true;
        }
      screenDisplay (tab2d, N);
    }
}

bool
isWin (unsigned short int **tab2d, vect *targets, int nbr_targets)
{
  int i;
  for (i = 0; i < nbr_targets; ++i)
    {
      int x = targets[i].x;
      int y = targets[i].y;
      if (tab2d[x][y] != BOX_ON_TARGET)
        {
          return false;
        }
    }
  return true;
}

bool
islose (unsigned short int **tab2d, const int N)
{
  int x = 0, y = 0;
  for (x = 0; x < N; ++x)
    {
      for (y = 0; y < N; ++y)
        {
          bool isblock = false;
          if (tab2d[x][y] == BOX)
            {
              vect box;
              box.x = x;
              box.y = y;
              isblock = blockBox (tab2d, N, box);
            }

          if (isblock)
            {
              printf("%d %d", x, y);
              return true;
            }
        }
    }
  return false;
}

vect
plusVect (vect one, vect two)
{
  vect result;
  result.x = one.x + two.x;
  result.y = one.y + two.y;
  return result;
}

int
lengthVect (vect vector)
{
  return abs (vector.x) + abs (vector.y);
}

bool
blockBox (unsigned short int **tab2d, const int N, vect box_coor)
{
  int nbr_touch = 0;
  vect card[4] = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 } };
  int *indice_card = NULL;
  int id_box = -1;
  int i;
  for (i = 0; i < 4; ++i)
    {
      vect test = plusVect (box_coor, card[i]);
      unsigned short int val = tab2d[test.x][test.y];
      if (val == BOX || val == WALL || val == BOX_ON_TARGET)
        {
          nbr_touch++;
          if(val == BOX || val == BOX_ON_TARGET)
          {
            id_box = nbr_touch -1;
          }
          
          indice_card = realloc (indice_card, sizeof (int) * nbr_touch);
          indice_card[nbr_touch - 1] = i;
          
          printf("i = %d, (%d, %d)\n", i, test.x, test.y);
        }
    }
  printf("nbr_touch = %d\n", nbr_touch);
  if (nbr_touch == 0)
    return false;

  if (nbr_touch >= 3)
  {
    if(id_box != -1)
    {
      vect test = plusVect(card[indice_card[(id_box+1) %3]], card[indice_card[(id_box+2) %3]]);
      if (test.x == 0 && test.y == 0) return false;
    }
    return true;
  }


  if (nbr_touch == 2)
    {
      
      int id1 = indice_card[0];
      int id2 = indice_card[1];
      vect add = plusVect (card[id1], card[id2]);
      if(lengthVect (add) == 2)
      {
        if (id_box == -1) return true;
        vect test = plusVect(card[indice_card[id_box]], card[indice_card[(id_box+1) %2]]);
        test = plusVect(test, box_coor);
        printf("Vect test : %d %d\n", test.x, test.y);
        if (tab2d[test.x][test.y] == WALL) return true;
      }
      return false;
    }

  vect normal = card[indice_card[0]];
  vect director1 = card[(indice_card[0] + 1) % 4];
  vect director2 = card[(indice_card[0] + 1) % 4];
  vect dir_test[2] = { director1, director2 };

  bool wall = false;
  vect current = plusVect (box_coor, director1);

  for (int i = 0; i < 2; ++i)
    {
      vect current = plusVect (box_coor, dir_test[i]);
      while (!wall)
        {
          unsigned short int val = tab2d[current.x][current.y];
          if (val == WALL) wall = true;
          if (val == TARGET) return false;

          vect cur_nor = plusVect (current, normal);
          val = tab2d[cur_nor.x][cur_nor.y];
          if (val != WALL || val != BOX || val != BOX_ON_TARGET)
            {
              puts("false");
              return false;
            }
           
        }
        puts("fait");
    }
  return true;
  perror("error in blockBox");
  exit(0);
}