#include <stdio.h>
#include <stdlib.h> // per convertire da ascii a floating point
#include <malloc.h> // 
#include <math.h>
#include <time.h>

//variabili e funzioni globali
void leggiMatrici(char *,char *);
int searchSeq(short int *);
int generaSporco(void);
short int calcolaNuovoStato(int);
void creaRipartizione(void);
void normalizza(void);
float **matrice,**ripartizione;			//puntatore a puntatori (un vettore di puntatori)
short int **sequenze;		//puntatore a puntatori (un vettore di puntatori)
int righe, colonne, livello;      //
char *note[]={"DO","DO#","RE","RE#","MI","FA","FA#","SOL","SOL#","LA","LA#","SI"};

void main()
{
	//**dichiarazione variabili
	char filename[80]="greg.txt",filehdr[80]="greg.hdr",fileout[80]; //puntatore di gets e 
	short int startSeq[] = {7,5,9},seq[100]; //inizializzazione del vettore dimensionato a 3 elementi
	int stato,seqlen=100,startPoint,i;

		srand((unsigned int)time(NULL)); //inizializzazione seme gen. casuale (nel main per non cambiare ogni volta seme, come succederebbe nel sottoprogramma)

	//**************
	//**APERTURA del file Probabilità e del file Header (righe, colonne e sequenze)
	//**************
	printf ("nome file occorrenze: ");		//per inserire il nome da tastiera
	gets (filename);			//per leggere il nome del file contenuto nell'array filename
	printf ("nome file header: ");		//per inserire il nome da tastiera
	gets (filehdr);			//per leggere il nome del file contenuto nell'array filename
	printf ("nome file di uscita: ");		//per inserire il nome da tastiera
	gets (fileout);			//per leggere il nome del file contenuto nell'array filename
	//apertura file
	leggiMatrici(filename,filehdr);
	normalizza();
	creaRipartizione();
	
	//GENERAZIONE DELLE SEQUENZE
	for(i=0;i<livello;i++) seq[i] = startSeq[i];//caricamento della sequenza di partenza

	startPoint = 0; //offset 
	for(i=livello;i<seqlen;i++)//caricamento delle nuove sequenze (livello = numero di stati nella sequenza)
	{
		if((stato = searchSeq(seq + startPoint))<0) stato = generaSporco();
		seq[i] = calcolaNuovoStato(stato);//caricamento del nuovo stato
		startPoint++; //in modo che parta dalla sequenza successiva
	}
	FILE *fp;			//puntatori alla struttura FILE definita in stdio.h
	fp = fopen(fileout,"wb");
	for(i=0;i<seqlen;i++)
	{
		printf("%s,",note[seq[i]]);//
		fprintf(fp,"%d ",seq[i]);
	}
	fclose(fp);
	printf("\n\n");
//		for(i=0;i<seqlen;i++) printf("%c",seq[i]+97); //conversione in lettere per gioco

}

	
void leggiMatrici(char *filename, char *filehdr) //gli passiamo come argomenti i nomi dei files
{
	FILE *fp,*fph;			//puntatori alla struttura FILE definita in stdio.h
	int r, c;      //

	fp = fopen (filename, "rb"); //per aprire il file e riversare le informazioni in fp (puntatore alla strutt. FILE)
	if (fp == NULL) 
	{
		printf("Errore!\n");
		exit (0);	//se non riesce ad aprire il file esce
	}
	fph = fopen (filehdr, "rb"); //per aprire il file e riversare le informazioni in fph (puntatore alla strutt. FILE)
	if (fph == NULL) 
	{
		printf("Errore!\n");
		exit (0);	//se non riesce ad aprire il file esce
	}
	//

	
	//**LETTURA dei primi tre valori dell'header (righe, colonne, livello) 
	fscanf(fph,"%d",&righe); //legge il primo valore indicato nel file (numero delle righe)
	fscanf(fph,"%d",&colonne); //legge il secondo valore indicato nel file (numero delle colonne)
	fscanf(fph,"%d",&livello);//legge il terzo valore indicato nel file (numero degli stati in una sequenza)
	printf("righe=%d, colonne=%d, livello=%d\n",righe,colonne,livello);
	
	//**ALLOCAZIONE DINAMICA dello spazio per le due matrici
	matrice = (float **) calloc(righe,sizeof(float *)); //alloca spazio per il vettore di puntatori
	ripartizione = (float **) calloc(righe,sizeof(float *)); //alloca spazio per il vettore di puntatori
	for (r=0; r<righe; r++)
	{
		matrice[r] = (float *) calloc(colonne,sizeof(float)); // alloca spazio per ciascun singolo puntatore-vettore
		ripartizione[r] = (float *) calloc(colonne,sizeof(float));
	}

	sequenze = (short int **) calloc(righe,sizeof(short int *)); //alloca spazio per il vettore di puntatori
	for (r=0; r<righe; r++)
		sequenze[r] = (short int *) calloc(livello,sizeof(short int)); // alloca spazio per ciascun singolo puntatore-vettore
	
	//**************
	//**CARICAMENTO DELLE MATRICI
	//**************
	//ciclo di caricamento della matrice delle probabilità
	for (r=0; r<righe; r++)
	{
		for (c=0; c<colonne; c++)
		{
			fscanf(fp, "%f", &matrice[r][c]); //
		}
	} 

	//ciclo di caricamento della matrice delle sequenze
	for (r=0; r<righe; r++)
	{
		for (c=0; c<livello; c++)
		{
			fscanf(fph, "%d", &sequenze[r][c]); //
		}
	} 

	printf("Probabilita\'\n");

	//ciclo di stampa probabilità
	for (r=0; r<righe; r++)
	{
		printf("%d: ",r);
		for (c=0; c<colonne; c++)
		{
			printf("%.3f,", matrice[r][c]);
		}
		printf("\n");
	} 

	//ciclo di stampa header
	printf("\nHeader\n");
	for (r=0; r<righe; r++)
	{
		printf("%d: ",r);
		for (c=0; c<livello; c++)
		{
			printf("%d,", sequenze[r][c]);
		}
		printf("\n");
	} 

	fclose (fp);					//chiude il file
	fclose (fph);					//chiude il file
}


