#include <utilities/log.h>

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

#include <topology/lsvineyard.h>

#include <boost/program_options.hpp>
#include <boost/iterator/counting_iterator.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>
namespace bl = boost::lambda;


typedef     double                                      VertexValue;
typedef     unsigned                                    Vertex;
typedef     std::vector<VertexValue>                    VertexVector;
struct SubscriptFunctor: public std::unary_function<Vertex, VertexValue>
{
                                SubscriptFunctor(const VertexVector& v): vec(&v)    {}
        float                   operator()(Vertex i) const                          { return (*vec)[i]; }
        SubscriptFunctor&       operator=(const SubscriptFunctor& other)            { vec = other.vec; return *this; }
        const VertexVector*     vec;
};
typedef     SubscriptFunctor                            VertexEvaluator;
typedef     std::vector<VertexVector>                   VertexVectorVector;
typedef     LSVineyard<Vertex, VertexEvaluator>         PLVineyard;
typedef     PLVineyard::Simplex                         Smplx;              // gotta start using namespaces

void        program_options(int argc, char* argv[], std::string& complex_fn, 
                                                    std::string& values_fn, 
                                                    std::string& output_prefix, 
                                                    bool& skip_infinite_vines, 
                                                    bool& save_vines,
                                                    bool& explicit_events);
void        read_simplices(const std::string& complex_fn, PLVineyard::LSFiltration& simplices);
void        read_vertices(const std::string& vertex_fn, VertexVectorVector& vertices); 


int main(int argc, char** argv)
{
#ifdef LOGGING
    rlog::RLogInit(argc, argv);
#endif     
    
    std::string                 complex_fn, values_fn, output_prefix;
    bool                        skip_infinite_vines = false, explicit_events = false, save_vines = false;
    program_options(argc, argv, complex_fn, values_fn, output_prefix, skip_infinite_vines, save_vines, explicit_events);


    // Read in the complex
    PLVineyard::LSFiltration            simplices;
    read_simplices(complex_fn, simplices);
    std::cout << "Complex read, size: " << simplices.size() << std::endl;

    // Read in vertex values
    VertexVectorVector                  vertices;
    read_vertices(values_fn, vertices);

    // Setup the vineyard
    VertexEvaluator                     veval(vertices[0]);
    PLVineyard::VertexComparison        vcmp(veval);
    PLVineyard::SimplexComparison       scmp(vcmp);
    simplices.sort(scmp);
    PLVineyard                      v(boost::counting_iterator<Vertex>(0),
                                      boost::counting_iterator<Vertex>(vertices[0].size()), 
                                      simplices, veval);
    std::cout << "Pairing computed" << std::endl;

    // Compute vineyard
    for (size_t i = 1; i < vertices.size(); ++i)
    {
        veval = VertexEvaluator(vertices[i]);
        v.compute_vineyard(veval);
        std::cout << "Processed frame: " << i << std::endl;
    }
    std::cout << "Vineyard computed" << std::endl;
    
    if (save_vines)
        v.vineyard().save_vines(output_prefix, skip_infinite_vines);
    else
        v.vineyard().save_edges(output_prefix, skip_infinite_vines);
}


void        read_simplices(const std::string& complex_fn, PLVineyard::LSFiltration& simplices)
{
    std::ifstream   in(complex_fn.c_str());
    std::string     line;
    while (std::getline(in, line))
    {
        std::istringstream  strin(line);
        simplices.push_back(Smplx(std::istream_iterator<Vertex>(strin), std::istream_iterator<Vertex>()));
    }
    std::cout << "Simplices read:" << std::endl;
    std::copy(simplices.begin(), simplices.end(), std::ostream_iterator<Smplx>(std::cout, "\n"));
}

void        read_vertices(const std::string& vertex_fn, VertexVectorVector& vertices)
{
    std::ifstream   in(vertex_fn.c_str());
    std::string     line;
    while (std::getline(in, line))
    {
        std::istringstream  strin(line);
        vertices.push_back(VertexVector(std::istream_iterator<VertexValue>(strin), std::istream_iterator<VertexValue>()));
    }
    std::cout << "Vertex values read:" << std::endl;
    for (size_t i = 0; i < vertices.size(); ++i)
    {
        std::copy(vertices[i].begin(), vertices[i].end(), std::ostream_iterator<VertexValue>(std::cout, " "));
        std::cout << std::endl;
    }
}

void        program_options(int argc, char* argv[], std::string& complex_fn, 
                                                    std::string& values_fn, 
                                                    std::string& output_prefix, 
                                                    bool& skip_infinite_vines,
                                                    bool& save_vines,
                                                    bool& explicit_events)
{
    namespace po = boost::program_options;

    po::options_description     hidden("Hidden options");
    hidden.add_options()
        ("complex-file",        po::value<std::string>(&complex_fn),            "file listing the simplices of the complex")
        ("values-file",         po::value<std::string>(&values_fn),             "file listing the values at the vertices")
        ("output-prefix",       po::value<std::string>(&output_prefix),         "output prefix");
    
    po::options_description visible("Allowed options", 100);
    visible.add_options()
        ("skip-infinite,s",     po::bool_switch(&skip_infinite_vines),                          "skip infinite vines in the output")
        ("explicit-events,e",   po::bool_switch(&explicit_events),                              "process kinetic sort events one by one")
        ("save-vines,v",        po::bool_switch(&save_vines),                                   "save vines instead of edges")
        ("help,h",                                                                              "produce help message");
#if LOGGING
    std::vector<std::string>    log_channels;
    visible.add_options()
        ("log,l",               po::value< std::vector<std::string> >(&log_channels),           "log channels to turn on (info, debug, etc)");
#endif

    po::positional_options_description pos;
    pos.add("complex-file", 1);
    pos.add("values-file", 1);
    pos.add("output-prefix", 1);
    
    po::options_description all; all.add(visible).add(hidden);

    po::variables_map vm;
    po::store(po::command_line_parser(argc, argv).
                  options(all).positional(pos).run(), vm);
    po::notify(vm);

#if LOGGING
    for (std::vector<std::string>::const_iterator cur = log_channels.begin(); cur != log_channels.end(); ++cur)
        stderrLog.subscribeTo( RLOG_CHANNEL(cur->c_str()) );
#endif

    if (vm.count("help") || !vm.count("complex-file") || !vm.count("values-file") || !vm.count("output-prefix"))
    { 
        std::cout << "Usage: " << argv[0] << " [options] complex-file values-file output-prefix" << std::endl;
        std::cout << visible << std::endl; 
        std::abort();
    }
}