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

void Assegna_valori(int n, char scacchiera[45][45],int riga,int colonna,char *tempA,char *tempB,char *tempC,char *tempD,char *tempE, char *tempF,char *tempG,char *tempH);
void stampa_matrice(char scacchiera[45][45]);
int conta_vive(char,char,char,char,char,char,char,char);

int main() {
/**
 * Si consideri una scacchiera in cui ogni casella rappresenta una cellula, che può essere viva o morta
 * Prendendo in esame ogni singola casella, ne aggiorna il suo state in base al numero di cellule vive
 * che gli sono intorno.
 */
char scacchiera[45][45];
/*
La scacchiera deve essere aggiornata solo alla fine di ogni passo: ciò significa che l’algoritmo deve usare un
array per memorizzare la scacchiera attuale e un array per memorizzare la scacchiera
modificata
*/
char scacchiera_temporanea[45][45];

char A,B,C,D,E,F,G,H;
int lives = 0;
int colonna=0,riga=0;
int rig=0,col=0;
int i=0,j=0,n=45,itest=0,ntest=0;
int scelta;
int iv,nv,cv,rv;
// I due for assegnano all'intera matrice il valore ' ', riempiendo la matrice di cellule al momento "morte".
for (j=0; j<n; j++)    {
 for(i=0; i<n; i++) {
        scacchiera[j][i] = ' ';
                    }
                       }
// La scelta dell'utente determina la nostra configurazione iniziale di cellule "vive"

printf("Specificare quale test vuoi effettuare :\n");
printf("1) Solo 7 cellule centrali della riga centrale sono vive\n");
printf("2) Solo 7 cellule centrali della colonna centrale sono vive\n");
printf("3) Solo le 4 cellule in posizione 22,22 22,23 23,22 23,23 sono vive\n");
printf("4) Inserisci manualmente la configurazione\n>");

scanf("%d", &scelta);

switch(scelta) {
    case 1:
        // Modifichiamo la riga centrale della scacchiera in modo che in mezzo ad essa ci siano 7 cellule vive
        itest=19;
        ntest=25;
        // il for va da 19 a 25 in modo da sfruttare direttamente l'indice per la modifica della matrice
        for(itest=19;itest<=ntest;itest++) {

            scacchiera[22][itest] = '*';
        // Passiamo quindi le cellule dallo stato morte a vive
        }
    break;

    case 2:
        // Modifichiamo la colonna centrale della scacchiera in modo che in mezzo ad essa ci siano 7 cellule vive
        itest=19;
        ntest=25;
         // il for va da 19 a 25 in modo da sfruttare direttamente l'indice per la modifica della matrice
        for(itest=19;itest<=ntest;itest++) {
         scacchiera[itest][22] = '*';
        // Passiamo quindi le cellule dallo stato morte a vive
        }
    break;

    case 3:
        // Nella terza configurazione, passiamo direttamente le coordinate nelle matrici e le passiamo da morte a vive
        scacchiera[22][22] = '*';
        scacchiera[22][23] = '*';
        scacchiera[23][22] = '*';
        scacchiera[23][23] = '*';
    break;
    case 4:
        // Nel 4° Caso assegniamo manualmente alla scacchiera le cellule vive
        printf("Quante cellule vive contiene la tua configurazione di partenza? \n");
        scanf("%d", &nv);
        // Il ciclo ogni volta chiede la posizione delle cellule vive assegnate dall'utente
        iv=0;
        for(iv=0;iv<nv;iv++)
        {
        printf("Inserisci le coordinate della %d cellula viva nel formato RIGA,COLONNA Es: 22,25\n",iv+1);
        scanf("%d,%d",&rv,&cv);
        // Dopo aver letto le coordinate le passiamo negli indici di riga e di colonna e assegniamo il valore * di Cellula Viva
        scacchiera[rv][cv] = '*';
        }
    break;
}
// Ottenendo la nostra matrice/scacchiera configurata copiamo tutto il suo contenuto nella matrice/scacchiera temporanea
for (colonna=0; colonna<n; colonna++) {
 for(riga=0; riga<n; riga++) {
scacchiera_temporanea[riga][colonna]=scacchiera[riga][colonna];
                             }
                                      }

colonna = 0;
riga = 0;
i=0;

// L’algoritmo esamina n volte la scacchiera
for (i=1; i<=n; i++) {

// Faccio scorrere tutta la scacchiera
 for(riga=0;riga<n;riga++) {
  for (colonna=0;colonna<n;colonna++) {
/*
    Nella procedura seguente mando in input l'indice di riga e di colonna dell'interazione, la scacchiera, e il numero totale di righe e colonne (n)
    la procedura restituisce in output il contenuto delle caselle che sono intorno alla cellula in esame
*/
   Assegna_valori(n, scacchiera, riga, colonna, &A,&B,&C,&D,&E,&F,&G,&H);

/*
  Dopo aver controllato se la casella che sto esaminando si trova nei bordi e negli ancoli della scacchiera
  Vado a contollare quante cellule vive sono intorno alla cellula che stiamo esaminando con la function conta_vive in check.c
  che restituisce in output appunto il numero delle vive
*/
       lives = conta_vive(A,B,C,D,E,F,G,H);

       // In base al numero di cellule vive contate intorno alla cellula in esame
       // Possiamo quindi modificarne il contenuto

       // Se una cellula ha esattamente tre cellule vicine vive allora la cellula deve essere posta nello stato “viva”
        if(lives == 3) { scacchiera_temporanea[riga][colonna] = '*'; }

      // Se una cellula ha 1,2 o 4 cellule vicine vive allora la cellula permane nello stato in cui si trova
        if(lives == 1 || lives == 2 || lives == 4) { scacchiera_temporanea[riga][colonna] = scacchiera[riga][colonna]; }

      // Se una cellula ha 5 o più cellule vicine vive allora la cellula deve essere posta nello stato “morta”
        if(lives >= 5) { scacchiera_temporanea[riga][colonna] = ' '; }

// La scacchiera deve essere aggiornata solo alla fine di ogni passo

   for(rig=0; rig<n; rig++)     {
    for (col=0; col<n; col++) {
// Ricopio quindi la configurazione ottenuta, all'interno della matrice.
      scacchiera[rig][col]=scacchiera_temporanea[rig][col];
                              }
                                }
        // Riporto il numero di vive a 0, in modo da ricontare il contenuto nel passo successivo
        lives=0;
}
}

/* L’algoritmo visualizza tutto l’array 2D al temine del secondo, terzo,
quarto, sesto, ottavo, decimo, 20-simo, 30-simo e 45-simo passo. */

if(i == 2 || i == 3 || i == 4 || i == 6 || i == 8 || i == 10 || i == 20 || i == 30 || i == 45)
    {
    stampa_matrice(&scacchiera);
        /*
          Alla fine della stampa di ogni matrice "pulisco" (CLEAR) la schermata
          ad eccezione alla stampa dell'ultima elaborazione della scacchiera
          in modo che alla fine del intero processo rimanga una stampa dell'elaborazione ottenuta
        */
    if(i != 45)  {system("cls");};
    }

}
system("pause");

             }


   /*
   Prendendo in input le lettere che hanno come valore le cellule che sono intorno
   alla cellula che stiamo elaborando, riusciamo a contare le cellule vive
   controllando se il loro valore corrisponde a *, il valore che contraddistingue le cellule vive
   */
