#include <utilities/log.h>

 #include "topology/simplex.h"

 #include "topology/filtration.h"

 #include "topology/static-persistence.h"

 #include "topology/dynamic-persistence.h"

 #include "topology/persistence-diagram.h"

 #include <utilities/indirect.h>

 #include <vector>

 #include <map>

 #include <iostream>

 #if 1

 #include <fstream>

 #include <boost/archive/text_oarchive.hpp>

 #include <boost/archive/text_iarchive.hpp>

 #include <boost/serialization/vector.hpp>

 #endif

 typedef         unsigned                                            Vertex;

 typedef         Simplex<Vertex, double>                             Smplx;

 typedef         Filtration<Smplx>                                   Fltr;

 // typedef         StaticPersistence<>                                 Persistence;

 typedef         DynamicPersistenceTrails<>                          Persistence;

 typedef         PersistenceDiagram<>                                PDgm;

 typedef         OffsetBeginMap<Persistence, Fltr, 

                                Persistence::iterator, 

                                Fltr::Index>                         PersistenceFiltrationMap;

 typedef         OffsetBeginMap<Fltr, Persistence,

                                Fltr::Index, 

                                Persistence::iterator>               FiltrationPersistenceMap;

 // Transposes elements of the filtration together with the 

 struct FiltrationTranspositionVisitor: public Persistence::TranspositionVisitor

 {

     typedef     Persistence::iterator                               iterator;

                 FiltrationTranspositionVisitor(const Persistence& p,

                                                Fltr& f):

                     p_(p), f_(f)                                    {}                                               

     void        transpose(iterator i)                               { f_.transpose(f_.begin() + (i - p_.begin())); }

     const Persistence&  p_;

     Fltr&               f_;

 };

 void fillTriangleSimplices(Fltr& c)

 {

     typedef std::vector<Vertex> VertexVector;

     VertexVector vertices(4);

     vertices[0] = 0; vertices[1] = 1; vertices[2] = 2; 

     vertices[3] = 0;

     VertexVector::const_iterator bg = vertices.begin();

     VertexVector::const_iterator end = vertices.end();

     c.push_back(Smplx(bg,     bg + 1, 0));                 // 0 = A

     c.push_back(Smplx(bg + 1, bg + 2, 1));                 // 1 = B

     c.push_back(Smplx(bg + 2, bg + 3, 2));                 // 2 = C

     c.push_back(Smplx(bg,     bg + 2, 2.5));               // AB

     c.push_back(Smplx(bg + 1, bg + 3, 2.9));               // BC

     c.push_back(Smplx(bg + 2, end,    3.5));               // CA

     c.push_back(Smplx(bg,     bg + 3, 5));                 // ABC

 }

 int main(int argc, char** argv)

 {

 #ifdef LOGGING

     rlog::RLogInit(argc, argv);

     stdoutLog.subscribeTo(RLOG_CHANNEL("topology/persistence"));

     //stdoutLog.subscribeTo(RLOG_CHANNEL("topology/chain"));

     //stdoutLog.subscribeTo(RLOG_CHANNEL("topology/vineyard"));

 #endif

     Fltr f;

     fillTriangleSimplices(f);

     std::cout << "Simplices filled" << std::endl;

     for (Fltr::Index cur = f.begin(); cur != f.end(); ++cur)

         std::cout << "  " << *cur << std::endl;

 #if 1           // testing serialization of the Filtration (really Simplex)

   {  

     std::ofstream ofs("complex");

     boost::archive::text_oarchive oa(ofs);

     oa << f;

     f.clear();

   }  

   {

     std::ifstream ifs("complex");

     boost::archive::text_iarchive ia(ifs);

     ia >> f;

   }  

 #endif

     f.sort(Smplx::DataComparison());

     std::cout << "Filtration initialized" << std::endl;

     std::cout << f << std::endl;

     Persistence p(f);

     std::cout << "Persistence initialized" << std::endl;

     p.pair_simplices();

     std::cout << "Simplices paired" << std::endl;

     Persistence::SimplexMap<Fltr>   m = p.make_simplex_map(f);

     std::map<Dimension, PDgm> dgms;

     init_diagrams(dgms, p.begin(), p.end(), 

                   evaluate_through_map(m, Smplx::DataEvaluator()),

                   evaluate_through_map(m, Smplx::DimensionExtractor()));

     std::cout << 0 << std::endl << dgms[0] << std::endl;

     std::cout << 1 << std::endl << dgms[1] << std::endl;

     PersistenceFiltrationMap                                    pfmap(p, f);

     DimensionFunctor<PersistenceFiltrationMap, Fltr>            dim(pfmap, f);

     // Transpositions

     FiltrationPersistenceMap        fpmap(f, p);

     FiltrationTranspositionVisitor  visitor(p, f);

     Smplx A;  A.add(0);

     std::cout << A << std::endl;

     std::cout << "Transposing A: " << p.transpose(fpmap[f.find(A)], dim, visitor) << std::endl;     // 1.2 unpaired

     Smplx BC; BC.add(1); BC.add(2);

     Smplx AB; AB.add(0); AB.add(1);

     std::cout << BC << std::endl;

     std::cout << p.transpose(fpmap[f.find(BC)], dim, visitor) << std::endl;         // 3.1

     // p.transpose(fpmap[f.find(BC)], dim, visitor);

     std::cout << AB << std::endl;

     std::cout << p.transpose(fpmap[f.find(AB)], dim, visitor) << std::endl;         // 2.1

     // p.transpose(fpmap[f.find(AB)], dim, visitor);

     std::cout << p.transpose(p.begin(), dim, visitor) << std::endl;         // transposition case 1.2 special

     std::cout << p.transpose(boost::next(p.begin()), dim, visitor) << std::endl;

     std::cout << p.transpose(boost::next(p.begin(),3), dim, visitor) << std::endl;

 }