#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <iterator>
#include <time.h>
#include <iostream>
#include <cmath>
using namespace std;

#include "Produit.h"

static char tampon [2048];

Produit::Produit()
{
}

Produit::~Produit()
{
}

//Mise � jour d'un produit
void Produit::majProduit()
{
}

//Insertion d'un nouveau produit
void Produit::nvProduit()
{
}

//Fonction de calcul des surfaces de pixels
long double Produit::createAreaVincenty(Point point)
{
//        Point* pBas = new Point(point.lat, point.lon + pas/2);
		Point* pBas = new Point(point.lat+pas/2, point.lon);
//        Point* pHaut = new Point(point.lat+pas, point.lon + pas/2);
		Point* pHaut = new Point(point.lat-pas/2, point.lon);
//        Point* pGauche = new Point(point.lat+pas/2, point.lon);
		Point* pGauche = new Point(point.lat, point.lon-pas/2);
//        Point* pDroit = new Point(point.lat+pas/2, point.lon+pas);
		Point* pDroit = new Point(point.lat , point.lon+pas/2);
//        double distancePhautPbas = distance(pHaut, pBas)/1000;
        double distancePhautPbas = distance(pBas, pHaut)/1000;
        double distancePgauchePdroit = distance(pGauche, pDroit)/1000;

        delete pBas;
        delete pHaut;
        delete pGauche;
        delete pDroit;
        return ( (distancePhautPbas *  distancePgauchePdroit) );

	
}

long double Produit::distance(Point* p1, Point* p2)
{
	 ////cout<<"lon p1 "<<p1->lon<<" lat p2 "<<p2->lon<<endl;
        p1->lonRad = p1->lon  * ((2*3.14159265)/360) ;
        p2->lonRad = p2->lon * ((2*3.14159265)/360) ;
        p1->latRad = p1->lat * ((2*3.14159265)/360) ;
        p2->latRad = p2->lat * ((2*3.14159265)/360) ;

        ////cout<<"lonrad p2 "<<p2->lonRad<<" lonrad p1 "<<p1->lonRad<<endl;
        long double L = p2->lonRad - p1->lonRad;
        ////cout<<"L "<<L<<endl;
        long double U1 = atan((1 - f) * tan(p1->latRad));
        long double U2 = atan((1 - f) * tan(p2->latRad));

        long double sinU1 = sin(U1);
        long double cosU1 = cos(U1);

        long double sinU2 = sin(U2);
        long double cosU2 = cos(U2);

        long double sinLambda = 0, cosLambda = 0, sinSigma = 0, cosSigma = 0, sigma = 0, sinAlpha = 0, cosSqAlpha = 0, cos2SigmaM = 0;
        long double lambda = L, lambdaP = 2* 3.14159265;
        long double iterLimit = 20;

        while( fabs(lambda-lambdaP) > 1e-12 && --iterLimit>0 )
        {
                sinLambda = sin(lambda);
                cosLambda = cos(lambda);
                sinSigma = sqrt((cosU2*sinLambda) * (cosU2*sinLambda) + (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda));
                if (sinSigma==0) return 0;  // co-incident points
                cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda;
                sigma = atan2(sinSigma, cosSigma);
                sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
                cosSqAlpha = 1 - sinAlpha*sinAlpha;
 cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha;
                if (isnan(cos2SigmaM)) cos2SigmaM = 0;  // equatorial line: cosSqAlpha=0 (6)
                long double C = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha));
                lambdaP = lambda;
                lambda = L + (1-C) * f * sinAlpha * (sigma + C*sinSigma*(cos2SigmaM+C*cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)));
        }

        if (iterLimit == 0) return NAN;  // formula failed to converge

        long double uSq = cosSqAlpha * (a*a - b*b) / (b*b);
        long double A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
        long double B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
        long double deltaSigma = B*sinSigma*(cos2SigmaM+B/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)-B/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)));
        long double s = b*A*(sigma-deltaSigma);
        ////cout<<"s  "<<s<<endl;
        return s;

	
	
}

long double Produit::distanceHaversine(Point* p1, Point* p2)
{
	
	long double a = pow( sin((p2->lat-p1->lat)/2) ,2)+ cos(p2->lat) * pow( sin((p2->lon-p1->lon)/2) ,2);
	long double c = 2*atan2(sqrt(a), sqrt(1-a));
	return R*c;
}

long double Produit::createAreaHaversine(Point point)
{
//        Point* pBas = new Point(point.lat, point.lon + pas/2);
	Point* pBas = new Point(point.lat+pas/2, point.lon);
//        Point* pHaut = new Point(point.lat+pas, point.lon + pas/2);
	Point* pHaut = new Point(point.lat-pas/2, point.lon);
//        Point* pGauche = new Point(point.lat+pas/2, point.lon);
	Point* pGauche = new Point(point.lat, point.lon-pas/2);
//        Point* pDroit = new Point(point.lat+pas/2, point.lon+pas);
	Point* pDroit = new Point(point.lat , point.lon+pas/2);

//	double distancePhautPbas = distanceHaversine(pHaut, pBas)/1000;
	double distancePhautPbas = distanceHaversine(pBas, pHaut)/1000;
	double distancePgauchePdroit = distanceHaversine(pGauche, pDroit)/1000;
	
	delete pBas; 
	delete pHaut; 
	delete pGauche; 
	delete pDroit; 
	return ( distancePhautPbas *  distancePgauchePdroit );
}



