#include "cparams.h"
#include <cstdio>

#include <cstdlib>
#include <cstdio>
#include <iostream>

#include <tuning.h>

time_t CParams::s_time_start = time(NULL) ;

#ifndef MULTITHREAD_MODE
#define MULTITHREAD_MODE DEFAULT_MULTITHREAD_MODE
#define COMPILATION_MULTITHREAD false
#else
#define COMPILATION_MULTITHREAD true
#endif

#define USAGE \
"Usage :\n\t%s [-h|-?] [-t TIME] [-n INSTANCE] [-r SOLUTION] [-i]"\
"                   [-s] [-strat STRAT] [-duals METH] [-fa METH] [-accepte_pa] [-rejet_crp]\n"\
"\toptions : \n"\
"\t\t-h|-?          : affiche ce message\n"\
"\t\t-t TIME        : limite de temps d'exécution\n"\
"\t\t-n INSTANCE    : nom du fichier contenant l'instance du problème (dans ./)\n"\
"\t\t-r SOLUTION    : nom du fichier solution à produire\n"\
"\t\t-i             : affiche l'identifiant de l'équipe sur la sortie standard\n"\
"\t\t-s             : produire des stats plutôt que lancer l'optimisation\n"\
"\t\t-strat STRAT   : définir la stratégie d'optimisation. Valeurs possibles :\n"\
"\t\t                           toujoursDualAscent_sansCliques\n"\
"\t\t                           jamaisDualAscent_avecCliques\n"\
"\t\t                           Cliques_puis_DualAscent_AvecCliques_quand_plus_de_nouveaux_plans\n"\
"\t\t                           Cliques_puis_DualAscent_SansCliques_quand_plus_de_nouveaux_plans\n"\
"\t\t                           Cliques_et_DualAscent_alternes\n"\
"\t\t-duals METHOD  : définir la méthode de calcul des variables duales. Valeurs possibles :\n"\
"\t\t                           dualascent\n"\
"\t\t                           cplexduals_1ct  : une colonne thermique agrégée\n"\
"\t\t                           cplexduals_ct   : une colonne thermique par centrale\n"\
"\t\t                           cplexduals_dt   : une diagonale thermique liée par centrale\n"\
"\t\t                           cplexduals_scenarios : diagonales thermiques libres * S\n"\
"\t\t                           cplexduals      : une diagonale thermique libre par centrale\n"\
"\t\t-sel   METHOD  : définir le type de sélecteur de colonnes. Valeurs possibles :\n"\
"\t\t                           1ct             : une colonne thermique\n"\
"\t\t                           ct              : plusieurs colonnes thermiques\n"\
"\t\t                           cts             : plusieurs colonnes et scénarios\n"\
"\t\t                           1cts            : une thermique, plusieurs scénarios\n"\
"\t\t-fa    METHOD  : définir le type de filtre aval. Valeurs possibles :\n"\
"\t\t                           manuel\n"\
"\t\t                           cplex\n"\
"\t\t                           cplex_reste_libre\n"\
"\t\t                           cplex_ultime\n"\
"\t\t                           cplex_ultime_1passe\n"\
"\t\t-disc  COEFF   : définir le coefficient de discrétisation (1 par défaut)\n"\
"\t\t-accepte_pe    : accepte les plans existants\n"\
"\t\t-rejette_crp   : rejette les coûts réduits positifs\n"\
"\t\t-mt            : inverse le mode multithread\n"\
"\n\n"

    /* lecture des options */
    /* ========================================================================= */
    /* ========================================================================= */
    /* Quoi: Analyse les arguments de la ligne de commande                       */
    /* Entrée: argc (nombre d'arguments) et argv (liste des arguments)           */
    /*                                                                           */
    /* ------------------------------------------------------------------------- */

