/***************************************************************************
 *   Copyright (C) 2008 by Douglas Castro,,,   *
 *   douglas@douglas-laptop   *
 *                                                                         *
 ***************************************************************************/

#include "imprime.h"
#include "affirm.h"
#include <assert.h>

void mostra(FILE *arq, Reg *r,int ind)
{ 
	if (r == NULL) { return; }
	int qx=0, qy=0, p=0;
	// calculo da profundidade
//	p = log2(r->ind);
	p = log(ind)/log(2);
	// calculo da qtdade de bits coords x e y
	qx = p/2;
	qy = p/2;
	
	if(p%2==1)
	{
		qx += 1;
		qy += 0;
	}
	// qtdade de celulas na prof p nas direcoes x e y
	qx = pow(2,qx);
	qy = pow(2,qy);
	// calculo das posicoes x e y
	int d0, d1;
	encontra_posicao(ind, &d0, &d1);
	// calculo das coordenadas (reais) do canto inf esq de uma cel em [0,1]x[0,1]
	double coordX = d0*(1./(double) qx);
	double coordY = d1*(1./(double) qy);

	fprintf(arq, "%10.6f %10.6f %10.6f\n", coordX, coordY, 0.0);
	
	mostra(arq, r->esq,2*ind);
	mostra(arq, r->dir,2*ind+1);
}

/**
 * Escreve num arquivo as coordenadas x e y do vertice inferior esquerdo de todas celulas 
 * com suas respectivas medias celulares
 * @param arq [out] arquivo onde os dados serao escritos
 * @param r [in] arvore 
 * @param ind [in] indicce da celula
 * @param prof [in] profundodade na arvore
 * @param xmin [in] abscissa inferior da celula
 * @param xmax [in] abscissa superior da celula
 * @param ymin [in] ordenada inferior da celula
 * @param ymax [in] ordenada superior da celula
 */
void mostra_aux(FILE *arq, Reg *r,int ind, int prof, double xmin, double xmax, double ymin, double ymax)
{
	if (r == NULL ) { return; }
	
	fprintf(arq, "%d %10.6f %10.6f %10.6f\n", ind, xmin, ymin, r->fval);
	
	if(prof%2==0)
	{
// 		printf("par\n");
		mostra_aux(arq, r->esq,2*ind,prof + 1, xmin, (xmax+xmin)/2.0, ymin, ymax);
		mostra_aux(arq, r->dir,2*ind+1,prof + 1, (xmax+xmin)/2.0, xmax, ymin, ymax);
	}
	else
	{
// 		printf("impar\n");
		mostra_aux(arq, r->esq,2*ind,prof + 1, xmin, xmax, ymin, (ymax+ymin)/2.0);
		mostra_aux(arq, r->dir,2*ind+1,prof + 1, xmin, xmax, (ymin+ymax)/2.0, ymax);
	}
}

void mostra_folhas(FILE *arq, Reg *r, int ind, int prof, double xmin, double xmax, double ymin, double ymax)
{
  /* Exigencia da fun��o: */
  demand(r != NULL, "a arvore n�o pode ser nula!");

  /* Paranoia: */
  assert((r->esq == NULL) == (r->dir == NULL));

        if(r->esq==NULL)
	{
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", ind, xmin, ymin, r->fval);
		return;
	}
	if(prof%2==0)
	{
		mostra_folhas(arq, r->esq, 2*ind + 0, prof + 1, xmin, (xmax+xmin)/2.0, ymin, ymax);
		mostra_folhas(arq, r->dir, 2*ind + 1, prof + 1, (xmax+xmin)/2.0, xmax, ymin, ymax);
	}
	else
	{
		mostra_folhas(arq, r->esq, 2*ind + 0, prof + 1, xmin, xmax, ymin, (ymax+ymin)/2.0);
		mostra_folhas(arq, r->dir, 2*ind + 1, prof + 1, xmin, xmax, (ymin+ymax)/2.0, ymax);
	}
}

/**
 * Dado indice da celula calcula-se sua posicao na malha
 * @param ind [in] indice da celula
 * @param delta0 [out] coordenada x da celula
 * @param delta1 [out] coordenada y da celula
 */
