#include "GKR_Test.h"

#include <sys/types.h> // for getpid
#include <unistd.h> // for getpid

#include <fstream>
#include <iostream> // for cout
#include <iomanip> // for setprecision( int p )
#include <memory> // For auto_ptr
#include <sstream>
#include <vector>
#include <limits>
#include <cmath>

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/serialization/string.hpp>

#include <boost/filesystem/path.hpp> // For system independent path support
namespace bf = boost::filesystem;

void printVecVec( std::vector< std::vector<float> > &vec );
void printVec( std::vector<float> &vec );

bool readAUData( std::istream &is, std::vector< std::vector<float> > &vec );
bool readPredictions( std::istream &is, std::vector<float> &vec );
bool getOneAU( const std::vector< std::vector<float> > &data, std::vector<float> &auVec, unsigned int index );
bool getMultipleAUsMatrix( const std::vector< std::vector<float> > &data, Matrix2d &auVec, std::vector<unsigned int> indexes );

CPPUNIT_TEST_SUITE_REGISTRATION( GKR_Test );

GKR_Test::GKR_Test() : ID("AU 4"), model(ID)
{
}

/**
 */
void GKR_Test::setUp()
{
    std::vector< std::vector< float> > calAUs;
    std::ifstream ifs( "data/3.mov.cert.csv" );

    CPPUNIT_ASSERT( ifs.good() );
    CPPUNIT_ASSERT( readAUData( ifs, calAUs ) );

//    std::cout << "Read in " << calAUs.size() << " AU values." << std::endl;

    CPPUNIT_ASSERT( getOneAU( calAUs, au4, 3 ) );

    std::vector<unsigned int> poseIndexes;
    poseIndexes.push_back(25);
    poseIndexes.push_back(26);
    poseIndexes.push_back(27);
    CPPUNIT_ASSERT( getMultipleAUsMatrix( calAUs, poses, poseIndexes ) );

    CPPUNIT_ASSERT( model.train( au4, poses, 8 ) );
}

/**
 */
void GKR_Test::tearDown()
{
}

void GKR_Test::testPrediction()
{
//    GKR::Model model( "AU 4" );
//    CPPUNIT_ASSERT( model.train( au4, poses, 8 ) );
//    GKR::printMatrix( poses, "Poses" );
//    GKR::printMatrix( model.getC() );

    Matrix2d testData;
    int res = loadTestData( testData );
    CPPUNIT_ASSERT( 0 == res );
    model.predict( testData );

    // load the good predictions and compare
    std::ifstream ifsPred( "data/prediction.txt" );
    CPPUNIT_ASSERT( ifsPred.good() );

    std::vector<float> pred;
    const Matrix2d &modelPred = model.getPrediction();

    CPPUNIT_ASSERT( readPredictions( ifsPred, pred ) );
    CPPUNIT_ASSERT( pred.size() > 0 );
    CPPUNIT_ASSERT( pred.size() == modelPred.shape()[0] );

    float diff = 0;
    float total = 0;
    for( unsigned int i = 0; i < pred.size(); ++i )
    {
        diff += std::abs( pred[i] - modelPred[i][0] );
        total += std::abs( pred[i] );
    }

    CPPUNIT_ASSERT( (diff / total) < 0.001 );
}

std::string
GKR_Test::getTemporaryFilename()
{
    pid_t pid = getpid();
    std::ostringstream ost;

    ost << "/tmp/GKR_Test_serialization_" << pid << ".xml";
    return ost.str();
}

void GKR_Test::testSerialization()
{
//    std::string ID("AU 4");
//    GKR::Model model( ID );
//    CPPUNIT_ASSERT( model.train( au4, poses, 8 ) );

    // Serialize the model out to a file.
    std::string filename( getTemporaryFilename() );
    {
        std::ofstream ofs( filename.c_str() );
        CPPUNIT_ASSERT( ofs.good() );
        boost::archive::xml_oarchive xml(ofs);
        xml << boost::serialization::make_nvp( "GKR_Test", model );
    }

    // Then load it into a new model and compare
    GKR::Model newModel;
    {
        std::ifstream ifs( filename.c_str() );
        boost::archive::xml_iarchive xml(ifs);
        xml >> boost::serialization::make_nvp( "GKR_Test", newModel );
    }

    CPPUNIT_ASSERT( ID == newModel.getID() );
    CPPUNIT_ASSERT( model.getID() == newModel.getID() );
    CPPUNIT_ASSERT( model.getGmean() == newModel.getGmean() );
    CPPUNIT_ASSERT( model.getGsigma() == newModel.getGsigma() );
    CPPUNIT_ASSERT( model.getC() == newModel.getC() );
}

