//************************************************************************
// --- Logiciel MEF++
// ---
// --- Copyright 1996-2006 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.
//************************************************************************

#include "MEFPPUtil.h"
#include "ChaineCar.h"
#include "ChampGeoLin.h"
#include "ChampScalContinu.h"
#include "ChampVect3DContinu.h"
#include "ChampVect3DQuad.h"
#include "ExportVU.h"
#include "fonctionsChaineCar.h"
#include "Geometrie.h"
#include "GestionFichierChamps.h"
#include "InitialisationArgvArgc.h"
#include "InitialisationTraitementSignal.h"
#include "ListeConditionsLimites.h"
#include "ListEntitesGeometrique.h"
#include "Maillage.h"
#include "MatricePETScCSR.h"
#include "OptionsSolveurLinPETSc.h"
#include "PETScInitialisation.h"
#include "PPFonctionSurPtsSchemaIntg.h"
#include "ProblemeEF.h"
#include "PtIntgElem1D.h"
#include "PtIntgHexaedre.h"
#include "PtIntgPrismeTri.h"
#include "PtIntgQuadrangle.h"
#include "PtIntgTetraedre.h"
#include "PtIntgTriangle.h"
#include "SchemaIntg.h"
#include "SolveurLinPETSc.h"
#include "traducteurERMsg.h"
#include "VecteurPETSc.h"

#include <ctime>
#include <fstream>
#include <iomanip>
#include <limits_giref>
#include <sstream_giref>

struct Min {
  void preCalcul() { aMin = std::numeric_limits<DReel>::max(); }
  void postCalcul() {}
  void operator()(const DReel &pValeur) { aMin = std::min(aMin, pValeur); }
  double aMin;
};

struct MaxComp {
  MaxComp(int pIndice) : aIndice(pIndice) { }
  void preCalcul() { aMax = -(std::numeric_limits<DReel>::max()); }
  void postCalcul() {}
  void operator()(const Vecteur3D &pVecteur) { aMax = std::max(aMax, pVecteur[aIndice]); }
  double aMax;
  int aIndice;
};

struct MinMax {
  void preCalcul() { aMax = -(std::numeric_limits<DReel>::max()); aMin = std::numeric_limits<DReel>::max(); }
  void postCalcul() {}
  void operator()(const Vecteur3D &pVecteur) { aMax = std::max(aMax, pVecteur.reqZ()); aMin = std::min(aMin, pVecteur.reqZ()); }
  double aMax, aMin;
};

struct MinMinMaxMax {
  void preCalcul() { aMax = -(std::numeric_limits<DReel>::max()); aMin = std::numeric_limits<DReel>::max(); }
  void postCalcul() {}
  void operator()(const Vecteur3D &pVecteur) {
    aMax = std::max(std::max(aMax, pVecteur[0]), std::max(pVecteur[1], pVecteur[2]));
    aMin = std::min(std::min(aMin, pVecteur[0]), std::min(pVecteur[1], pVecteur[2]));
  }
  double aMax, aMin;
};