char* Produit::getExtensionFileRead(char* fichier) 
{
	
	string fichierStr = fichier;
	
	string nomFich = SplitFilename(fichier);
	size_t found = (nomFich).find_last_of(".") ;
	
	//if ((nomFich).substr(found+1, nomFich.length() ) != NULL )	
		fichierStr=(nomFich).substr(found+1, nomFich.length());
	//else
		//fichierStr="";
		
		return (char*)fichierStr.c_str();
	/*
	char* fich = fichier;
	while (strchr(fich, '/') != NULL)
	{
		 fich = strchr(fich, '/')+1;
	}	
	if ( strchr(fich, '.') != NULL ) 
	fich = strchr(fich, '.')+1;
	else fich = "";
	
	
	return fich;*/
}




//------------------------------------Fonctions de lecture des donn�es brutes-------------------------------------------//

//Scan d'un repertoire : determiner les sous repertoires et les fichiers

Repertoire Produit::scanRep(Repertoire rep)
{
	struct dirent *item;
	static struct stat stat_item;
	DIR *dirp;
	char *addr;
	//cout<<"-----------------------------------------ScanRep------------------------------------"<<endl;	
	if ((dirp = opendir(rep.chemin)) != NULL)
	{
		strcpy(tampon, rep.chemin);
		strcat(tampon, "/");
		addr= &tampon[strlen(tampon)];

		while ((item=readdir(dirp)) != NULL)
		{
			strcpy(addr, item->d_name);
			if (!stat(tampon, &stat_item))
			{
				if (S_ISDIR(stat_item.st_mode))
				{
					if (strcmp(item->d_name, ".") && strcmp(item->d_name, ".."))
					{
						Repertoire child;
						child.allouRep(stat_item,item->d_name, tampon, rep.level);
						rep.children.push_back(child);
					}
				}
				else
					{
						Feuille fich = Feuille(stat_item, item->d_name,tampon, rep.level);
						rep.fichier.push_back(fich);
					}
			}
		}
		//cout<<"-----------------------------------------end ScanRep------------------------------------"<<endl;
		
	}
	else
	{
		 //logger->addReadersMessagesErrors("Impossible d'ouvrir le perertoire : "+rep.chemin);
		 cout << " --->   Impossible d'ouvrir le repertoire : " << rep.chemin << endl;  
	}
	
	return(rep);
	
}

//iterer sur toute l'arborescence
void Produit::scanParcour(Repertoire rep)
{
	rep = scanRep(rep);
	parcourRep(rep);
}

//--------------------------------------------------------------------------------------------------------------------//

void Produit::parcourRep(Repertoire rep)
{	
	if (!rep.children.empty())
	{
		list<Repertoire>::iterator it;
		for (it = rep.children.begin(); it != rep.children.end(); it++){
			scanParcour((*it));
		}
	}
	
	if (!rep.fichier.empty())
	{
		base.readBD(logger);
//		cout << "    traitement des fichiers du repertoire : "<< rep.nom << endl;
			
		bool verifExt;
			
		list<Feuille>::iterator itt;
		for (itt = rep.fichier.begin(); itt != rep.fichier.end(); itt++)
		{
//			cout << ".......... Fichier à traiter:"<<  (*itt).nom <<endl;
			if(!strcmp("NULL", extension))
				verifExt=true;
			else
				verifExt=!strcmp(getExtensionFileRead((*itt).chemin),extension);
//			cout << ".......... verifExt="<<verifExt <<endl;
			if ( ( verifExt && base.fichier.verifDate(ctime(&((*itt).stt.st_ctime)), base.produit.getTuple(NomProduit)->id, (*itt).nom) ) || ( !strcmp("", extension) && base.fichier.verifDate(ctime(&((*itt).stt.st_ctime)), base.produit.getTuple(NomProduit)->id, (*itt).nom) ) )
			{
				//cout<<"-----------verifDate------------"<<  base.fichier.verifDate(ctime(&((*itt).stt.st_ctime)), base.produit.getTuple(NomProduit)->id, (*itt).nom) <<(*itt).chemin <<endl;
				//cout<< !strcmp(strchr((*itt).chemin , '.')+1, extension)<<"//////8888//////////"<<endl;
//				cout << ".......... Traitement du fichier "<<(*itt).chemin<<"    "<<  (*itt).nom <<endl;
				//cout << ".......... Traitement du fichier : "<<"    "<<  (*itt).nom <<endl;
				readFile((*itt));
				//cout << ".......... fin Traitement du fichier : "<<endl;
			}
		}
		//cout<< " taille rep="<<rep.fichier.size()<<endl;
	}
		
	if (rep.children.empty() && rep.fichier.empty())
	{
		//logger->addReadersMessagesErrors("Le repertoire : "+rep.chemin+"est vide");
		//printf("--- Le repertoire : %s est vide \n", rep.chemin);
		cout<<"--- Le repertoire : "<<rep.chemin<<" est vide"<<endl;
	}
}

