#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <unistd.h>

#include "../ag_gen/asset.h"
#include "../ag_gen/assetgroup.h"
#include "../ag_gen/edge.h"
#include "../ag_gen/exploit.h"
#include "../ag_gen/factbase.h"
#include "../ag_gen/network_state.h"
#include "../ag_gen/ag_gen.h"

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/properties.hpp>
#include <boost/graph/graphviz.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/ini_parser.hpp>
#include <boost/graph/visitors.hpp>
#include <boost/graph/depth_first_search.hpp>


#include <boost/archive/tmpdir.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>

#include <boost/serialization/base_object.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/string.hpp>

#include <boost/mpi.hpp>
#include <boost/mpi/environment.hpp>
#include <boost/mpi/communicator.hpp>

#include <boost/serialization/is_bitwise_serializable.hpp>

namespace mpi = boost::mpi;


void save_quality(const Quality &q, const char * filename){
    std::ofstream ofs(filename);
    boost::archive::text_oarchive oa(ofs);
    oa << q;
}

void restore_quality(Quality &q, const char * filename){
    std::ifstream ifs(filename);
    boost::archive::text_iarchive ia(ifs);
    ia >> q;
}

int quality_check(Quality &q1, Quality &q2){
    if (q1.get_asset_id() == q2.get_asset_id() &&
        q1.get_name() == q2.get_name() && 
        q1.get_op() == q2.get_op() &&
        q1.get_value() == q2.get_value())
    {
        return 1;
    }

    else return 0;
}

int param_quality_check(ParameterizedQuality &pq1, ParameterizedQuality &pq2){
    if (pq1.param == pq2.param &&
        pq1.name == pq2.name &&
        pq1.value == pq1.value &&
        pq1.op == pq2.op)
   {
    return 1;
   }

    else return 0;
}

int param_topology_check(ParameterizedTopology &pt1, ParameterizedTopology &pt2){
    if (pt1.get_from_param() == pt2.get_from_param() &&
        pt1.get_to_param() == pt2.get_to_param() &&
        pt1.get_dir() == pt2.get_dir() && 
        pt1.get_property() == pt2.get_property() &&
        pt1.get_operation() == pt2.get_operation() &&
        pt1.get_value() == pt2.get_value())
    {
        return 1;
    }

    else return 0;
}

int postcond_quality_check(PostconditionQ &pq1, PostconditionQ &pq2){

    auto preq1 = std::get<1>(pq1);
    auto preq2 = std::get<1>(pq2);

    if(param_quality_check(preq1, preq2) == 1 &&
        std::get<0>(pq1) == std::get<0>(pq2))
    {
        return 1;
    }

    else return 0;
}

int postcond_topology_check(PostconditionT &pt1, PostconditionT &pt2){

    auto pret1 = std::get<1>(pt1);
    auto pret2 = std::get<1>(pt2);

    if(param_topology_check(pret1, pret2) == 1 &&
        std::get<0>(pt1) == std::get<0>(pt2))
    {
        return 1;
    }

    else return 0;
}

