#include "ILPTrackPlans.hpp"
#include "TrackPlan.hpp"
#include "gurobi_c++.h"
#include <algorithm>
#include <iterator>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include "../../../General/Model/STFMockInstance.hpp"
#include "gurobi_c.h"

namespace solverlib {
    using namespace modellib;

    ILPTrackPlans::ILPTrackPlans(std::vector<TrackPlan>& plans): m_env(true), trackPlans(plans)
    {
        init();
    }

    void ILPTrackPlans::init()
    {
        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Initializing Gurobi env");

        //m_env.set("LogFile", "ILP.log");
        //m_env.set(GRB_IntParam_ThreadLimit, 1);
        m_env.start();
        m_model = std::make_unique<GRBModel>(m_env);
        m_model->set(GRB_DoubleParam_TuneTimeLimit, 3600);
        m_model->set(GRB_DoubleParam_TimeLimit, 600);
        
        /*
        	MIPFocus 2
            OBBT 1
            Cuts 0
            PrePasses 2
        */
        m_model->set(GRB_IntParam_MIPFocus, 2);
        m_model->set(GRB_IntParam_Cuts, 0);
        m_model->set(GRB_IntParam_PrePasses, 2);
        m_model->set(GRB_IntParam_OBBT, 1);

        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Fetching swap information");
        
        initSwaps();
        
        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Initializing variables");
        
        initVariables();
        
        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Initializing constraints");
        
        addAllConstraints();
        /*m_model->tune();
        m_model->getTuneResult(0);
        m_model->write("tuning.prm");*/
    }

    void ILPTrackPlans::initSwaps()
    {
        loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Getting unique swaps and mandatory selections");

        std::unordered_set<std::shared_ptr<CroisementUM>> swapsU;
        unsigned int p = 0;
        swapsOfTrackPlans.resize(trackPlans.size());
        for(auto& plan : trackPlans)
        {
            if(!plan.isTrash)
            {
                for(auto& sw : plan.mock->swaps)
                {
                    swapsU.insert(sw);
                    swap_setoftrackPlan[sw].push_back(p);
                }
            }
            ++p;
        }

        if(!swapsU.empty())
        {
            std::move(swapsU.begin(), swapsU.end(), std::back_inserter(swaps));
            std::sort(swaps.begin(), swaps.end(), [&](auto& s1, auto& s2){
                return s1->getPotentialSwapSlot().getDebut().getRelativeDate() < s2->getPotentialSwapSlot().getDebut().getRelativeDate();
            });

            // Maintenant que swaps est trié et indexé, on peut remplir swapsOfTrackPlans
            for(unsigned int i = 0; i < swaps.size(); ++i)
            {
                for(auto& planIdx : swap_setoftrackPlan[swaps[i]])
                {
                    swapsOfTrackPlans[planIdx].push_back(i);
                }
            }

            loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Checking incompatible swaps");

            for(unsigned int i = 0; i < swaps.size(); ++i)
            {
                auto& swap = swaps[i];
                const auto& plansOfSwap = swap_setoftrackPlan[swap];

                for(unsigned int j = 0; j < swaps.size(); ++j)
                {
                    if(i == j) continue;
                    auto& swapComp = swaps[j];
                    const auto& plansOfSwapComp = swap_setoftrackPlan[swapComp];

                    // Vérifier si une rame est en commun
                    bool sharedRame = false;
                    for(auto& r : swap->um_crit.ramesInfo)
                        if(swapComp->find(r.id)) { sharedRame = true; break; }
                    if(!sharedRame)
                        for(auto& r : swap->um_sane.ramesInfo)
                            if(swapComp->find(r.id)) { sharedRame = true; break; }

                    if(!sharedRame) continue;

                    // Vérifier si les deux croisements ont au moins un trackplan commun
                    bool hasCommonPlan = false;
                    for(auto& planIdx : plansOfSwap)
                    {
                        for(auto& planIdxComp : plansOfSwapComp)
                        {
                            if(planIdx == planIdxComp) { hasCommonPlan = true; break; }
                        }
                        if(hasCommonPlan) break;
                    }
                    //hasCommonPlan = plansOfSwap == plansOfSwapComp;

                    // Incompatibles si rame commune ET aucun trackplan commun
                    if(!hasCommonPlan)
                    {
                        swap_incompswap[swap].push_back(j);
                    }
                }

                for(unsigned int j = 0; j < swaps.size(); ++j)
                {
                    if(j != i)
                    {
                        if(swaps[i]->getPotentialSwapSlot().getDebut().getRelativeDate() > swaps[j]->getPotentialSwapSlot().getDebut().getRelativeDate())
                        {
                            auto sw = swaps[i];
                            bool foundRame = false;
                            for(auto& ramInfList : {sw->um_sane.ramesInfo, sw->um_crit.ramesInfo})
                            {
                                for(auto& rameInf : ramInfList)
                                {
                                    foundRame = swaps[j]->find(rameInf.id);
                                    if(foundRame)
                                    {
                                        break;
                                    }
                                }
                                if(foundRame)
                                {
                                    break;
                                }
                            }
                            if(foundRame && swap_setoftrackPlan[sw] == swap_setoftrackPlan[swaps[j]])
                            {
                                swapDependsOnSwaps[i].push_back(j);
                            }
                        }
                    }
                }

            }

            for(unsigned int tr = 0; tr < trackPlans.size(); ++tr)
            {
                if(!trackPlans[tr].isTrash)// && trackPlans[tr].mock->swaps.empty())
                {
                    trackPlanNoSWIncompSwap[tr];
                    unsigned int s = 0;
                    for(auto& sw : swaps)
                    {
                        if(trackPlans[tr].mock->swaps.empty() || std::find(swap_setoftrackPlan[sw].begin(), swap_setoftrackPlan[sw].end(), tr) == swap_setoftrackPlan[sw].end())
                        {
                            bool foundRame = false;
                            for(auto& ramInfList : {sw->um_sane.ramesInfo, sw->um_crit.ramesInfo})
                            {
                                for(auto& rameInf : ramInfList)
                                {
                                    foundRame = trackPlans[tr].isRameInScheduleAfterDate(rameInf.id, sw->getPotentialSwapSlot().getDebut().getRelativeDate());
                                    if(foundRame)
                                    {
                                        break;
                                    }
                                }
                                if(foundRame)
                                {
                                    break;
                                }
                            }
                            if(foundRame)
                            {
                                trackPlanNoSWIncompSwap[tr].push_back(s);
                            }
                        }
                        ++s;
                    }
                }
            }
        }
    }

