//************************************************************************
// --- Logiciel MEF++
// ---
// --- Copyright 1996-2000 GIREF, Universit¿ Laval
// --- TOUS DROITS R¿SERV¿S
// --- ALL RIGHTS RESERVED
// ---
// --- Ce logiciel est couvert par la Loi sur le droit d'auteur.
// --- L'utilisation, ou la modification de ce logiciel sous toutes ses
// --- formes, que ce soit code source ou code compil¿, ¿ des fins
// --- personnelles et non commerciales sont autoris¿es sans frais pour
// --- autant que la pr¿sente notice de copyright ainsi que cette
// --- permission apparaissent dans toutes les copies ainsi que dans la
// --- documentation.
// --- Le GIREF et l'Universit¿ Laval ne pr¿tendent en aucune fa¿on que
// --- ce logiciel convient ¿ un emploi quelconque. Celui-ci est
// --- distribu¿ sans aucune garantie implicite ou explicite.
//************************************************************************

//********************************************************************
//  Nom du fichier:
//
//********************************************************************
//  Description: Programme servant a faire la conversion du
//  format GIREF vers VU.
//
//********************************************************************

#include "ChaineCar.h"
#include "ChampGeoLin.h"
#include "ChampScalConstElem.h"
#include "ChampScalLin.h"
#include "ChampScalQuad.h"
#include "ChampTensO2SymLin.h"
#include "ChampVect2DLin.h"
#include "ChampVect2DQuad.h"
#include "ChampVect3DLin.h"
#include "ChampVect3DQuad.h"
#include "ChampVect3DHierarchique.h"
#include "DoubleurElementsConst.h"
#include "ExportVU.h"
#include "ExportGmsh.h"
#include "ExportGIREF.h"
#include "ExpressionAlgebrique.h"
#include "fonctionsChaineCar.h"
#include "InitialisationArgvArgc.h"
#include "InitialisationTraitementSignal.h"
#include "Maillage.h"
#include "NormalisateurElements.h"
#include "PETScInitialisation.h"
#include "PPNormeL2.h"
#include "RequeteAreteConst.h"
#include "RequeteFaceConst.h"
#include "RequeteSommetConst.h"
#include "traducteurERMsg.h"
#include <cstring>
#include <ctime>
#include <fstream>

using namespace std;