int searchSeq(short int *seq) //cerca la sequenza nella matrice delle sequenze
{
	int i,j;
	for(i=0;i<righe;i++)//scorre l'indice delle sequenze
	{
		for(j=0;j<livello;j++)// scorre i valori della singola sequenza 
		{
			if(seq[j] != sequenze[i][j]) break; //confronto con i valori della sequenza di partenza, esce se ne trova uno diverso (!=)
		}
		if(j<livello) continue;//se non arriva alla fine continua
		else break; //interrompi se j è uguale a livello e quindi la sequenza è quella giusta
	}
	if(i<righe) return(i); //restituisce la riga (stato equivalente)
	else return(-1); //se non trova la seq. restituisce -1
}


int generaSporco()
{
	short int indice;

	indice = rand()%26;

	return(indice);
}


short int calcolaNuovoStato(int stato)
{
	int i;
	float numero;
	numero = (float)rand()/(float)RAND_MAX;//numero casuale da superare nel confronto
	for(i=0;i<colonne;i++)
	{
		if(ripartizione[stato][i]>= numero) 
		{
			stato = i;
			break;// se lo trova non va avanti
		}
	}
	return(i);
}


void creaRipartizione()
{
	int i,j;
	float accu;
	for(i=0;i<righe;i++)
	{
		accu = 0;
		for(j=0;j<colonne;j++)
		{
			accu += matrice[i][j];
			ripartizione[i][j] = accu;
		}
	}
}


void normalizza()
{
	int i,j;
	float accu,fattore;
	for(i=0;i<righe;i++)
	{
		accu = 0;
		for(j=0;j<colonne;j++) accu += matrice[i][j]; //accu è la somma di tutti i valori della riga
		if(accu != 0) //se la riga è diversa da 0 facciamo l'operazione
		{
			fattore = /*1.0/ */accu;//accu diventa il fattore di proporzionalità
			for(j=0;j<colonne;j++) matrice[i][j] = matrice[i][j] / fattore;//la riga viene riscandita e ogni valore diviso per il fattore di proporzionalità
		}
		else matrice[i][0] = 1.0; //se è uguale a zero diamo al primo indirizzo probabilità totale.... data la dubbia provenienza della matrice di esempio è necessario fare ciò
	}
}