template <class PTTypeChamp>
void importeChamp(PTTypeChamp& pChamp,std::ifstream& pFichier,ChaineCar& pNomDuChamp){
  pChamp.asgnNom(pNomDuChamp);
  ERMsg lMsg = pChamp.importe(pFichier);  
  if(!lMsg)  std::cout << traducteurERMsg(lMsg) << std::endl;
}

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

  //***********************************
  //* BLOC: Initialisations générales *
  //***********************************
  PETScInitialisation lPETScInit(&argc, &argv);
  sInitialisationArgvArgc.asgnArguments(argc, argv);
  initialiseTraitementSignal();
  const std::vector<std::string> lArgv = sInitialisationArgvArgc.reqArgv();

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

  // On récupère le GroupeProcessus associé à PETSC_COMM_WORLD
  const PAGroupeProcessus lGroupeGlobal = PETScInitialisation::reqPetscCommWorld();

  // On déclare les variables qui seront extraites de la ligne de commande
  ChaineCar lNom;
  ChaineCar lNomFichierPA, lNomFichierPB;
  EntierN lNumPA=0, lNumPB=0, lNumLen=0;

  const Entier lNbArg = lArgv.size();

  if (lNbArg < 7) {
    ChaineCar lNomProgramme = sInitialisationArgvArgc.reqNomProgramme();
    ChaineCar lMessageUsage = "USAGE: \n";

    lMessageUsage += enleveCheminAccesFichier(lNomProgramme);
    lMessageUsage += " Prefixe_fichiers_d_entree NomPartieA NomPartieB NumBas NumHaut NumLen [ENTITE]";
    lMsg.ajoute(ERMsg(ERMsg::ERREUR, lMessageUsage));
  } else {
    lNom          = lArgv[1];
    lNomFichierPA = lArgv[2];
    lNomFichierPB = lArgv[3];
    lNumPA = atoi(lArgv[4].c_str());
    lNumPB = atoi(lArgv[5].c_str());
    lNumLen = atoi(lArgv[6].c_str());
  }

  bool lUtiliseEntite = false;
  ChaineCar lNomEntite;
  if (lNbArg >= 8) {
    lUtiliseEntite = true;
    lNomEntite = lArgv[7];
  }

  //*****************************************************
  //* BLOC: Création des objets utilisés dans le calcul *
  //*****************************************************
  // On crée: la géométrie, la liste d'entités géométriques, le maillage et le champ géométrique.
  Geometrie              lGeo;
  ListEntitesGeometrique lListeEntite;
  Maillage               lMail;
  ChampGeoLin            lChampGeo(lMail);

  //Déclaration de l'objet qui fait la gestion des champs pour le problème.
  GestionFichierChamps lFichierChamp;

  // Par defaut fera tres bien l'affaire ! On pourrait aussi reduire le nombre de
  // points d'integration pour augmenter la rapidite.
  SchemaIntg     lSchemaIntg;

  ProblemeEF lProb;
  lProb.asgnGroupeProcessus(lGroupeGlobal);

  // Assignation de la géométrie, entité, maillage, champgéométrique  au problème
  // et lecture des données d'entrée
  if (lMsg) {
    lMsg = lProb.lisDonnees(lNom, lMail, lGeo, lChampGeo, lListeEntite);
  }

  if (lMsg) {
    if (lUtiliseEntite) {
      // On trouve l'entite
      if (!lListeEntite.identificateurExiste(lNomEntite)) {
        std::ostringstream lOutput;
        lOutput << "L'identificateur de l'entite n'existe pas. Choix disponibles :" << std::endl;

        ListEntitesGeometrique::IterateurEntite lIter = lListeEntite.reqEntiteDebut();
        ListEntitesGeometrique::IterateurEntite lIterFin = lListeEntite.reqEntiteFin();

        while (lIter != lIterFin) {
          lOutput << "\t" << lIter->reqIdentificateur() << std::endl;
          ++lIter;
        }

        lMsg = ERMsg(ERMsg::ERREUR, lOutput.str());
      }
    }

    if (lMsg) {

      ChaineCar lNomDuChamp("U");
      ChampVect3DQuad lChamp3D(lChampGeo);

      if (lMsg) {
        lSchemaIntg = lChamp3D.reqFonctionsInterpolation().reqPositionsDDLsComplets();
      }
      // S'assure de la precision desiree et du type de sortie.
      std::cout.precision(8);
      std::cout.setf(std::ios::scientific);

      // PPFonction avec MinMax sur reqZ()
      PPFonctionSurPtsSchemaIntg<ChampVect3DContinu, MinMax> lPPFonction(lMail);
      MinMax lMinMax;
      if (lMsg) {
        lPPFonction.asgnParametres(lChampGeo, lChamp3D, &lMinMax, lSchemaIntg);
        if (lUtiliseEntite) lMsg = lPPFonction.asgnEntiteGeo(lListeEntite.reqEntiteGeometrique(lNomEntite));
      }

      Entier lLongueur = static_cast<int>(floor(log10(static_cast<DReel>(lNumLen)))+1);

      // Effectue le calcul pour chacun des fichiers
      for (EntierN i = lNumPA; (i <= lNumPB) && lMsg; ++i) {
        // Fabrique la chaine
        ChaineCar lNomFichier;
	lNomFichier = ajouteNumeroALaFin(lNom,i,lLongueur);
	lNomFichier =lNomFichier +".U.champv3dquad";

        std::ifstream lFichier(lNomFichier.c_str());
	importeChamp(lChamp3D,lFichier,lNomDuChamp);
        lFichier.close();

        if (lMsg) lMsg = lPPFonction.effectueCalcul();

        if (lMsg) {
          std::cout << lChamp3D.reqTemps() << "   " << lMinMax.aMin << "  " << lMinMax.aMax << std::endl;
        }
      }
    }
  }

  int lValeurRetour = 0;
  if(!lMsg) {
    std::cerr << traducteurERMsg(lMsg) << std::endl;
    lValeurRetour = 1;
  }

  return lValeurRetour;
}