int exploit_check(Exploit &exp1, Exploit &exp2){
    int base_corr = 0;

    //Precondition counters
    int pre_qual_corr = 0;
    int pre_qual_count = 0;
    int pre_topo_corr = 0;
    int pre_topo_count = 0;

    //Postcondition counters
    int post_qual_corr = 0;
    int post_qual_count = 0;
    int post_topo_corr = 0;
    int post_topo_count = 0;

    //Base member check correctness
    if (exp1.get_id() == exp2.get_id() &&
        exp1.get_name() == exp2.get_name() &&
        exp1.get_group() == exp2.get_group() &&
        exp1.get_num_params() == exp2.get_num_params())
    {
        base_corr = 1;
    }

    //Init lists for pre and post conditions for quals and topos
    auto exp1_pre_quals = exp1.precond_list_q();
    auto exp2_pre_quals = exp2.precond_list_q();

    auto exp1_pre_topos = exp1.precond_list_t();
    auto exp2_pre_topos = exp2.precond_list_t();

    auto exp1_post_quals = exp1.postcond_list_q();
    auto exp2_post_quals = exp2.postcond_list_q();

    auto exp1_post_topos = exp1.postcond_list_t();
    auto exp2_post_topos = exp2.postcond_list_t();

    //Init iterators for preconds
    auto itq1 = exp1_pre_quals.begin();
    auto itq2 = exp2_pre_quals.begin();

    auto itt1 = exp1_pre_topos.begin();
    auto itt2 = exp2_pre_topos.begin();

    //Check Precondition Qualities
    while(itq1 != exp1_pre_quals.end() || itq2 != exp2_pre_quals.end())
    {
        pre_qual_corr += param_quality_check(*itq1, *itq2);
        pre_qual_count++;

        if(itq1 != exp1_pre_quals.end())
            ++itq1;

        if(itq2 != exp2_pre_quals.end())
            ++itq2;
    }

    //Check Precondition Topologies
    while(itt1 != exp1_pre_topos.end() || itt2 != exp2_pre_topos.end())
    {
        pre_topo_corr += param_topology_check(*itt1, *itt2);
        pre_topo_count++;

        if(itt1 != exp1_pre_topos.end())
            ++itt1;

        if(itt2 != exp2_pre_topos.end())
            ++itt2;
    }

    //Init iterators for postconds
    auto itpq1 = exp1_post_quals.begin();
    auto itpq2 = exp2_post_quals.begin();

    auto itpt1 = exp1_post_topos.begin();
    auto itpt2 = exp2_post_topos.begin();

    //Check Postcondition Qualities
    while(itpq1 != exp1_post_quals.end() || itpq2 != exp2_post_quals.end())
    {
        post_qual_corr += postcond_quality_check(*itpq1, *itpq2);
        post_qual_count++;

        if(itpq1 != exp1_post_quals.end())
            ++itpq1;

        if(itpq2 != exp2_post_quals.end())
            ++itpq2;
    }

    //Check Postcondition Topologies
    while(itpt1 != exp1_post_topos.end() || itpt2 != exp2_post_topos.end())
    {
        post_topo_corr += postcond_topology_check(*itpt1, *itpt2);
        post_topo_count++;

        if(itpt1 != exp1_post_topos.end())
            ++itpt1;

        if(itpt2 != exp2_post_topos.end())
            ++itpt2;
    }
   
    if( base_corr == 1 && 
        pre_qual_count == pre_qual_corr &&
        pre_topo_count == pre_topo_corr &&
        post_qual_count == post_qual_corr &&
        post_topo_count == post_topo_corr)
    {
        return 1;
    }

    else return 0;
}

void save_topology(const Topology &t, const char * filename){
    std::ofstream ofs(filename);
    boost::archive::text_oarchive oa(ofs);
    oa << t;
}

void restore_topology(Topology &t, const char * filename){
    std::ifstream ifs(filename);
    boost::archive::text_iarchive ia(ifs);
    ia >> t;
}

int topology_check(Topology &t1, Topology &t2){
    if (t1.get_from_asset_id() == t2.get_from_asset_id() &&
        t1.get_to_asset_id() == t2.get_to_asset_id() &&
        t1.get_dir() == t2.get_dir() && 
        t1.get_property() == t2.get_property() &&
        t1.get_op() == t2.get_op() &&
        t1.get_value() == t2.get_value())
    {
        return 1;
    }

    else return 0;
}