void GKR_Test::testCopy()
{
    GKR::Model emptyModel;
    GKR::Model newModel( model );

    CPPUNIT_ASSERT( ID == newModel.getID() );
    CPPUNIT_ASSERT( model.getID() == newModel.getID() );
    CPPUNIT_ASSERT( model.getGmean() == newModel.getGmean() );
    CPPUNIT_ASSERT( model.getGsigma() == newModel.getGsigma() );
    CPPUNIT_ASSERT( model.getC() == newModel.getC() );
    CPPUNIT_ASSERT( model == newModel ); // This should also be a good test of Model's operator==() method (two equal signs).

    // Now test operator= (one equal sign)
    emptyModel = model;
    CPPUNIT_ASSERT( ID == emptyModel.getID() );
    CPPUNIT_ASSERT( model.getID() == emptyModel.getID() );
    CPPUNIT_ASSERT( model.getGmean() == emptyModel.getGmean() );
    CPPUNIT_ASSERT( model.getGsigma() == emptyModel.getGsigma() );
    CPPUNIT_ASSERT( model.getC() == emptyModel.getC() );
    CPPUNIT_ASSERT( model == emptyModel );
}

void GKR_Test::testMap()
{
    GKR::Model emptyModel( ID );
    std::map< std::string, GKR::Model > modelMap;

    modelMap[ ID ] = emptyModel;
    CPPUNIT_ASSERT( ID == modelMap[ ID ].getID() );
}

int
GKR_Test::loadTestData( Matrix2d &testData )
{
    std::vector< std::vector< float> > testAUs;
    std::ifstream ifs( "data/4.mov.cert.csv" );

    if( !ifs.good() )
    {
        std::cerr << "Unable to open test data file." << std::endl;
        return 1;
    }

    if( !readAUData( ifs, testAUs ) )
    {
        std::cerr << "Unable to parse test data file." << std::endl;
        return 2;
    }


    std::vector<unsigned int> poseIndexes;
    poseIndexes.push_back(25);
    poseIndexes.push_back(26);
    poseIndexes.push_back(27);
    if( !getMultipleAUsMatrix( testAUs, testData, poseIndexes ) )
        std::cerr << "Unable to get poses from test data." << std::endl;

    return 0;
}

bool getOneAU( const std::vector< std::vector<float> > &data, std::vector<float> &auVec, unsigned int index )
{
    for( unsigned int line = 0; line < data.size(); ++line )
    {
        if( data[line].size() <= index )
            return false;
        auVec.push_back( data[line][index] );
    }
    return true;
}

bool getMultipleAUsMatrix( const std::vector< std::vector<float> > &data, Matrix2d &auVec, std::vector<unsigned int> indexes )
{
    auVec.resize( boost::extents[data.size()][indexes.size()] );
    for( unsigned int line = 0; line < data.size(); ++line )
    {
        for( unsigned int ind = 0; ind < indexes.size(); ++ind )
        {
            if( data[line].size() <= indexes[ind] )
                return false;

            auVec[line][ind] = data[line][indexes[ind]];
        }
    }
    return true;
}

// 1	-1.8112652	-1.4598047	0.64149712	-0.70318543	-1.0369882	0.023451995	-0.7214796	0.50358514	2.1211298	0.6452723	1.4662239	1.8760964e-10	1.9192059e-11	5.0226402e-12	2.0250189e-09	3.0184257e-09	1.2295038e-14	0.99999999	-3.6022999	-0.60837938	-2.7560404	-0.64246493	-3.5106335	-8.9779863	0.28557748	1.7431227	6.3912992	232	130	173	173	6	261.37271	133.12607	387.6142	143.97261	382.38412	277.65121	256.14264	266.80466	351.02087	182.15794	292.7821	177.16963	322.44897	215.01866	321.26157	247.20827
bool readAUData( std::istream &is, std::vector< std::vector<float> > &vec )
{
    while( !is.eof() )
    {
        std::string line;
        std::getline( is, line );

        if( line.length() > 0 )
        {
            std::stringstream str( line );
            std::vector<float> lineVals;

            do {
                float fval;
                int ival;
                std::string sval;

                if( str >> fval )
                {
                    lineVals.push_back( fval );
                }
                else if( str >> ival )
                {
                    lineVals.push_back( ival );
                }
                else if( str >> sval )
                {
                    if( "NA" == sval || "NAN" == sval || "NaN" == sval )
                    {
                        lineVals.push_back( std::numeric_limits<float>::quiet_NaN() );
                    }
                    else
                    {
                        std::cerr << "Non NaN string" << std::endl;
                        return false;
                    }
                }
                else
                {
                    // ??
                    std::cerr << "Unknown type when reading AU line: " << line << std::endl;
                    return false;
                }
            } while( !str.eof() );

            vec.push_back( lineVals );
        }
    }
    return true;
}

bool readPredictions( std::istream &is, std::vector<float> &vec )
{
    while( !is.eof() )
    {
        std::string line;
        std::getline( is, line );

        if( line.length() > 0 )
        {
            std::stringstream str( line );

            float fval;
            if( str >> fval )
            {
                vec.push_back( fval );
            }
            else
            {
                std::cerr << "Bad value in stream." << std::endl;
                return false;
            }
        }
    }
    return true;
}

void printVec( std::vector<float> &vec )
{
    for( unsigned int i = 0; i < vec.size(); ++i )
        std::cout << vec[i] << " ";
    std::cout << std::endl;
}

void printVecVec( std::vector< std::vector<float> > &vec )
{
    for( unsigned int i = 0; i < vec.size(); ++i )
    {
        std::cout << "   ";
        printVec( vec[i] );
    }
}