    void ILPTrackPlans::initVariables()
    {
        x_ks.resize(trackPlans.size());
        for(unsigned int i = 0; i < trackPlans.size(); ++i)
        {
            std::string name = "x_" + std::to_string(i);
            x_ks[i] = m_model->addVar(0.0,1.0,0.0, GRB_BINARY, name.c_str());
        }

        swap_ls.resize(swaps.size());
        for(unsigned int i = 0; i < swaps.size(); ++i)
        {
            std::string name = "swap_" + std::to_string(i);
            swap_ls[i] = m_model->addVar(0.0,1.0,0.0, GRB_BINARY, name.c_str());
        }
    }

    std::optional<Planification> ILPTrackPlans::solve()
    {
        m_model->optimize();
        //printSol();
        return buildSolution();
    }

    std::optional<Planification> ILPTrackPlans::buildSolution()
    {
        Planification planif;
        int status = m_model->get(GRB_IntAttr_Status);
        std::vector<TrackPlan> finalTrackPlans;
        std::vector<std::shared_ptr<CroisementUM>> finalSwaps;

        std::vector<unsigned int> finalVar;
        if(status != GRB_INFEASIBLE)
        {
            unsigned int i = 0;
            for(auto& var : x_ks)
            {
                if(var.get(GRB_DoubleAttr_X) > 0)
                {
                    finalTrackPlans.push_back(trackPlans[i]);
                    finalVar.push_back(i);
                }
                ++i;
            }

            unsigned int s = 0;
            for(auto& var : swap_ls)
            {
                if(var.get(GRB_DoubleAttr_X) > 0)
                {
                    finalSwaps.push_back(swaps[s]);
                    //std::cout << swaps[s]->um_crit.ramesInfo[0].id <<  " - " << swaps[s]->um_sane.ramesInfo[0].id << " at " << swaps[s]->getPotentialSwapSlot().getDebut().getRelativeDate() << std::endl;
                }
                ++s;
            }
        }
        else {
            return std::nullopt;
        }
        if(!finalTrackPlans.empty())
        {
            //<job, trackPlanPos in finaltrackplans>
            std::unordered_map<unsigned short, std::vector<unsigned int>> doublonsInfos;
            bool hasDoubles = false;
            unsigned int i = 0;
            for(auto& trSch : finalTrackPlans)
            {
                for(auto& dec : trSch.schedule)
                {
                    doublonsInfos[dec.first].push_back(i);
                    if(doublonsInfos[dec.first].size() > 1)
                        hasDoubles= true;
                }
                ++i;
            }

            if(!hasDoubles)
            {
                loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Solution from ILP is valid");
            }
            else {
                loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Removing jobs appearing multiple types");
                for(auto& doublon : doublonsInfos)
                {
                    std::string tracksAppear = "";
                    for(auto& el : doublon.second)
                    {
                        tracksAppear += std::to_string(!finalTrackPlans[el].isTrash ? finalTrackPlans[el].track : finalVar[el]) + " ";
                    }
                    loggerlib::Logger::systemNotify(loggerlib::LOGGER_PROGRESS, "Job " + std::to_string(doublon.first) + " : " + tracksAppear);

                    if(doublon.second.size() > 1)
                    {
                        std::map<int,std::pair<unsigned int, TrackPlan>> modifiedTrPlans;
                        for(auto& trSchid: doublon.second)
                        {
                            auto trSchCop = finalTrackPlans[trSchid];
                            auto cost = trSchCop.cost;
                            auto suppDec= trSchCop.schedule[doublon.first];
                            trSchCop.schedule.erase(doublon.first);
                            trSchCop.shiftAndRecomputeCostsOnMachine(suppDec.empV);
                            auto costAfter = trSchCop.cost;
                            int gain = costAfter - cost;
                            modifiedTrPlans[gain] = std::make_pair(trSchid,trSchCop);
                        }
                        unsigned int j = 0;
                        for(auto modTrPlan = modifiedTrPlans.begin(); modTrPlan != modifiedTrPlans.end(); ++modTrPlan)
                        {
                            if(j == modifiedTrPlans.size()-1)
                                break;
                            finalTrackPlans[modTrPlan->second.first] = modTrPlan->second.second;
                            ++j;
                        }
                    }
                }
            }
        }
        unsigned int totalCost = 0;
        unsigned int totalDiagCost = 0;
        unsigned int totalNbExclu = 0;
        std::shared_ptr<STFMockInstance> newMock = STFMockInstance::copy(STFInstance::getCurrentInstance()->mockInstance);
        std::sort(finalSwaps.begin(), finalSwaps.end(), [&](auto& el1, auto& el2){return el1->getPotentialSwapSlot().getDebut().getRelativeDate() < el2->getPotentialSwapSlot().getDebut().getRelativeDate(); });
        for(auto& sw : finalSwaps)
        {
            newMock->swap(*sw);
            newMock->swaps.push_back(sw);
            
        }
        planif.setPlanificationState(newMock);
        for(auto& plan : finalTrackPlans)
        {
            totalCost += plan.cost;
            totalDiagCost += plan.diagCost;
            totalNbExclu += plan.isTrash && !plan.schedule.empty();
            std::cout << "Track " << (!plan.isTrash ? std::to_string(plan.track) : "trash") << " ";
            std::vector<std::pair<unsigned short, decision>> decsSorted;
            for(auto& dec : plan.schedule)
            {
                decsSorted.push_back(dec);
            }
            std::sort(decsSorted.begin(), decsSorted.end(), [&](auto& e1, auto& e2){ return e1.second.lastCreneau.first < e2.second.lastCreneau.second;});
            std::cout << "SOURCE : " << std::to_string(static_cast<int>(plan.source)) << " "; 
            for(auto& dec : decsSorted)
            {
                std::cout << STFMockInstance::jobs[dec.first]->getOpId() << " : " << dec.second.lastCreneau.first << "-" << dec.second.lastCreneau.second << " | ";
            }
            std::cout << std::endl;

            auto& decisions = plan.schedule;
            //auto& swaps = finalSwaps;
            auto& trStops = newMock->trajectoryStops;
            for(auto& d : decisions)
            {
                if(!d.second.excluded)
                {
                    unsigned int rameId = STFMockInstance::rameOfOperations[d.first];
                    STFMockInstance::jobs[d.first]->setIdRame(STFMockInstance::rames[rameId]->getId());
                    STFMockInstance::jobs[d.first]->setNumeroEF(STFMockInstance::rames[rameId]->getNumeroEF());
                    bool isPCr = trStops[d.second.empR].typeDispo.first == typeStop::RLT_POST_CROISEMENT_SUBIT || trStops[d.second.empR].typeDispo.first == typeStop::RLT_POST_CROISEMENT_VOULU;
                    std::pair<unsigned short, unsigned short> slot = d.second.rejected ? std::make_pair(d.second.lastCreneau.first, d.second.lastCreneau.first + STFMockInstance::jobs[d.first]->getDureeDiag()) : std::make_pair(d.second.lastCreneau.first, d.second.lastCreneau.first + STFMockInstance::jobs[d.first]->getDuree());
                    OperationPlanifie opPlan(d.first, d.second.voie, d.second.site, d.second.empR, d.second.empV, slot, d.second.rejected, isPCr);
                    planif.addOperation(opPlan);
                }
                else
                {
                    unsigned int rameId = STFMockInstance::rameOfOperations[d.first];
                    STFMockInstance::jobs[d.first]->setIdRame(STFMockInstance::rames[rameId]->getId());
                    STFMockInstance::jobs[d.first]->setNumeroEF(STFMockInstance::rames[rameId]->getNumeroEF());
                    planif.getOpImplanifiables().push_back(d.first);
                }
            }
        }
        for(auto& s : finalSwaps)
        {
            planif.getCroisementsEffectues().push_back(*s);
        }
        std::cout << "Total cost = " << totalCost <<  std::endl;
        std::cout << "Total diagcost = " << totalDiagCost <<  std::endl;
        std::cout << "Nb exclusions = " << totalNbExclu <<  std::endl;
        return planif;
    }   