int ag_check(AssetGroup &ag1, AssetGroup &ag2){
    int qual_count = 0;
    int qual_corr = 0;
    int topo_count = 0;
    int topo_corr = 0;

    auto ag1_quals = ag1.get_hypo_quals();
    auto ag2_quals = ag2.get_hypo_quals();

    auto ag1_topos = ag1.get_hypo_topos();
    auto ag2_topos = ag2.get_hypo_topos();

    auto itq1 = ag1_quals.begin();
    auto itq2 = ag2_quals.begin();

    auto itt1 = ag1_topos.begin();
    auto itt2 = ag2_topos.begin();

    while(itq1 != ag1_quals.end() || itq2 != ag2_quals.end())
    {
        qual_corr += quality_check(*itq1, *itq2);
        qual_count++;

        if(itq1 != ag1_quals.end())
            ++itq1;

        if(itq2 != ag2_quals.end())
            ++itq2;
    }

    while(itt1 != ag1_topos.end() || itt2 != ag2_topos.end())
    {
        topo_corr += topology_check(*itt1, *itt2);
        topo_count++;

        if(itt1 != ag1_topos.end())
            ++itt1;

        if(itt2 != ag2_topos.end())
            ++itt2;
    }
   
    if(ag1.get_perm() == ag2.get_perm() &&
        qual_count == qual_corr &&
        topo_count == topo_corr)
    {
        return 1;
    }

    else return 0;

}

void save_factbase(const Factbase &fb, const char * filename){
    std::ofstream ofs(filename);
    boost::archive::text_oarchive oa(ofs);
    oa << fb;
}

void restore_factbase(Factbase &fb, const char * filename){
    std::ifstream ifs(filename);
    boost::archive::text_iarchive ia(ifs);
    ia >> fb;
}

int factbase_check(Factbase &fb1, Factbase &fb2){
    int qual_count = 0;
    int qual_corr = 0;
    int topo_count = 0;
    int topo_corr = 0;

    auto fb1_tuple = fb1.get_facts_tuple();
    auto fb1_quals = std::get<0>(fb1_tuple);
    auto fb1_topos = std::get<1>(fb1_tuple);
    
    auto fb2_tuple = fb2.get_facts_tuple();
    auto fb2_quals = std::get<0>(fb2_tuple);
    auto fb2_topos = std::get<1>(fb2_tuple);

    auto itq1 = fb1_quals.begin();
    auto itq2 = fb2_quals.begin();

    auto itt1 = fb1_topos.begin();
    auto itt2 = fb2_topos.begin();

    while(itq1 != fb1_quals.end() || itq2 != fb2_quals.end())
    {
        qual_corr += quality_check(*itq1, *itq2);
        qual_count++;

        if(itq1 != fb1_quals.end())
            ++itq1;

        if(itq2 != fb2_quals.end())
            ++itq2;
    }

    while(itt1 != fb1_topos.end() || itt2 != fb2_topos.end())
    {
        topo_corr += topology_check(*itt1, *itt2);
        topo_count++;

        if(itt1 != fb1_topos.end())
            ++itt1;

        if(itt2 != fb2_topos.end())
            ++itt2;
    }
   

    if(fb1.get_id() == fb2.get_id() &&
        qual_count == qual_corr &&
        topo_count == topo_corr)
    {
        return 1;
    }

    else return 0;
}

void save_network_state(const NetworkState &ns, const char * filename){
    std::ofstream ofs(filename);
    boost::archive::text_oarchive oa(ofs);
    oa << ns;
}

void restore_network_state(NetworkState &ns, const char * filename){
    std::ifstream ifs(filename);
    boost::archive::text_iarchive ia(ifs);
    ia >> ns;
}

int network_state_check(NetworkState &ns1, NetworkState &ns2){
    auto fb1 = ns1.get_factbase();
    auto fb2 = ns2.get_factbase();

    return factbase_check(fb1, fb2);
}


