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

#define EXIT_SUCCESS          0
#define EXIT_WRONGCOMMANDLINE 1
#define EXIT_OPENFILE         2
#define EXIT_WRONGINPUTFORMAT 3
#define EXIT_MEMORY           4


#define LATO   8

typedef char Scacchiera[LATO][LATO];
typedef char Istruzione[3];

#define TRUE  1
#define FALSE 0


void ReadInstructions (int argc, char *argv[], char *InputFile);

void LoadData (char *InputFile, Scacchiera S, char *pGiocatore, int *pNumIstruzioni, Istruzione** pI);

void Othello (Scacchiera S, char *pGiocatore, int NumIstruzioni, Istruzione *I);

void SaveBoard (Scacchiera S);

int LegalMove (int r, int c, char Giocatore, Scacchiera S);

void PerformMove (int r, int c, char Giocatore, Scacchiera S);

void EvaluateBoard (Scacchiera S);


int main(int argc, char *argv[])
{
  char InputFile[256];
  Scacchiera S;
  char Giocatore;
  Istruzione *I;
  int NumIstruzioni;


  // 1) Interpretazione della linea di comando
  ReadInstructions(argc,argv,InputFile);

  // 2) Caricamento dei dati
  LoadData(InputFile,S,&Giocatore,&NumIstruzioni,&I);

  // 3) Algoritmo:
  // Esegue le istruzioni di ListaIstruzioni sulla configurazione iniziale Scacchiera
  Othello(S,&Giocatore,NumIstruzioni,I);

  // 4) Salvataggio dei risultati
  SaveBoard(S);

  // 5) Deallocazione delle strutture dati
  free(I);

  return EXIT_SUCCESS;
}


void ReadInstructions (int argc, char *argv[], char *InputFile)
{
  if (argc != 2)
  {
    printf("Command line format wrong!\n");
    exit(EXIT_WRONGCOMMANDLINE);
  }

  strcpy(InputFile,argv[1]);
}


void LoadData (char *InputFile, Scacchiera S, char *pGiocatore, int *pNumIstruzioni, Istruzione** pI)
{
  FILE *fInputFile;
  int i;

  fInputFile = fopen(InputFile,"r");
  if (fInputFile == NULL)
  {
    printf("File %s does not exist!\n",InputFile);
    exit(EXIT_OPENFILE);
  }

  for (i = 0; i < LATO; i++)
    fscanf(fInputFile,"%s",S[i]);

  fscanf(fInputFile,"\n%c",pGiocatore);

  fscanf(fInputFile,"%d",pNumIstruzioni);
  *pI = (Istruzione *) calloc(*pNumIstruzioni,sizeof(Istruzione));
  if (*pI == NULL)
  {
    printf("Memoria insufficiente per allocare un vettore di %d istruzioni!\n",*pNumIstruzioni);
    exit(EXIT_MEMORY);
  }

  for (i = 0; i < *pNumIstruzioni; i++)
    fscanf(fInputFile,"%s",(*pI)[i]);

  fclose(fInputFile);
}


void Othello (Scacchiera S, char *pGiocatore, int NumIstruzioni, Istruzione *I)
{
  int i, r, c, num;

  for (i = 0; i < NumIstruzioni; i++)
  // Esegue l'istruzione corrente
    switch (I[i][0])
    {
      case 'L': {
                  num = 0;
                  for (r = 0; r < LATO; r++)
                    for (c = 0; c < LATO; c++)
                      if (LegalMove(r,c,*pGiocatore,S))
                      {
                        num++;
                        printf("(%d,%d) ",r+1,c+1);
                      }
                  if (num == 0) printf("Nessuna mossa lecita");
                  printf("\n");
                  break;
                }
      case 'M': {
                  r = I[i][1]-'1';
                  c = I[i][2]-'1';
                  if (!LegalMove(r,c,*pGiocatore,S)) *pGiocatore = ( *pGiocatore == 'B' ? 'N' : 'B' );
                  if (!LegalMove(r,c,*pGiocatore,S))
                    printf("Mossa non lecita\n");
                  else
                  {
                    PerformMove(r,c,*pGiocatore,S);
                    EvaluateBoard(S);
                    *pGiocatore = ( *pGiocatore == 'B' ? 'N' : 'B' );
                  }
                  break;
                }
      case 'Q': {
                  i = NumIstruzioni;
                  break;
                }
      default : {
                  printf("Istruzione non definita!\n");
                  exit(EXIT_WRONGINPUTFORMAT);
                }
    }
}


void SaveBoard (Scacchiera S)
{
  int i, j;

  for (i = 0; i < LATO; i++)
  {
    for (j = 0; j < LATO; j++)
      printf("%c",S[i][j]);
    printf("\n");
  }
}


int LegalMove (int r, int c, char Giocatore, Scacchiera S)
{
  int i, j;
  char Avversario = ( Giocatore == 'B' ? 'N' : 'B' );

  if ( (r < 0) || (r >= LATO) || (c < 0) || (c >= LATO) || (S[r][c] != '-') ) return FALSE;

  i = r;
  for (j = c+1; (j < LATO) && (S[i][j] == Avversario); j++);
  if ( (j > c+1) && (j < LATO) && (S[i][j] == Giocatore) ) return TRUE;

  for (j = c-1; (j >= 0) && (S[i][j] == Avversario); j--);
  if ( (j < c-1) && (j >= 0) && (S[i][j] == Giocatore) ) return TRUE;

  j = c;
  for (i = r+1; (i < LATO) && (S[i][j] == Avversario); i++);
  if ( (i > r+1) && (i < LATO) && (S[i][j] == Giocatore) ) return TRUE;

  for (i = r-1; (i >= 0) && (S[i][j] == Avversario); i--);
  if ( (i < r-1) && (i >= 0) && (S[i][j] == Giocatore) ) return TRUE;

  for (i = r-1, j = c+1; (i >= 0) && (j < LATO) && (S[i][j] == Avversario); i--, j++);
  if ( (i < r-1) && (i >= 0) && (S[i][j] == Giocatore) ) return TRUE;

  for (i = r+1, j = c-1; (i < LATO) && (j >= 0) && (S[i][j] == Avversario); i++, j--);
  if ( (i > r+1) && (i < LATO) && (S[i][j] == Giocatore) ) return TRUE;

  return FALSE;
}


void PerformMove (int r, int c, char Giocatore, Scacchiera S)
{
}


void EvaluateBoard (Scacchiera S)
{
  int i, j;
  int n, b;

  n = b = 0;
  for (i = 0; i < LATO; i++)
    for (j = 0; j < LATO; j++)
      if (S[i][j] == 'B')
        b++;
      else if (S[i][j] == 'N')
        n++;

  printf("Bianco - %d  Nero - %d \n",b,n);
}