    void ILPTrackPlans::warmStart(std::vector<TrackPlan>& plans)
    {
        std::vector<unsigned int> varToSet;

        for(auto& plan : plans)
        {
            if(plan.isTrash)
            {
                auto find = std::find_if(trackPlans.begin(), trackPlans.end(), [&](const TrackPlan& p) {
                    return p.isTrash && p.schedule.begin()->first == plan.schedule.begin()->first;
                });
                if(find != trackPlans.end())
                {
                    varToSet.push_back(std::distance(trackPlans.begin(), find));
                }
            }
            else {
                auto find = std::find_if(trackPlans.begin(), trackPlans.end(), [&](const TrackPlan& p) {
                    return p == plan;
                });
                if(find != trackPlans.end())
                {
                    varToSet.push_back(std::distance(trackPlans.begin(), find));
                }
            }
        }


        for(auto& var : x_ks)
        {
            var.set(GRB_DoubleAttr_Start, 0);
        }
        for(auto& var : swap_ls)
        {
            var.set(GRB_DoubleAttr_Start, 0);
        }
        unsigned int cost = 0;
        for(auto j : varToSet)
        {
            x_ks[j].set(GRB_DoubleAttr_Start, 1);
            cost += trackPlans[j].cost;
            for(auto& var : swapsOfTrackPlans[j])
            {
                swap_ls[var].set(GRB_DoubleAttr_Start, 1);
            }
        }

        std::cout << "Cost warm : " << cost << std::endl;
    }