void Produit::deleteProduct(string idProduct)
{
	PGconn* conn = base.connectBD(logger);
	string sql = "delete from grille where id_produit ="+idProduct+";";
	////cout << sql << endl;
	
	PGresult* res = PQexec(conn, sql.c_str());
	if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
	{
		logger->traitementBaseMessages(" DELETE GRILLE " , res);
		////cout<<"delete"<<endl;
	}
	
	sql = "delete from fichier where id_produit ="+idProduct+";";
	////cout << sql << endl;
	
	res = PQexec(conn, sql.c_str());
	if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
	{
		logger->traitementBaseMessages(" DELETE FICHIER " , res);
		////cout<<"delete fichier"<<endl;
	}
	PQfinish(conn);	
}

bool Produit::chercheFichierRep(Rowfichier fichier, Repertoire rep)
{
	rep = scanRep(rep);
	////cout<<"repchercheFichierRep  "<<rep.nom<<endl;
	bool trouve = false;
	if (!rep.children.empty())
	{
		////cout<<"children"<<endl;
		list<Repertoire>::iterator itRep;
		for (itRep = rep.children.begin(); itRep != rep.children.end(); itRep++)
		{
			Repertoire reper = scanRep((*itRep));
			trouve = chercheFichierRep(fichier, reper);
		}
	}
	if (trouve) return trouve;
	else
	{
		list<Feuille>::iterator itt;
		////cout<<"taille "<<rep.fichier.size()<<endl;
		////cout<<"nom rep "<<rep.chemin<<endl;
		//if (rep.fichier.empty()) return trouve;
		for (itt = rep.fichier.begin(); itt != rep.fichier.end(); itt++)
		{
			/*if (fichier.idProduit == base.produit.getTuple(NomProduit)->id)
			{*/
			////cout <<(*itt).nom<<"      "<<fichier.name<<endl;
			if(  ( fichier.idProduit == base.produit.getTuple(NomProduit)->id )  && ( !strcmp((*itt).nom, (fichier.name).c_str()) ) ) 
			{
				////cout <<(*itt).nom<<"   **   "<<fichier.name<<endl;
				trouve = true;
				return trouve;
				break;
			}
			//}
		}
	}
	return trouve;
	
}



bool Produit::fichierAbst(Tabfichier tabFichier, Repertoire rep)
{

	//cout << "fonction  fichierAbst " <<rep.nom <<endl;
	bool absent;  
	//cout<<"tabFichier"<<tabFichier.tuples.size()<<endl;
	//cout<<"rep"<<rep.fichier.size()<<endl;
	if ( !tabFichier.tuples.empty() )
	{ 
		absent = false;
		rep = scanRep(rep);
		
		list<Rowfichier>::iterator it;
		
		for (it = tabFichier.tuples.begin() ; it != tabFichier.tuples.end(); it++){
			if ((*it).idProduit == base.produit.getTuple(NomProduit)->id){
				if(!chercheFichierRep((*it), rep)){
					absent = true;
					break;
				}
			}
		}
	}
	else absent=false;
	
	return absent;
	
}

void Produit::readFile(Feuille f)
{
}

void Produit::verifMinMax(float min, float max)
{
	Base baseVerif;
	baseVerif.readBD(logger);
	
	float minBase = atof(  (baseVerif.parametre.getTuple(NomParametre)->minCalculate).c_str()  );
	float maxBase = atof(  (baseVerif.parametre.getTuple(NomParametre)->maxCalculate).c_str()  );
//	cout<<"minbase="<<minBase<<", min="<<min<<", maxbase="<<maxBase<<", max="<<max <<endl;

	if (min < minBase)
	{
		PGconn* conn = base.connectBD(logger);
		string sql = "update parametre set min_param_calculate ="+ ftoa(min) +" where id_param="+ base.parametre.getTuple(NomParametre)->id +";";
		////cout<<"sql "<<sql<<endl;
		PGresult* res = PQexec(conn, sql.c_str());
		PQfinish(conn);
		
		/*if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
		{
			logger->traitementBaseMessages(" UPDATE PARAM MIN " , res);
		}*/
	}
	
	if (max > maxBase)
	{
		PGconn* conn = base.connectBD(logger);
		string sql = "update parametre set max_param_calculate ="+ ftoa(max) +" where id_param="+ base.parametre.getTuple(NomParametre)->id +";";
		////cout<<"sql "<<sql<<endl;
		////cout<<"maxBase "<<maxBase<<endl;
		PGresult* res = PQexec(conn, sql.c_str());
		PQfinish(conn);
		
		/*if ( PQresultStatus(res) != PGRES_TUPLES_OK)  
		{
			logger->traitementBaseMessages(" UPDATE PARAM MAX " , res);
		}*/
	}
}