#include "sudoku.h"

/*
 * Restituisce un numero casuale nell'intervallo [min, max)
 */ 
int randomr(int min, int max){
	int base = rand(); 
	int intervallo = max - min;
	if (RAND_MAX == base)
		return randomr(min, max);
	if (base < RAND_MAX - (RAND_MAX % intervallo))
		return min + base / (RAND_MAX / intervallo);
	else
		return randomr(min, max);
}

/*
 * Restituisce due numeri casuali diversi
 */
int *randomd(){
	int *r = (int *)malloc(2 * sizeof(int));
	do{
		r[0] = randomr(1,9); 
		r[1] = randomr(1,9);
	}while(r[0] == r[1]);
	return r;
}

/*
 * Scambia due variabili.
 * Fallisce se si passa la stessa variabile 2 volte.
 */
void scambia(int* a, int* b){
    *a ^= *b;
    *b ^= *a;
    *a ^= *b;
}

/*
 * Blocca l'esecuzione finchè non viene premuto invio
 */
void pausa(){
	char c;
	do
		getchar();
	while ((c = getchar()) != '\n' && c != EOF);
}

/*
 * Cancella le evidenziature per i valori errati
 */
void cancella_errati(){
	for(int i=0; i<n; i++)
		for(int k=0; k<n; k++)
			if(sudoku[i][k][1] == 2)
				sudoku[i][k][1] = 1;
}

/*
 * Cancella la tabella del sudoku
 */
void vuota(){
	for(int i=0; i<n; i++)
		for(int k=0; k<n; k++){
			sudoku[i][k][0] = 0;
			sudoku[i][k][1] = 1;
		}
}

/*
 * Inizializza la tabella del sudoku
 * generando uno schema
 */
void inizializza(int spazi){
	int base[n][n] = {\
		{6,9,7,1,4,3,8,2,5},\
		{4,1,8,9,2,5,6,3,7},\
		{2,5,3,8,7,6,4,9,1},\
		{7,3,2,4,6,8,5,1,9},\
		{8,4,9,3,5,1,7,6,2},\
		{5,6,1,2,9,7,3,8,4},\
		{3,8,4,7,1,9,2,5,6},\
		{1,2,6,5,3,4,9,7,8},\
		{9,7,5,6,8,2,1,4,3}\
	};
	int sostituzioni[9];

	/* genera uno schema
	 * facendo delle sostituzione 
	 * in uno di partenza.
	 */

	for(int l=0; l<25; l++){
		int *r; 

		//scambia riga
		r = randomd();
		for(int i=0; i<n; i++){
			for(int k=0; k<n; k++)
				sostituzioni[k] = base[i][k];
			for(int s=0; s<9; s++)
				if (sostituzioni[s] == r[0])
					sostituzioni[s] = r[1];
				else if (sostituzioni[s] == r[1])
					sostituzioni[s] = r[0];
			for(int p=0; p<9; p++)
        		for(int q=0; q<9; q++)
                	base[i][q] = sostituzioni[q];
		}

		//scambia colonna
		r = randomd();
		for(int i=0; i<n; i++){
			for(int k=0; k<n; k++)
				sostituzioni[k] = base[i][k];
			for(int s=0; s<9; s++)
				if (sostituzioni[s] == r[0])
					sostituzioni[s] = r[1];
				else if (sostituzioni[s] == r[1])
					sostituzioni[s] = r[0];
			for(int p=0; p<9; p++)
				for(int q=0; q<9; q++)
					base[q][i] = sostituzioni[q];
		}

	}

	for(int l=0; l<25; l++){
		int r = randomr(0,3);
		switch(r){
			
			//colonna centrale fissa
			case 0:{
				for(int i=0; i<9; i++){
					for(int k=0; k<9; k++)
                    	sostituzioni[k] = base[i][k];
					for(int j=0; j<9; j++)
						if(j != 4)
                        	base[i][j] = sostituzioni[8-j] ;
				}
				break;
			}

			//riga centrale fissa
			case 1:{
				for(int k=0; k<9; k++){
					for(int i=0; i<9; i++)
        	            sostituzioni[i] = base[i][k];
					for(int j=0; j<9; j++)
						if(j!=4)
							base[j][k] = sostituzioni[8-j];
				}
				break;
			}
			
			//inversione riga 3-5
			case 2:{
				for(int i=0; i<9; i++)
					scambia(&base[3][i], &base[5][i]);
				break;
			}
		}
	}
	
	//inserisci gli spazi
	for(int i=0; i<spazi; i++){
        int unico = 0; //la casella è valida
		do{
			int x = randomr(0,9);
			int y = randomr(0,9);			
			if(!base[x][x])
				unico = 1;			
			else {
				base[x][y] = 0;
				unico = 0;
			}
		}while(unico == 1);
    }

	//copia lo schema generato nella matrice
	for(int i=0; i<n; i++)
		for(int k=0; k<n; k++){
			sudoku[i][k][0] = base[i][k];
			if(!base[i][k])
				sudoku[i][k][1] = 1;
		}
}