    void ILPTrackPlans::addSwapsSelectedAreCompatible()
    {
        std::unordered_map<unsigned int, std::unordered_set<unsigned int>> pairs;

        for(unsigned int p = 0; p < x_ks.size(); ++p)
        {
            for(auto& cols : swapsOfTrackPlans[p])
            {
                std::string name = "P1: swap " +std::to_string(cols) +" of trplan " + std::to_string(p) + " must be selected if trplan is";
                auto sw = swaps[cols];
                bool foundRame = false;
                for(auto& ramInfList : {sw->um_sane.ramesInfo, sw->um_crit.ramesInfo})
                {
                    for(auto& rameInf : ramInfList)
                    {
                        foundRame = trackPlans[p].isRameInScheduleAfterDate(rameInf.id, sw->getPotentialSwapSlot().getDebut().getRelativeDate());
                        if(foundRame)
                        {
                            break;
                        }
                    }
                    if(foundRame)
                    {
                        break;
                    }
                }
                if(foundRame)
                    m_model->addConstr(swap_ls[cols] >= x_ks[p], name.c_str());  // si constrSw=0 alors swap=0

            }

        }

        for(unsigned int id_swap = 0; id_swap < swaps.size(); ++id_swap)
        {
            for(auto& cols : swap_incompswap[swaps[id_swap]])
            {
                if(pairs[id_swap].find(cols) == pairs[id_swap].end() && pairs[cols].find(id_swap) == pairs[cols].end())
                {
                    pairs[id_swap].insert(cols);
                    pairs[cols].insert(id_swap);
                    std::string incomp = "swap " + std::to_string(id_swap) + " and swap " + std::to_string(cols) + " cannot be selected together";
                    m_model->addConstr(swap_ls[id_swap] + swap_ls[cols] <= 1, incomp.c_str());
                }
            }
        }

        for(auto tr_incomp_swap : trackPlanNoSWIncompSwap)
        {
            for(auto& sw : tr_incomp_swap.second)
            {
                std::string incomp = "swap " + std::to_string(sw) + " and tr " + std::to_string(tr_incomp_swap.first) + " cannot be selected together";
                m_model->addConstr(swap_ls[sw] + x_ks[tr_incomp_swap.first] <= 1, incomp.c_str());
            }
        }

        for(auto swapComp : swapDependsOnSwaps)
        {
            for(auto& sw : swapComp.second)
            {
                std::string incomp = "if swap " + std::to_string(sw) + " is selected then swap " + std::to_string(swapComp.first) + " must be selected";
                m_model->addConstr(swap_ls[sw] >= swap_ls[swapComp.first], incomp.c_str());
            }
        }

    }