int main(int argc, char *argv[]) {

  ///

  // ***********************************
  // * BLOC: Initialisations g¿n¿rales *
  // ***********************************
  PETScInitialisation lPETScInit(&argc, &argv);
  sInitialisationArgvArgc.asgnArguments(argc, argv);
  initialiseTraitementSignal();

  const vector<string> lArgv = sInitialisationArgvArgc.reqArgv();

  // On d¿clare une variable qui contiendra potentiellement un message d'erreur
  ERMsg lMsg = ERMsg(ERMsg::OK);

  // On recupere le GroupeProcessus associe a PETSC_COMM_WORLD
  const PAGroupeProcessus lGroupeGlobal = PETScInitialisation::reqPetscCommWorld();

  // On d¿clare les variables qui seront extraites de la ligne de commande
  ChaineCar lNomMaillage_0;
  ChaineCar lTypeDeChamp;
  ChaineCar lNomChamp_0;
  ChaineCar lNomMaillage_1;
  ChaineCar lNomChamp_1;
  std::ifstream lFichier_0;
  std::ifstream lFichierFin;

  // V¿rification des param¿tres pass¿s ¿ la ligne de commande.
  const Entier lNbArg = lArgv.size();
  if (lNbArg < 5 || lNbArg > 5) {
    ChaineCar lNomProgramme = sInitialisationArgvArgc.reqNomProgramme();
    ChaineCar lMessageUsage = "USAGE: \n";
    lMessageUsage += enleveCheminAccesFichier(lNomProgramme);
    lMessageUsage += " Prefixe_fichier_Maillage_0 nom_champ_0 Prefixe_fichier_Maillage_1 nom_champ_1";
    lMsg.ajoute(ERMsg(ERMsg::ERREUR, lMessageUsage));
  }
  else {
    lNomMaillage_0          = lArgv[1];
    lNomChamp_0         = lArgv[2];
    lNomMaillage_1               = lArgv[3];
    lNomChamp_1              = lArgv[4];
  }

  if(lMsg) {
    lFichier_0.open(lNomChamp_0.c_str());
    if(lFichier_0){
      importeString(lFichier_0,lTypeDeChamp);
      // on rewind
      lFichier_0.seekg (0, std::ios::beg);
    } else {
      lMsg.ajoute(ERMsg(ERMsg::ERREUR,"ERREUR LECTURE FICHIER: "+ lNomChamp_0));
    }
  }

  if(lMsg && lTypeDeChamp != "ChampVect3DHierarchique"){
    lMsg.ajoute(ERMsg(ERMsg::ERREUR,"Ce type de champs: " + lTypeDeChamp + " n'est pas traite, ajoutez-le dans le source et recompilez!"));
  }

  if(lMsg) {
    lFichierFin.open(lNomChamp_1.c_str());
    if(lFichierFin){
      importeString(lFichierFin,lTypeDeChamp);
      // on rewind
      lFichierFin.seekg (0, std::ios::beg);
    } else {
      lMsg.ajoute(ERMsg(ERMsg::ERREUR,"ERREUR LECTURE FICHIER: "+ lNomChamp_1));
    }
  }

  if(lMsg && lTypeDeChamp != "ChampVect3DHierarchique"){
    lMsg.ajoute(ERMsg(ERMsg::ERREUR,"Ce type de champs: " + lTypeDeChamp + " n'est pas traite, ajoutez-le dans le source et recompilez!"));
  }

  if(lMsg){
    // Lecture du Maillage
    Maillage lMaillage_0;
    lMaillage_0.asgnGroupeProcessus(lGroupeGlobal);
    if(lMsg) lMsg = lMaillage_0.importe(lNomMaillage_0);

    Maillage lMaillage_1;
    lMaillage_1.asgnGroupeProcessus(lGroupeGlobal);
    if(lMsg) lMsg = lMaillage_1.importe(lNomMaillage_1);

    ChampGeoLin lChampGeoG(lMaillage_0);
    ChampVect3DHierarchique lChampG(lChampGeoG);

    if(lMsg){
      lMsg = lChampG.importe(lFichier_0);
    }

    ChampGeoLin lChampGeoF(lMaillage_1);
    ChampVect3DHierarchique lChampF(lChampGeoF);

    if(lMsg){
      lMsg = lChampF.importe(lFichierFin);
    }

    if(lMsg){
      std::cout<<std::endl<<"Pour la différence on envoie "<<lFichier_0<<" sur le maillage "<<lNomMaillage_1<<std::endl<<std::endl;

      ChampVect3DHierarchique lChampDifference(lChampGeoF);
      lChampDifference.reinterpole(lChampG);

      lChampDifference -= lChampF;

      // calcul des normes:

      // Pour la norme L2 on a besoin d'intégrer alors il faut des points de d'intégration
      SchemaIntg lSchemaIntgDefault;

      if(lMsg){// overkill mais bof.
        lSchemaIntgDefault.asgnIntegration(PtIntgTriangle(PtIntgTriangle::Hammer_SeizePtsInternes_Degre8));
        lSchemaIntgDefault.asgnIntegrationFace3Sommets(PtIntgTriangle(PtIntgTriangle::Hammer_SeizePtsInternes_Degre8));
        lSchemaIntgDefault.asgnIntegrationFace4Sommets(PtIntgQuadrangle(PtIntgElem1D(4),PtIntgElem1D(4)));

        lSchemaIntgDefault.asgnIntegration(PtIntgElem1D(4));
        lSchemaIntgDefault.asgnIntegrationArete(PtIntgElem1D(4));

        lSchemaIntgDefault.asgnIntegration(PtIntgTetraedre(6));
        lSchemaIntgDefault.asgnIntegration(PtIntgQuadrangle(PtIntgElem1D(3), PtIntgElem1D(3)));
        lSchemaIntgDefault.asgnIntegration(PtIntgHexaedre(PtIntgElem1D(4), PtIntgElem1D(4), PtIntgElem1D(4)));
        lSchemaIntgDefault.asgnIntegration(PtIntgPrismeTri(PtIntgTriangle(PtIntgTriangle::Hammer_DouzePtsInternes_Degre6), PtIntgElem1D(4)));
      }

      DReel lNormeLDeux;
      PPNormeL2<ChampVect3DHierarchique> lNormeL2(lMaillage_1);
      lNormeL2.asgnParametres(lChampGeoF,lSchemaIntgDefault);
      lNormeL2.ajouteChamp(lChampDifference,lNormeLDeux,NULL);
      lNormeL2.effectueCalcul();

      DReel lNormInfUX(0.), lNormInfUY(0.), lNormInfUZ(0.), lNormInfU(0.);

      if(lMsg){

        Maillage::IterateurSommetConst       lIterSommet    = lMaillage_1.reqSommetDebut();
        const Maillage::IterateurSommetConst lIterSommetFin = lMaillage_1.reqSommetFin();

        Maillage::IterateurAreteConst       lIterArete    = lMaillage_1.reqAreteDebut();
        const Maillage::IterateurAreteConst lIterAreteFin = lMaillage_1.reqAreteFin();

        Maillage::IterateurElement1DConst       lIterElement    = lMaillage_1.reqElement1DDebut();
        const Maillage::IterateurElement1DConst lIterElementFin = lMaillage_1.reqElement1DFin();

        while(lIterSommet != lIterSommetFin) {
          const Maillage::TypeSommet& lSommet = *lIterSommet;
          Vecteur3D lValeur;
          lChampDifference.reqValeurSommet(lSommet,lValeur);
          lNormInfUX = std::max(lValeur[0],lNormInfUX);
          lNormInfUY = std::max(lValeur[1],lNormInfUY);
          lNormInfUZ = std::max(lValeur[2],lNormInfUZ);
          lNormInfU  = std::max(lValeur.reqNorme(),lNormInfU);
          ++lIterSommet;
        }
        while(lIterArete != lIterAreteFin) {
          const Maillage::TypeArete& lArete = *lIterArete;
          Vecteur3D lValeur;
          lChampDifference.reqValeurArete(lArete,lValeur);
          lNormInfUX = std::max(lValeur[0],lNormInfUX);
          lNormInfUY = std::max(lValeur[1],lNormInfUY);
          lNormInfUZ = std::max(lValeur[2],lNormInfUZ);
          lNormInfU  = std::max(lValeur.reqNorme(),lNormInfU);
          ++lIterArete;
        }
        while(lIterElementFin != lIterElementFin) {
          const Element1D& lElement1D = *lIterElement;
          Vecteur3D lValeur;
          lChampDifference.reqValeurElement(lElement1D,lValeur);
          lNormInfUX = std::max(lValeur[0],lNormInfUX);
          lNormInfUY = std::max(lValeur[1],lNormInfUY);
          lNormInfUZ = std::max(lValeur[2],lNormInfUZ);
          lNormInfU  = std::max(lValeur.reqNorme(),lNormInfU);
          ++lIterElement;
        }
      }

      if(lMsg ) {
        std::cout<<"Norme de la différence : "<<std::endl<<std::endl;
        std::cout<<"  Norme inifnie composante X : "<<lNormInfUX<<std::endl;
        std::cout<<"  Norme inifnie composante Y : "<<lNormInfUY<<std::endl;
        std::cout<<"  Norme inifnie composante Z : "<<lNormInfUZ<<std::endl;
        std::cout<<"  Norme inifinie:              "<<lNormInfU<<std::endl;
        std::cout<<"  Norme L2:                    "<<lNormeLDeux<<std::endl;
    }

      // fin calcul des normes

//       std::ofstream lFichierExporte(ltoto.c_str());
//       lChampDifference.exporte(lFichierExporte);
    }

  }



  if (!lMsg) {
    cerr << traducteurERMsg(lMsg);
  }

  return 0;
}