/*
 * Restituisce 0 se nella riga non sono presenti duplicati
 * altrimenti restituisce 1.
 */
int controlla_riga(int m){
	float media = 0;
	for(int i=0; i<n; i++)
		media += sudoku[m][i][0];
	if(media/9 != 5)
		return 1;
	return 0;
}

/*
 * Restituisce 0 se nella colonna non sono presenti duplicati
 * altrimenti restituisce 1.
 */
int controlla_colonna(int m){
	float media = 0;
	for(int i=0; i<n; i++)
		media += sudoku[i][m][0];
	if(media/9 != 5)
		return 1;
	return 0;
}

/*
 * Restituisce 0 se nel quadrante non sono presenti duplicati
 * altrimenti restituisce 1.
 */
int controlla_quadrante(int m){
	float media = 0;
	int **quadrante = ottieni_quadrante(m);
	for(int i=0; i<n; i++)
		media += quadrante[i][0];
	if(media/9 != 5)
		return 1;
	return 0;
}

/*
 * Restituisce un array di puntatori a intero del quadrante m.
 */
int **ottieni_quadrante(int m){
	int **quadrante = (int **)malloc(sizeof(int *) * n);
	int quadranti[][2] = {{0,0}, {0,3}, {0,6}, {3,0}, {3,3}, {3,6},{6,0}, {6,3}, {6,6}};
	int t = quadranti[m][0], s = quadranti[m][1], j = 0;
	for(int i=t; i<(t+3); i++)
		for(int k=s; k<(s+3); k++){
			quadrante[j] = sudoku[i][k];
			j++;
		}
	return quadrante;
}

/*
 * Evidenzia le casella errate.
 * m: numero della riga/colonna/quadrante.
 * tipo: 0 - riga, 
 *     1 - colonna, 
 *     2 - quadrante,
 */
void evidenzia(int m, int tipo){
	switch(tipo){
		//riga
		case 0:{
			for(int i=0; i<n; i++)
				if(sudoku[m][i][1])
					sudoku[m][i][1] = 2;
			break;
		}
		//colonna
		case 1:{
			for(int i=0; i<n; i++)
				if(sudoku[i][m][1])
					sudoku[i][m][1] = 2;
			break;
		}
		//quadrante
		case 2:{
			int **quadrante = ottieni_quadrante(m);
			for(int i=0; i<n; i++)
				if(quadrante[i][1])
					quadrante[i][1] = 2;
			break;
		}
	}
}

/*
 * Controlla la presenza di errori e li evidenzia.
 * Restituisce 0 se il sudoku non è corretto altrimenti 1.
 */
int corretto(){
	int errori = 0;
	for(int i=0; i<n; i++)
		if(controlla_riga(i)){
			evidenzia(i, 0);
			errori = 1;
		}
	for(int i=0; i<n; i++)
		if(controlla_colonna(i)){
			evidenzia(i, 1);
			errori = 1;
		}
	for(int i=0; i<n; i++)
		if(controlla_riga(i)){
			evidenzia(i, 2);
			errori = 1;
		}
	return !errori;
}

/*
 * Stampa la tabella del sudoku
 */
void stampa(){
	printf("\n\n\n");
	for(int i=0; i<n; i++){
		printf("%-25s", RESET);
		for(int k=0; k<n; k++){
			if(!sudoku[i][k][0])
				printf("%-12s ", RESET);
			else {
				switch(sudoku[i][k][1]){
					//Schema non modificabile
					case 0:{
						printf("%-12s%d ", BIANCO, sudoku[i][k][0]);
						break;
					}
					//Inseriti dal giocatore
					case 1:{
						printf("%-12s%d ", VERDE, sudoku[i][k][0]);
						break;
					}
					//Errati
					case 2:{
						printf("%-12s%d ", ROSSO, sudoku[i][k][0]);
						break;
					}
				}
			}		
		}
		printf("\n\n\n");
	}
	printf("\n");
}

/*
 * Legge la mossa del giocatore
 */
void leggi_mossa(){
	int x, y, m;
	printf("%s%s%s", VERDE, "(x,y,m): ", BIANCO);
	scanf("%d,%d,%d", &x, &y, &m);
	if(!sudoku[x][y][1])
		printf("%-50sNon puoi cambiare il numero in (%d,%d)",ROSSO, x, y);
	else if(!(0 < m < 10))
		printf("%-45sSolo numeri tra 1 e 9 estremi inclusi.", ROSSO);
	else if(!(0 < x < 10) || !(0 < y < 10))
		printf("%.45sLe cordinate sono tra 1 e 9 estremi inclusi.", ROSSO);
	else{
		sudoku[x][y][0] = m;
		return;
	}
	pausa();
}