void serialization_unit_testing(AGGenInstance &instance, boost::mpi::communicator &world){

    char hammer_host[256];
    gethostname(hammer_host, 256);
    std::string str_host(hammer_host);

    if(world.rank() == 0){
        printf("\n");
        std::cout << "---------STARTING SERIALIZATION UNIT TESTING---------" << std::endl;
    }
    world.barrier();

    std::string rollcall = "Hello from process " + std::to_string(world.rank())\
     + " of " + std::to_string(world.size()) + " running on "\
      + str_host + ".";

    if(world.rank() != 0)
        world.send(0, 0, rollcall);
    else{
        std::cout << rollcall << std::endl;
        for(int i = 0; i < world.size()-1; i++){
            world.recv(mpi::any_source, 0, rollcall);
            std::cout << rollcall << std::endl;
        }
        std::cout << "" << std::endl;
    }
    world.barrier();

    std::string filename(boost::archive::tmpdir());
    filename += "/qualfile.txt";

    auto init_quals = instance.initial_qualities;
    auto init_topos = instance.initial_topologies;
    NetworkState init_state(init_quals, init_topos);//instantiate an obj init_state with initial input

    int e_flag = 0;
    int qual_count = 0;
    int qual_corr = 0;
    int top_count = 0;
    int top_corr = 0;
    int fb_count = 0;
    int fb_corr = 0;
    int ns_count = 0;
    int ns_corr = 0;
    int ag_count = 0;
    int ag_corr = 0;
    int exp_corr = 0;
    int exp_count = 0;

    std::vector<AssetGroup> asset_groups;
    std::vector<Quality> asset_group_quals;
    std::vector<Topology> asset_group_topos;


    if(world.rank() == 0){
        std::cout << "Performing Unit Testing on Exploit Serialization." << std::endl;
    }

    for (auto exp : instance.exploits)
    {
        Exploit new_exp;
        if(world.rank() == 0)
            new_exp = exp;

        mpi::request req;

        broadcast(world, new_exp, 0);
        exp_count++;
        exp_corr += exploit_check(exp, new_exp);
    }
    int total_exp_corr;

    reduce(world, exp_corr, total_exp_corr, std::plus<int>(), 0);

    if (world.rank() == 0){
        std::cout << "Exploit Unit Testing: " << std::to_string(total_exp_corr) << "/" << std::to_string(world.size() * exp_count) << std::endl;
        printf("\n");

        std::cout << "Performing Unit Testing on Quality Serialization." << std::endl;
    }

    for (auto qual : instance.initial_qualities)
    {
        Quality new_qual;
        if(world.rank() == 0)
            new_qual = qual;

        mpi::request req;

        broadcast(world, new_qual, 0);
        qual_count++;
        qual_corr += quality_check(qual, new_qual);

        asset_group_quals.emplace_back(qual);
    }

    int total_qual_corr;

    reduce(world, qual_corr, total_qual_corr, std::plus<int>(), 0);

    if (world.rank() == 0){
        std::cout << "Quality Unit Testing: " << std::to_string(total_qual_corr) << "/" << std::to_string(world.size() * qual_count) << std::endl;
        printf("\n");
  
        std::cout << "Performing Unit Testing on Topology Serialization." << std::endl;
    }

    for (auto topo : instance.initial_topologies)
    {
        Topology new_top;
        if(world.rank() == 0)
            new_top = topo;

        mpi::request req;

        broadcast(world, new_top, 0);
        top_count++;
        top_corr += topology_check(topo, new_top);

        asset_group_topos.emplace_back(topo);
    }

    std::vector<size_t> perm;
    perm.emplace_back(2);

    int total_top_corr;

    reduce(world, top_corr, total_top_corr, std::plus<int>(), 0);

    if (world.rank() == 0){
        std::cout << "Topology Unit Testing: " << std::to_string(total_top_corr) << "/" << std::to_string(world.size() * top_count) << std::endl;
        printf("\n");
        
        std::cout << "Performing Unit Testing on AssetGroup Serialization." << std::endl;
    }

    int total_ag_corr;
    std::vector<size_t> vec;
    vec.resize(2);
    std::fill(vec.begin(),vec.end(),0); 

    AssetGroup default_ag = AssetGroup(asset_group_quals, asset_group_topos, vec);

    for (int i = 0; i < 3; i++)
    {
        AssetGroup new_ag;
        if(world.rank() == 0){
            new_ag = AssetGroup(asset_group_quals, asset_group_topos, vec);
        }

        mpi::request req;

        broadcast(world, new_ag, 0);
        ag_count++;
        ag_corr += ag_check(new_ag, default_ag);
    }
    
    reduce(world, ag_corr, total_ag_corr, std::plus<int>(), 0);
    
    if (world.rank() == 0){
        std::cout << "AssetGroup Unit Testing: " << std::to_string(total_ag_corr) << "/" << std::to_string(world.size() * ag_count) << std::endl;
        printf("\n");

        std::cout << "Performing Unit Testing on Factbase Serialization." << std::endl;
    }

    for (auto fb : instance.factbases)
    {
        Factbase new_fb;
        int id;
        if(world.rank() == 0){
            new_fb = fb;
            id = fb.get_id();
        }

        mpi::request req;

        broadcast(world, new_fb, 0);
        broadcast(world, id, 0);
        new_fb.force_set_id(id);
        fb_count++;
        fb_corr += factbase_check(fb, new_fb);
    }
        
    int total_fb_corr;

    reduce(world, fb_corr, total_fb_corr, std::plus<int>(), 0);  

    if (world.rank() == 0){
        std::cout << "Factbase Unit Testing: " << std::to_string(total_fb_corr) << "/" << std::to_string(world.size() * fb_count) << std::endl;
        printf("\n");
  
        std::cout << "Performing Unit Testing on Network State Serialization." << std::endl;
    }

    NetworkState new_ns;
    int id;
    if(world.rank() == 0){
        new_ns = init_state;
        id = init_state.get_id();
    }

    mpi::request req;

    broadcast(world, new_ns, 0);
    broadcast(world, id, 0);
    new_ns.force_set_id(id);
    ns_count++;
    ns_corr += network_state_check(init_state, new_ns);

    int total_ns_corr;

    reduce(world, ns_corr, total_ns_corr, std::plus<int>(), 0);
    
    if (world.rank() == 0){
        std::cout << "Network State Unit Testing: " << std::to_string(total_ns_corr) << "/" << std::to_string(world.size() * ns_count) << std::endl;
        printf("\n");
    }

    if(world.rank() == 0){

        if(total_exp_corr == world.size() * exp_count)
        {
            std::cout << "100% Success Rate for Exploit Serialization." << std::endl;
        }
        else{
            std::cout << "Errors occurred in the Exploit Serialization." << std::endl;
            e_flag = 1;
        }
        
        if(total_qual_corr == world.size() * qual_count)
        {
            std::cout << "100% Success Rate for Quality Serialization." << std::endl;
        }
        else{
            std::cout << "Errors occurred in the Quality Serialization." << std::endl;
            e_flag = 1;
        }

        if(total_top_corr == world.size() * top_count)
        {
            std::cout << "100% Success Rate for Topology Serialization." << std::endl;
        }
        else{
            std::cout << "Errors occurred in the Topology Serialization." << std::endl;
            e_flag = 1;
        }

        if(total_ag_corr == world.size() * ag_count)
        {
            std::cout << "100% Success Rate for AssetGroup Serialization." << std::endl;
        }
        else{
            std::cout << "Errors occurred in the AssetGroup Serialization." << std::endl;
            e_flag = 1;
        }

        if(total_fb_corr == world.size() * fb_count)
        {
            std::cout << "100% Success Rate for Factbase Serialization." << std::endl;
        }
        else{
            std::cout << "Errors occurred in the Factbase Serialization." << std::endl;
            e_flag = 1;
        }

        if(total_ns_corr == world.size() * ns_count)
        {
            std::cout << "100% Success Rate for Network State Serialization." << std::endl;
        }
        else{
            std::cout << "Errors occurred in the Network State Serialization." << std::endl;
            e_flag = 1;
        }

       std::cout << "" << std::endl;
        if(e_flag == 1)
            std::cout << "-------------ERRORS OCCURRED DURING SERIALIZATION UNIT TESTING---------------" << std::endl;
        std::cout << "---------FINISHED SERIALIZATION UNIT TESTING---------" << std::endl;
        printf("\n");
    }
    //MPI Clean-up
    //MPI_Finalize();
   
    return;
}