void encontra_posicao(int ind, int *delta0, int *delta1)
{
	int bits[64], d0[32],d1[32],i=0,j,l;
	// zerando, para nao ter problemas com lixo
	for(l=0;l<32;l++)
	{
		d0[l] = 0;
		d1[l] = 0;
		bits[2*l] = 0;
		bits[2*l+1] = 0;
	}
	//coverte ind para binario
	while (ind != 0)
	{
		bits[i++] = ind % 2;
		ind = ind /2;
	}
	// IPORTANTE: no vetor bits, os algoritmos  0 1 provenientes da representacao 
	// binaria estao na ordem inversa. Ou seja, se ind = 11 (base 10) entao sua representacao
	// binaria deveria e ind_2 = 1011 mas em no vetor bits esta armazenado o numero 1101.
	
	if(i%2==0)
	{
		// separa os bits q vao formar o vetor posicao
		int cd0 = i/2;
		for(j=0;j<cd0;j++)
		{
			d0[j] = bits[2*j];
		}
		for(j=0;j<cd0-1;j++)
		{
			d1[j] = bits[2*j+1]; 
		}
		// converte d0 e d1 em decimal
		*delta0 = d0[0];
		*delta1 = d1[0];
		for(i=1;i<cd0;i++)
		{
			*delta0 += d0[i]*pow(2,i);
		}
		for(i=1;i<cd0-1;i++)
		{
			*delta1 += d1[i]*pow(2,i);
		}
	}
	else
	{
		// separa os bits q vao formar o vetor posicao
		int cd0 = (i-1)/2;
		for(j=0;j<cd0;j++)
		{
			d0[j] = bits[2*j];
			d1[j] = bits[2*j+1]; 
		} 
		// converte d0 e d1 em decimal
		*delta0 = d0[0];
		*delta1 = d1[0];
		for(i=1;i<cd0;i++)
		{
			*delta0 += d0[i]*pow(2,i);
			*delta1 += d1[i]*pow(2,i);
		}
	}
}

/////////////////////////  brincando !!!!!!!!!!

void imprime_arvore(FILE *arq, VReg pac[], double xmin[], double xmax[], int profund, Preditor pred)
{
	int  k=5; // posteriormente k pode se tornar argumento da funcao
	int ctr = (k*k)/2;
  
	if (pac[ctr].p == NULL) 
	{ 
		return;
	}
	/* Decide o eixo {ex} perpendicular ao corte: */
	int ex = profund % 2;
  
	int qual;
	VReg pac_fil[k*k];
	double xmin_fil[2], xmax_fil[2];
	for (qual = 0; qual <= 1; qual++)
	{
		/* Constrói o pacote do filho {qual}: */
		escolhe_pacote(arq,pac, xmin, xmax, ex, pred, qual, pac_fil, xmin_fil, xmax_fil);
		
		imprime_arvore(arq,pac_fil, xmin_fil, xmax_fil, profund+1, pred);
	}

}