CParams::CParams( int argc, char * argv[] )
{
    /* paramètres par défaut */
    m_multithread       = MULTITHREAD_MODE ;
    m_limit_type        = TIME_LIMIT ;
    m_affiche_id        = false ;
    m_instance_given    = false ;
    m_solution_given    = false ;
    m_optimize          = true  ;
    m_time_limit        = DEFAULT_TIME_LIMIT        ;
    m_strategie         = STRATEGIE_PAR_DEFAUT      ;
    m_dualmethod        = DUALS_PAR_DEFAUT          ;
    m_filtreaval        = FILTRE_AVAL_PAR_DEFAUT    ;
    m_selecteur         = SELECTEUR_PAR_DEFAUT      ;
    m_discretisation	= DEFAULT_FACTEUR_DE_PAVAGE ;

#ifdef OPTION_REJETE_PLANS_EXISTANTS
    m_rejet_existants   = true  ;
#else
    m_rejet_existants   = false  ;
#endif
#ifdef OPTION_REJETE_COUTS_REDUITS_POSITIFS
    m_rejet_cr_positif  = true ;
#else
    m_rejet_cr_positif  = false ;
#endif

    /* lecture des paramètres */
    string erreur       = "" ;
    char *pgm_name;

    pgm_name = argv[0];
    argv++; (argc)--;

    if (!argc)
        erreur = "Aucun argument trouvé" ;

    while (argc) {
        string arg = *argv ;
        if (arg == "-h" || arg == "-?") { /* HELP */
            erreur = "Help :" ;
        }
        else if ( arg == "-t") /// limite de temps
        {
            argc--; argv++;
            if (argc)
                m_time_limit = atoi(*argv) ;
            else
                erreur = "-t utilisé sans arguments";
        }
        else if ( arg == "-p") /// limite de passes
        {
            argc--; argv++;
            if (argc)
                m_pass_limit = atoi(*argv) ;
            else
                erreur = "-p utilisé sans arguments";
            m_limit_type = PASS_LIMIT;
        }
        else if ( arg == "-n") /// instance
        {
            argc--; argv++;
            if (argc) {
                m_instance_name = *argv ;
                m_instance_given = true ;
            } else
                erreur = "-n utilisé sans arguments";
        }
        else if ( arg == "-r") /// nom de la solution
        {
            argc--; argv++;
            if (argc) {
                m_solution_name = *argv ;
                m_solution_given = true ;
            } else
                erreur = "-r utilisé sans arguments";
        }
        else if ( arg == "-i") /// team_id
        {
            m_affiche_id = true ;
        }
        else if ( arg == "-s" ) /// statistiques (custom)
        {
            m_optimize = false ;
        }
        else if ( arg == "-mt" ) /// statistiques (custom)
        {
            m_multithread = not m_multithread;
        }
        else if ( arg == "-duals" ) /// méthode de calcul des variables duales (custom)
        {
            argc--; argv++;
            if (argc==0) {
                erreur = "-duals utilisé sans arguments";
            } else {
                string strat = *argv ;
                if (strat=="dualascent")
                    m_dualmethod = d_dualascent ;
                else if (strat=="cplexduals_scenarios")
                    m_dualmethod = d_cplexduals_scenarios ;
                else if (strat=="cplexduals")
                    m_dualmethod = d_cplexduals ;
                else if (strat=="cplexduals_1ct")
                    m_dualmethod = d_cplexduals_1ct ;
                else if (strat=="cplexduals_ct")
                    m_dualmethod = d_cplexduals_ct ;
                else if (strat=="cplexduals_dt")
                    m_dualmethod = d_cplexduals_dt ;
                else
                    erreur = "-duals utilisé avec un argument inconnu : " + strat ;
            }
        }
        else if ( arg == "-sel" ) /// type de filtre aval (custom)
        {
            argc--; argv++;
            if (argc==0) {
                erreur = "-sel utilisé sans arguments";
            } else {
                string strat = *argv ;
                m_selecteur = sel_ct ;
            }
        }
        else if ( arg == "-fa" ) /// type de filtre aval (custom)
        {
            argc--; argv++;
            if (argc==0) {
                erreur = "-fa utilisé sans arguments";
            } else {
                string strat = *argv ;
                if (strat=="manuel")
                    m_filtreaval = fa_manuel ;
                else if (strat=="cplex")
                    m_filtreaval = fa_cplex ;
                else if (strat=="cplex_reste_libre")
                    m_filtreaval = fa_cplex_reste_libre ;
                else if (strat=="cplex_ultime")
                    m_filtreaval = fa_cplex_ultime ;
                else if (strat=="cplex_ultime_1passe")
                    m_filtreaval = fa_cplex_ultime_1passe ;
                else
                    erreur = "-fa utilisé avec un argument inconnu : " + strat ;
            }
        }
         else if ( arg == "-disc" ) /// type de filtre aval (custom)
        {
            argc--; argv++;
            if (argc==0) {
                erreur = "-disc utilisé sans arguments";
            } else {
                m_discretisation = (coeff_t)atof(*argv) ;
            }
        }
       else if ( arg == "-accepte_pe" ) /// accepte les plans existants (custom)
        {
            m_rejet_existants = false ;
        }
        else if ( arg == "-rejette_crp" ) /// accepte les plans existants (custom)
        {
            m_rejet_cr_positif = true ;
        }
        else
            erreur = "Argument inconnu";

        argc--; argv++;
    }

    if (erreur!="")
    {
        fprintf(stderr, "%s\n", erreur.c_str()) ;
        fprintf(stderr, USAGE, pgm_name) ;
        throw string("Arrêt après la lecture des arguments");
    }


    if (not m_affiche_id) {
//     std::cout << ( COMPILATION_MULTITHREAD ? "Compilé en multithread" : "Compilé sans multithread" ) << std::endl ;
        std::cout << ( m_multithread ? "Version multi-threads" : "Version mono-thread" )  ;
        std::cout << "\t(Utiliser le switch -mt pour modifier le mode)" << std::endl ;
    }
}



CParams::~CParams()
{
}