// esame 28/02/2018
//file280218.txt

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

struct giocata{
    int x;//numero di x
    int o;//numero di o
    char g[11];//mi salvo la riga solo quando e' corretta
    int valoriSbagliati; // valori sbagliati ed in eccesso
    int finePartita; //se e' 1 significa che è la riga di fine partita
    int giocataErrata; //se è 1 significa che la giocata non è valida
};
struct partita{
    struct giocata v[9];
    int nGiocata;//numero di giocate che ho
    int partitaErrata; //se è 1 significa che c'è almeno una giocata errata
};

struct giocata *letturaFile(FILE *f,int *n);
void funzioneRiempiGiocata(struct giocata *g,int n);
int funzioneCalcoloNumeroPartite(struct giocata *g,int n);
void funzioneRiempiPartita(struct partita *p,struct giocata *g,int np,int n);
void stampaStructGiocata(struct giocata *g,int n);
void stampaStructPartita(struct partita *p, int n);
int funzioneCaratteriSbagliati(struct giocata *g,int n);
int funzioneMediaX(struct giocata *g,int n,int np);
int funzioneMediaO(struct giocata *g,int n,int np);
int funzionePartiteCorrette(struct partita *p,int n);


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

    int n,nP,valoriErrati,x,o,partiteCorrette;
    FILE *f;
    struct giocata *giocata;
    //struct partita *partita;

    if(argc!=2){
        return 1;
    }
    f=fopen(argv[1],"r");
    if(f==NULL){
        printf("file non trovato\n");
        return 1;
    }

    // funzione lettura e stampa e rimpeimento vari vet
    giocata=letturaFile(f,&n);
    fclose(f);
    funzioneRiempiGiocata(giocata,n);
    stampaStructGiocata(giocata,n);
    nP=funzioneCalcoloNumeroPartite(giocata,n);
    struct partita v[nP];
    funzioneRiempiPartita(v,giocata,nP,n);
    stampaStructPartita(v,nP);
    // richiesta 1
    printf("[PARTITE]\n%d\n",nP);
    //richiesta 2
    valoriErrati=funzioneCaratteriSbagliati(giocata,n);
    printf("[NON-VALIDI]\n%d\n",valoriErrati);
    //richiesta 3
    x=funzioneMediaX(giocata,n,nP);
    o=funzioneMediaO(giocata,n,nP);
    printf("[XEO]\n%d\n%d\n",x,o);
    //richiesta 4
    partiteCorrette=funzionePartiteCorrette(v,nP);
    printf("[CORRETTE]\n%d\n",partiteCorrette);
    //richiesta 5




    return 0;



}

struct giocata *letturaFile(FILE *f,int *n){
     struct giocata *p1,*p2;
     char buffer[100];
     int nConv;
     int size=10;
     *n=0;


    p2=malloc(size*sizeof(struct partita));
    while(fgets(buffer,size*sizeof(buffer),f)){

        p1=p2 + *n;
        nConv = sscanf(buffer, "%s", p1->g);

        (*n)++;
            //facciamo la realloc
        if(*n>size){
            size = size*2;
            p2 = realloc(p2, size*sizeof(struct partita));
        }
    }
    p2 = realloc(p2, *n*sizeof(struct giocata));

    return p2;
}
void funzioneRiempiGiocata(struct giocata *g,int n){

    int i,j;
    char finePartita[]="---";
    struct giocata giocata;
    int lungh;
    char s[11];

    for(i=0;i<n;i++){
        giocata = g[i];
        if(strcmp(giocata.g,finePartita)==0){
            giocata.finePartita=1;
        }else{
            giocata.finePartita=0;
            giocata.x=0;
            giocata.o=0;
            giocata.valoriSbagliati=0;
            lungh = strlen(giocata.g);

            strcpy(s, giocata.g);
            for(j=0;j<lungh;j++){

                if(s[j]=='x'){
                    giocata.x++;


                }else if(s[j] == 'o'){
                    giocata.o++;

                }
                else{

                    if(s[j]!= '.'){
                        giocata.valoriSbagliati++;
                    }
                }

            }
            if(lungh!=3){
                giocata.giocataErrata=1;
            }else{
                if(giocata.valoriSbagliati==0 && giocata.x==1 && giocata.o==1){
                    giocata.giocataErrata=0;
                }else{
                    giocata.giocataErrata=1;
                }

            }
        }
        g[i].x = giocata.x;
        g[i].o = giocata.o;
        g[i].giocataErrata = giocata.giocataErrata;
        g[i].valoriSbagliati = giocata.valoriSbagliati;
        g[i].finePartita = giocata.finePartita;

    }


}
int funzioneCalcoloNumeroPartite(struct giocata *g,int n){
    int count=0;
    int i;
    for(i=0;i<n;i++){
        if(g[i].finePartita==1){
            count++;
        }
    }
    return count;
}
void funzioneRiempiPartita(struct partita *p,struct giocata *g,int np,int n){

    int i,j,k;
    j = 0;
    k=0;
    struct giocata *vettGiocata;
    for(i=0;i<np;i++){
        p[i].nGiocata=0;
        p[i].partitaErrata=0;
    }
    for(i=0;i<n;i++){

        if(g[i].finePartita==1){
            j++;
            k=0;
        }else{
            printf("%d %d %d\n", j, k, p[j].nGiocata);
            vettGiocata=p[j].v;
            vettGiocata[k]=g[i];
            k++;
            p[j].nGiocata++;
            if(g[i].giocataErrata==1){
                p[j].partitaErrata=1;
            }
        }
    }
}
void stampaStructGiocata(struct giocata *g,int n){
    int i;
    for(i=0;i<n;i++){
        printf("%d %d %s %d %d %d\n",g[i].x,g[i].o,g[i].g,g[i].valoriSbagliati,g[i].finePartita,g[i].giocataErrata);
    }
}

void stampaStructPartita(struct partita *p, int n){
    int i;
    for(i=0;i<n; i++){
        printf("PARTITA: errata %d nGiocata %d\n", p[i].partitaErrata, p[i].nGiocata);
        printf("VETTORE GIOCATA:\n");
        stampaStructGiocata(p[i].v, p[i].nGiocata);
    }
}
int funzioneCaratteriSbagliati(struct giocata *g,int n){
    int i;
    int sbagliati=0;
    for(i=0;i<n;i++){
        sbagliati+=g[i].valoriSbagliati;
        }
    return sbagliati;
}
int funzioneMediaX(struct giocata *g,int n,int np){
    int i;
    int media=0;
    for(i=0;i<n;i++){
        media+=g[i].x;
    }
    return media/np;
}
int funzioneMediaO(struct giocata *g,int n,int np){
    int i;
    int media=0;
    for(i=0;i<n;i++){
        media+=g[i].o;
    }
    return media/np;
}

int funzionePartiteCorrette(struct partita *p,int n){
    int i;
    int count=0;
    for(i=0;i<n;i++){
        if(p[i].partitaErrata==0){
            count++;
        }
    }
    return count;
}
int funzioneVettore X(struct partita *p,int n,int np){
 	int i;
	int media;
    for(i=0;i<n;i++){
        if(p[i].partitaErrata==0){
           	 media+=
        }

        }