void escolhe_pacote(FILE *arq,VReg pac[],double xmin[], double xmax[], int ex,	Preditor pred,	int qual,	VReg fil[], double xmin_fil[], double xmax_fil[])
{
	int k=5;
	int ctr = k*k/2;
	
	if (pac[ctr-1].p == NULL)
	{
		double hx = xmax[0] - xmin[0];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0]-hx, xmin[1], pac[ctr-1].fv);
	}
	if (pac[ctr+1].p == NULL)
	{
		double hx = xmax[0] - xmin[0];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0]+hx, xmin[1], pac[ctr+1].fv);
	}
	if (pac[ctr-k].p == NULL)
	{
		double hy = xmax[1] - xmin[1];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0], xmin[1]-hy, pac[ctr-k].fv);
	}
	if (pac[ctr+k].p == NULL)
	{
		double hy = xmax[1] - xmin[1];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0], xmin[1]+hy, pac[ctr-k].fv);
	}
	if (pac[ctr-2].p == NULL)
	{
		double hx = xmax[0] - xmin[0];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0]-2.0*hx, xmin[1], pac[ctr-2].fv);
	}
	if (pac[ctr+2].p == NULL)
	{
		double hx = xmax[0] - xmin[0];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0]+2.0*hx, xmin[1], pac[ctr+2].fv);
	}
	if (pac[ctr-2*k].p == NULL)
	{
		double hy = xmax[1] - xmin[1];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0], xmin[1]-2.0*hy, pac[ctr-2*k].fv);
	}
	if (pac[ctr+2*k].p == NULL)
	{
		double hy = xmax[1] - xmin[1];
		fprintf(arq,"%d %10.6f %10.6f %10.6f\n", 0, xmin[0], xmin[1]+2.0*hy, pac[ctr-2*k].fv);
	}


	double xmed = (xmin[ex] + xmax[ex])/2.0;
	xmin_fil[ex] = (qual == 0 ? xmin[ex] : xmed);
	xmax_fil[ex] = (qual == 0 ? xmed : xmax[ex]);
    
	xmin_fil[1-ex] = xmin[1-ex];
	xmax_fil[1-ex] = xmax[1-ex];
	
	int i,j;
	if(ex == 0)
	{ // montando gabarito
		for(i=0; i<k; i++)
		{ 
			if (qual == 0)
			{ /* Filho esquerdo: */
				for(j=0; j<k; j++)
				{ 
					int m = j/2 + 1;
					Reg *pl = pac[i*k+m].p;
					double fa = pac[i*k+m-1].fv;
					double fb = pac[i*k+m].fv;
					double fc = pac[i*k+m+1].fv;
					double fint = pred(fa, fb, fc);

					Reg *p_fil;
					double fv_fil;
					if(j%2 == 0)
					{ 
						p_fil = (pl == NULL ? NULL : pl->esq);
						fv_fil = ((pl == NULL || pl->esq == NULL) ? 2.0*fb - fint : pl->esq->fval);
					}
					else
					{
						p_fil = (pl == NULL ? NULL : pl->dir);
						fv_fil = ((pl == NULL || pl->dir == NULL) ? fint : pl->dir->fval);
					}
					fil[i*k+j].p = p_fil;
					fil[i*k+j].fv = fv_fil;
				}
			}
			else
			{ /* filho direito: */
				for(j=0; j<k; j++)
				{
					int m = (j+1)/2 + 1;
					Reg *pl = pac[i*k+m].p;
					double fa = pac[i*k+m-1].fv;
					double fb = pac[i*k+m].fv;
					double fc = pac[i*k+m+1].fv;
					double fint = pred(fa, fb, fc);
					
					Reg *p_fil;
					double fv_fil;
					if(j%2==0)
					{
						p_fil = (pl == NULL ? NULL : pl->dir);
						fv_fil = ((pl == NULL || pl->dir == NULL) ? fint : pl->dir->fval);
					}
					else
					{
						p_fil = (pl == NULL ? NULL : pl->esq);
						fv_fil = ((pl == NULL || pl->esq == NULL) ? 2.0*fb - fint : pl->esq->fval);
					}
					fil[i*k+j].p = p_fil;
					fil[i*k+j].fv = fv_fil;
				}
			}
		}
	}
	else
	{
      // montando gabarito
		int i,j;
		for(i=0;i<k;i++)
		{
			if(qual==1)
			{ // filho direito
				for(j=0;j<k;j++)
				{
					int z = (i+1)/2;
					Reg *pl = pac[(z+1)*k+j].p;
					double fa = pac[z*k+j].fv;
					double fb = pac[(z+1)*k+j].fv;
					double fc = pac[(z+2)*k+j].fv;
					double fint = pred(fa, fb, fc);
					Reg *p_fil;
					double fv_fil;
					if(i%2==0)
					{ 
						p_fil = (pl == NULL ? NULL : pl->dir);
						fv_fil = ((pl == NULL || pl->dir == NULL) ? fint : pl->dir->fval);
					}
					else
					{
						p_fil = (pl == NULL ? NULL : pl->esq);
						fv_fil = ((pl == NULL || pl->esq == NULL) ? 2.0*fb - fint : pl->esq->fval);
					}
					fil[i*k+j].p = p_fil;
					fil[i*k+j].fv = fv_fil;
				}
			}
			else
			{//filho esquerdo
				for(j=0;j<k;j++)
				{
					int z = i/2;
					Reg *pl = pac[(z+1)*k+j].p;
					double fa = pac[z*k+j].fv;
					double fb = pac[(z+1)*k+j].fv;
					double fc = pac[(z+2)*k+j].fv;
					double fint = pred(fa, fb, fc);
					Reg *p_fil;
					double fv_fil;
					if(i%2==0)
					{ 
						p_fil = (pl == NULL ? NULL : pl->esq);
						fv_fil = ((pl == NULL || pl->esq == NULL) ? 2.0*fb - fint : pl->esq->fval);
					}
					else
					{
						p_fil = (pl == NULL ? NULL : pl->dir);
						fv_fil = ((pl == NULL || pl->dir == NULL) ? fint : pl->dir->fval);
					}
					fil[i*k+j].p = p_fil;
					fil[i*k+j].fv = fv_fil;
				}
			}
		}
	}
}