// esame 03/09/2019
// file2.txt

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

struct dati{
	int Ora;
	int Min;
	int Dip;
	int Porta;

};
struct dipendente{
	int codiceDip;
	int numIngresso;
	int numUscita;
};

struct dati *letturaFile(FILE *f,int *n);
void stampaStructDati(struct dati *d,int n);
struct dipendente *creazioneVetDip(struct dati *d,int nDati,int *n);
void stampaVetDipendente( struct dipendente *d, int n );
void riempiVetDipendente(struct dipendente *dip,struct dati *dati,int nDip,int nDati);
int calcolaIngressi(struct dipendente *d,int n);
int attivitaDipendente(struct dipendente *d,int n,int ID);

int main(int argc, char *argv[]){
	int nDip;
	int nDati;
	int numeroIngressi;
	int idDip;
	int ingressiDip;
	char s[5];
	struct dati *dati;
	struct dipendente *vetDipendente;
	FILE *f;

	if(argc!=3){
		return 1;
	}

	f=fopen(argv[1],"r");

	if(f==NULL){
		printf("file non trovato\n");
		return 1;
	}

	// funzioni per la lettura dei file
	dati=letturaFile(f,&nDati);
	stampaStructDati(dati,nDati);
	 // funzione creazioneVetDip riempi vetDip
	vetDipendente=creazioneVetDip(dati,nDati,&nDip);
	stampaVetDipendente(vetDipendente, nDip);
	riempiVetDipendente(vetDipendente,dati,nDip,nDati);
	stampaVetDipendente(vetDipendente, nDip);
	// richiesta 1
	numeroIngressi=calcolaIngressi(vetDipendente,nDip);
	printf("[INGRESSI]\n%d\n",numeroIngressi);
	// richiesta 3
	printf("[DIPEDENTI\n%d\n]",nDip);
	// richiesta 5

	strcpy(s,argv[2]+3);
		printf("argv[2] %s s: %s\n", argv[2], s);
	idDip=atoi(s);
	printf("ID %d\n", idDip);
	ingressiDip=attivitaDipendente(vetDipendente,nDip,idDip);
	printf("[ATTIVITA']\n%d\n",ingressiDip);

return 0;
}


struct dati *letturaFile(FILE *f,int *n){

	int nConv; // nCOnv= numero conversioni
	int size=10;
	char buffer [100];
	char s1[8]; // codice dipendente completo dipxxxx
	char s2[5]; //solo parte numerica del codice xxxx
	struct dati *d1,*d2;

	*n=0;

	d2=malloc(size *sizeof(struct dati));

	while(fgets(buffer,sizeof(buffer),f)){
		d1=d2 + *n;
		nConv=sscanf(buffer,"%d %d %s %d",&d1->Ora,&d1->Min,s1,&d1->Porta); // il codice dipendente lo salvo
						//in s perchè conto solo le ultime 4 cifre numriche
						// che inserisco all'interno della variabile dip della struct

		strcpy(s2,s1+3);// 3 s2 stringa in cui copio e s1+3 è la posizione da cui inizio a copiare
		d1->Dip=atoi(s2); // inserisco il contenuto della stringa s2 all'interno della struct nel int Dip
		(*n)++;

		if(*n>=size){
		size=2*size;
		d2=realloc(d2,size*sizeof(struct dati));
		}
	}
	d2=realloc(d2,*n*sizeof(struct dati));

	return d2;
}

void stampaStructDati(struct dati *d,int n){

	int i;

	for(i=0;i<n;i++){
		printf("%d %d %d %d\n",d[i].Ora,d[i].Min,d[i].Dip,d[i].Porta);
	}
}

struct dipendente *creazioneVetDip(struct dati *d,int nDati,int *n){
	int i,j,k;
	k = 0;
	int flag;
	int v[nDati];
	int size = nDati/2;
	// il vettore è inizializzato a zero attraverso il ciclo
	for(i = 0;i < nDati; i++){
		v[i] = 0;
	}

	struct dipendente *dip,*vetDip;

	vetDip=malloc(size*sizeof(struct dipendente));

	for(i=0;i<nDati;i++){
		flag=0;
		for(j=0;j<nDati;j++){
			if(v[j]==d[i].Dip){
			flag=1;
			}
		}
		v[i]=d[i].Dip;
		if(flag==0){
			dip=vetDip +k;
			dip->codiceDip=d[i].Dip;
			dip->numIngresso = 0;
			dip->numUscita = 0;

			k++;
		}
	}

	vetDip=realloc(vetDip, k*sizeof(struct dipendente));
	*n = k; //assegno al valore puntato da n la dimensione del vettore vetDip
	return vetDip;


}

void stampaVetDipendente( struct dipendente *d, int n ){
	int i;

	for(i=0;i<n;i++){
		printf("%d %d %d\n",d[i].codiceDip,d[i].numIngresso,d[i].numUscita);
	}
}
void riempiVetDipendente(struct dipendente *dip,struct dati *dati,int nDip,int nDati){

 	int i,j;
 	for(i=0;i<nDip;i++){
 		for(j=0;j<nDati;j++){
 			if(dip[i].codiceDip==dati[j].Dip){

 				if(dip[i].numIngresso==dip[i].numUscita){
 					dip[i].numIngresso++;
 				}else {
 					dip[i].numUscita++;
 				}
 			}
 		}
 	}
 }
 int calcolaIngressi(struct dipendente *d,int n){
	int i;
	int count=0; // la variabile che conta gli ingressi ed inizialmente vale 0
	for(i=0;i<n;i++){
		count=count+ d[i].numIngresso;
	}
	return count;
}

int attivitaDipendente(struct dipendente *d,int n,int ID){

	int i;
	int ingressi = 0;
	for(i=0;i<n;i++){
		if(ID==d[i].codiceDip){
		//printf("funziona\n");
		ingressi=d[i].numIngresso;
		}
	}
	return ingressi;
}