int conta_vive(char A,char B,char C,char D,char E,char F,char G,char H) {
        int conto_vive = 0;
        if(A == '*') { conto_vive++; }
        if(B == '*') { conto_vive++; }
        if(C == '*') { conto_vive++; }
        if(D == '*') { conto_vive++; }
        if(E == '*') { conto_vive++; }
        if(F == '*') { conto_vive++; }
        if(G == '*') { conto_vive++; }
        if(H == '*') { conto_vive++; }
return conto_vive;
}

// La procedura stampa la matrice con l'utilizzo di due cicli
// Che scorrono la matrice e a ogni iterazione stampano il contenuto di ciscuna casella
void stampa_matrice(char scacchiera[45][45]) {
int r=0,c=0,n=45;
     for(r=0;r<n;r++)      {
      for (c=0;c<n;c++) {

         printf("%c", scacchiera[r][c]);
                      }
        // Alla fine di ogni riga vado a capo
         printf("\n");
                       }

};


void Assegna_valori(int n, char scacchiera[45][45],int riga,int colonna,char *tempA,char *tempB,char *tempC,char *tempD,char *tempE, char *tempF,char *tempG,char *tempH) {
/*
 Alcune cellule prese in esame, possono non avere 8 cellule intorno
 Se ad esempio mi trovo negli spigoli (Esempio [0][0], oppure [44][44]), la cellula ha solo 3 cellule vicine
 Se mi trovo ai bordi, la cellula ha solo 5 cellule vicine
 */
// Controllo quindi se mi trovo negli spigoli
      if(riga == 0) {
        if(colonna == 0) {
         // Le cellule che quindi non esistono le dò come cellule "morte"
         // Non verranno quindi conteggiate da conta_vive();

            *tempA = ' ';
            *tempB = ' ';
            *tempC = ' ';
            *tempD = ' ';
            *tempF = ' ';
         /*
         Le cellule esistenti invece, possono essere sia vive che morte
         Copio quindi i loro valori nelle variabili,
         Posso modificare gli indici e copiare ogni volta il valore perchè
         la loro posizione intorno alla cellula in esame sarà sempre la stessa
         */
        *tempE = scacchiera[riga+1][colonna];
        *tempG = scacchiera[riga][colonna+1];
        *tempH = scacchiera[riga+1][colonna+1];
                      }
        // N-1 perchè l'ultima colonna e l'ultima riga nella scacchiera sarà 44
        // dato che partendo da 0 avremo i nostri 45 elementi
         if(colonna == n-1) {
            *tempA = ' ';
            *tempD = ' ';
            *tempF = ' ';
            *tempG = ' ';
            *tempH = ' ';
           *tempB = scacchiera[riga][colonna-1];
           *tempC = scacchiera[riga+1][colonna-1];
           *tempE = scacchiera[riga+1][colonna];
        }
        }


      if(riga == n-1) {
       if(colonna == n-1) {
            *tempC = ' ';
            *tempE = ' ';
            *tempH = ' ';
            *tempG = ' ';
            *tempF = ' ';
            *tempA = scacchiera[riga-1][colonna-1];
            *tempB = scacchiera[riga][colonna-1];
            *tempD = scacchiera[riga-1][colonna];
     }
        if(colonna == 0) {
            *tempA = ' ';
            *tempB = ' ';
            *tempC = ' ';
            *tempE = ' ';
            *tempH = ' ';

      *tempD = scacchiera[riga-1][colonna];
      *tempF = scacchiera[riga-1][colonna+1];
      *tempG = scacchiera[riga][colonna+1];

                    }
                         }
    // Controllo sui bordi
      else if(riga == 0)
     {
      *tempA = ' ';
      *tempD = ' ';
      *tempF = ' ';
      *tempB = scacchiera[riga][colonna-1];
      *tempC = scacchiera[riga+1][colonna-1];
      *tempE = scacchiera[riga+1][colonna];
      *tempG = scacchiera[riga][colonna+1];
      *tempH = scacchiera[riga+1][colonna+1];
     }
     else if(riga == n-1) {
      *tempC = ' ';
      *tempE = ' ';
      *tempH = ' ';
      *tempA = scacchiera[riga-1][colonna-1];
      *tempB = scacchiera[riga][colonna-1];
      *tempD = scacchiera[riga-1][colonna];
      *tempF = scacchiera[riga-1][colonna+1];
      *tempG = scacchiera[riga][colonna+1];

     }
else {
      // Se non mi trovo sui bordi, posso quindi copiare tutti i valori delle cellule che sono intorno alla cellula in esame
      // Modificando gli indici di riga e di colonna.
      *tempA = scacchiera[riga-1][colonna-1];
      *tempB = scacchiera[riga][colonna-1];
      *tempC = scacchiera[riga+1][colonna-1];
      *tempD = scacchiera[riga-1][colonna];
      *tempE = scacchiera[riga+1][colonna];
      *tempF = scacchiera[riga-1][colonna+1];
      *tempG = scacchiera[riga][colonna+1];
      *tempH = scacchiera[riga+1][colonna+1];
}
}