#include<iostream>
#include<cstdlib>
#include<iomanip>
#include"schema15.hpp"
using namespace std;

// costruttore di default. Inizializza il gioco con la configurazione finale
// 1 2 3 4 5 6 ... 13 14 15
//
schema15::schema15()
{
	inizializza();
}

// secondo costruttore: Inizializza il gioco con una configurazione casuale.
// nel caso (estremamente raro) che il metodo genera() non riesca a estrarre
// una configurazione risolvibile, riparte dalla configurazione iniziale.
//
schema15::schema15(int seed)
{
	if(!genera(seed))
		inizializza();
}

// crea la configurazione inziale
//
bool schema15::inizializza()
{
	for (int i=1;i<=16;i++)
		pad[i-1]=i;
	num_mosse=0;
	vX=vY=4;
	return true;
}

// inizializza lo schema di gioco utilizzando i valori forniti con l'array conf[].
// Verifica se la sequenza è lecita (contiene tutti i numeri da 1 a 16) e se la
// configurazione risulta valida. Restituisce true se tutto va bene.
//
bool schema15::inizializza(int *conf) {
	bool check[16]={false};
	int vpos,numcount=0;
	num_mosse=0;

	for(int i=0;i<16;i++) {
		pad[i]=conf[i];
		if(!check[i]) {
			check[i]=true;
			numcount++;
		}
		if(pad[i]==16)
			vpos=i;
	}
	if (numcount!=16)
		return false;
	
	vX=vpos/4;
	vY=vpos%4;

	return valido();
}
bool schema15::inizializza(int *conf,int m) {
	bool v;
	v=inizializza(conf);
	num_mosse=m;
	return v;
}

// genera una permutazione della configurazione iniziale e verifica che sia
// risolvibile e restituisce true. In caso di esito negativo, ripete il tentativo 
// per al piu' maxiter tentativi (evento piuttosto raro). Se tutto va male, 
// restituisce false. Il programma gestisce.
//
bool schema15::genera(int seed)
{
	bool v=false;
	int tentativi=0;
	inizializza();

	do {
		mischia(seed);
		v=valido();
		tentativi++;
	} while (!v&&tentativi<maxiter);
	return v;
}


void schema15::mischia(int seed)
{
	int i,j,vpos=0;;

	srand(seed);
	for(i=0;i<16;i++) {
		j=rand()%16;
		if(pad[i]==16)
			vpos=j;
		if(pad[j]==16)
			vpos=i;
		swap(pad[i],pad[j]);
	}
	vX=vpos/4;
	vY=vpos%4;
}

// verifica che lo schema abbia "somma del 15" pari e, nel caso, restituisce true.. 
// In caso contrario restituisce false.
//
bool schema15::valido() 
{
	int somma15[16]={0};
	int i,j,s=0;

	for(i=0;i<15;i++){
		for(j=i+1;j<16;j++)
			if(pad[j]<pad[i])
			       somma15[i]++;	
		s+=somma15[i];
	}
	return !(s%2);
}

// Mosse: sposta in alto la cella che si trova sotto lo spazio vuoto (se presente)
// agiorna la posizione della cella vuota, incrementa il numero di messe e restituisce true.
// In caso contrario (mossa illegittima) restituisce false.
//
// I metodi basso(), destra() e sinistra(), funzionano in maniera del tutto analoga.
//
bool schema15::alto()
{
	int i,j;
	if(vX==3)
		return false;
	i=vX+1;
	j=vY;
	swap(pad[i*4+j],pad[vX*4+vY]);
	vX++;
	num_mosse++;
	return true;
}

bool schema15::basso()
{
	int i,j;
	if(vX==0)
		return false;
	i=vX-1;
	j=vY;
	swap(pad[i*4+j],pad[vX*4+vY]);
	vX--;
	num_mosse++;
	return true;
}

bool schema15::destra()
{
	int i,j;
	if(vY==0)
		return false;
	i=vX;
	j=vY-1;
	swap(pad[i*4+j],pad[vX*4+vY]);
	vY--;
	num_mosse++;
	return true;
}

bool schema15::sinistra()
{
	int i,j;
	if(vY==3)
		return false;
	i=vX;
	j=vY+1;
	swap(pad[i*4+j],pad[vX*4+vY]);
	vY++;
	num_mosse++;
	return true;
}

// restituisce true se il gioco ha raggiunto la configurazione vincente 
// 1 2 3 4 5 6 ... 15 [ ](spazio vuoto in coda)
//
bool schema15::vinto()
{
	for(int i=1;i<=16;i++) 
		if(pad[i-1]!=i)
			return false;
	return true;
}

// restituisce il numero di mosse giocate fino al momento in cui e' invocato.
//
int schema15::mosse() 
{
	return num_mosse;
}

// restituisce una copia dell'array pad
// il parametro punta a un array già allocato
//

void schema15::conf(int *c)
{
	for(int i=0; i<16;i++)
		c[i]=pad[i];
}

// visualizza lo schema di gioco su console
//
void schema15::mostra()
{
	int i,j,c;
	cout<<endl;
	cout<< "Mosse: "<< num_mosse<<endl;
	cout<<"+--+--+--+--+"<<endl;
	for(i=0;i<4;i++){
		for(j=0;j<4;j++){
			c=pad[i*4+j];
			cout <<"|"<<setw(2)<<right;
		        if (c!=16)
				cout<<c;
			else 
				cout<< "  ";	
		}
		cout<<"|"<<endl;
	cout<<"+--+--+--+--+"<<endl;
	}
//	cout <<"vX="<<vX<<", vY="<<vY<<endl;
}