    void ILPTrackPlans::printSol()
    {
        unsigned int i = 0;
        unsigned int cost = 0;
        unsigned int nbExcl = 0;
        int status = m_model->get(GRB_IntAttr_Status);
        if(status != GRB_INFEASIBLE)
        {
            for(auto& var : x_ks)
            {
                if(var.get(GRB_DoubleAttr_X) > 0)
                {
                    std::cout << "Track " + (!trackPlans[i].isTrash ? std::to_string(trackPlans[i].track) : "trash" + std::to_string(i)) << std::endl;
                    std::cout << "Jobs : ";
                    for(auto& job : trackPlans[i].schedule)
                    {
                        std::cout << job.first << " ";
                    }
                    std::cout << std::endl;
    
                    if(trackPlans[i].isTrash)
                    {
                        nbExcl++;
                    }
                    cost += trackPlans[i].cost;
                }
                ++i;
            }
            std::cout << "Nb EXcl : " << nbExcl << std::endl;
            std::cout << "Total cost : " << cost << std::endl;
        }
    }

    void ILPTrackPlans::addAllConstraints()
    {
        addTrackAppearsOneTime();
        addJobAppearsOneTime();
        addSwapsSelectedAreCompatible();
        addEpsilonConstraintDiagnosis();
        addObjectiveFunction();
    }


    void ILPTrackPlans::addTrackAppearsOneTime()
    {
        std::unordered_map<unsigned int, GRBLinExpr> trackExpressions;
        for(unsigned int id_col = 0; id_col < trackPlans.size(); ++id_col)
        {
            if(!trackPlans[id_col].isTrash)
            {
                trackExpressions[trackPlans[id_col].track] += x_ks[id_col]; 
            }
        }

        for(auto& trackExpr : trackExpressions)
        {
            std::string name = "track " + std::to_string(trackExpr.first) + " must appear at most once";
            m_model->addConstr(trackExpr.second <= 1, name.c_str());
        }
    
    }

    void ILPTrackPlans::addJobAppearsOneTime()
    {
        for(unsigned int id_job = 0; id_job < STFMockInstance::jobs.size(); ++id_job)
        {
            GRBLinExpr job_once = 0;
            for(unsigned int id_col = 0; id_col < trackPlans.size(); ++id_col)
            {
                if(trackPlans[id_col].isJobOnTrack(id_job))
                {
                    job_once += x_ks[id_col];
                }
            }
            std::string name = "job " + std::to_string(id_job) + " must appear at least once";
            m_model->addConstr(job_once >= 1, name.c_str());
        }
    }

    void ILPTrackPlans::addObjectiveFunction()
    {
        GRBLinExpr sum_T = 0;
        for(unsigned int id_col = 0; id_col < trackPlans.size(); ++id_col)
        {
            sum_T += x_ks[id_col]*trackPlans[id_col].cost;
        }
        m_model->setObjective(sum_T,GRB_MINIMIZE);
    }

    void ILPTrackPlans::addEpsilonConstraintDiagnosis()
    {
        GRBLinExpr sum_epsilon = 0;
        for(unsigned int id_col = 0; id_col < trackPlans.size(); ++id_col)
        {
            sum_epsilon += x_ks[id_col]*trackPlans[id_col].diagCost;
        }
        std::string name = "Diagnosis cost must be below or equal to epsilon = " + std::to_string(configlib::Configuration::Global.EPSILON);
        m_model->addConstr(sum_epsilon <= configlib::Configuration::Global.EPSILON, name.c_str());
    }    

}