#include "FileReader.h"
#include <iostream>

#include "filter/Structs.h"
#include "Plotti.h"

#include <chrono>

#include "filter/Logic.h"

#include <Indoor/floorplan/v2/Floorplan.h>
#include <Indoor/floorplan/v2/FloorplanReader.h>

#include <Indoor/grid/factory/v2/GridFactory.h>
#include <Indoor/grid/factory/v2/Importance.h>

#include <Indoor/geo/Point2.h>


#include <KLib/math/statistics/Statistics.h>

#include <Indoor/sensors/imu/TurnDetection.h>
#include <Indoor/sensors/imu/StepDetection.h>
#include <Indoor/sensors/pressure/RelativePressure.h>
#include <Indoor/sensors/radio/WiFiGridEstimator.h>
#include <Indoor/sensors/beacon/model/BeaconModelLogDistCeiling.h>

#include <Indoor/math/MovingAVG.h>
#include <Indoor/math/FixedFrequencyInterpolator.h>
#include <Indoor/data/Timestamp.h>

#include "Settings.h"

#include <KLib/math/filter/particles/ParticleFilter.h>
#include <KLib/math/filter/particles/ParticleFilterHistory.h>
#include <KLib/math/filter/particles/ParticleFilterInitializer.h>

#include <KLib/math/filter/particles/estimation/ParticleFilterEstimationWeightedAverage.h>
#include <KLib/math/filter/particles/estimation/ParticleFilterEstimationRegionalWeightedAverage.h>
#include <KLib/math/filter/particles/estimation/ParticleFilterEstimationOrderedWeightedAverage.h>
#include <KLib/math/filter/particles/estimation/ParticleFilterEstimationKernelDensity.h>

#include <KLib/math/filter/particles/resampling/ParticleFilterResamplingSimple.h>
#include <KLib/math/filter/particles/resampling/ParticleFilterResamplingPercent.h>


#include <Indoor/geo/Heading.h>

//frank
//const std::string mapDir = "/mnt/data/workspaces/IPIN2016/IPIN2016/competition/maps/";
//const std::string dataDir = "/mnt/data/workspaces/IPIN2016/IPIN2016/competition/src/data/";

//toni
const std::string mapDir = "/home/toni/Documents/programme/localization/russenJournal/russen/map/";
const std::string dataDir = "/home/toni/Documents/programme/localization/russenJournal/russen/data/";
const std::string errorDir = dataDir  + "results/";

/** describes one dataset (map, training, parameter-estimation, ...) */
struct DataSetup {
	std::string map;
	std::vector<std::string> training;
	std::string wifiParams;
	int minWifiOccurences;
	VAPGrouper::Mode vapMode;
    int buildingNum;
};

/** all configured datasets */
struct Data {

    DataSetup SHL = {

        mapDir + "SHL/SHL25.xml",

        {
            dataDir + "bergwerk/path1/nexus/vor/1454775984079.csv",
            dataDir + "bergwerk/path1/galaxy/vor/1454776168794.csv",
            dataDir + "bergwerk/path2/nexus/vor/1454779863041.csv",
            dataDir + "bergwerk/path2/galaxy/vor/1454780113404.csv",
            dataDir + "bergwerk/path3/nexus/vor/1454782562231.csv",
            dataDir + "bergwerk/path3/galaxy/vor/1454782896548.csv",
            dataDir + "bergwerk/path4/nexus/vor/1454776525797.csv",
            dataDir + "bergwerk/path4/galaxy/vor/1454779020844.csv"
        },

        dataDir + "bergwerk/wifiParams.txt",
        40,
        VAPGrouper::Mode::LAST_MAC_DIGIT_TO_ZERO,
        10
    };

} data;


Floorplan::IndoorMap* MyState::map;

void run(DataSetup setup, int numFile, std::string folder) {

    // load the floorplan
    Floorplan::IndoorMap* map = Floorplan::Reader::readFromFile(setup.map);
    MyState::map = map;

    WiFiModelLogDistCeiling WiFiModel(map);
    WiFiModel.loadAPs(map, Settings::WiFiModel::TXP, Settings::WiFiModel::EXP, Settings::WiFiModel::WAF);
    Assert::isFalse(WiFiModel.getAllAPs().empty(), "no AccessPoints stored within the map.xml");

    BeaconModelLogDistCeiling beaconModel(map);
    BeaconModelLogDistCeiling::APEntry beacon1(Point3(69.84f,45.26f,3.8f+3.4f+1.2f),-81,Settings::BeaconModel::EXP, Settings::BeaconModel::WAF);
    beaconModel.addBeacon(MACAddress("48:EF:8D:77:66:DF"), beacon1);

    BeaconModelLogDistCeiling::APEntry beacon2(Point3(69.84f,45.26f,3.8f+3.4f+1.2f),-81,Settings::BeaconModel::EXP, Settings::BeaconModel::WAF);
    beaconModel.addBeacon(MACAddress("6F:5F:39:0C:51:E4"), beacon2);

    BeaconModelLogDistCeiling::APEntry beacon3(Point3(69.84f,45.26f,3.8f+3.4f+1.2f),-81,Settings::BeaconModel::EXP, Settings::BeaconModel::WAF);
    beaconModel.addBeacon(MACAddress("49:23:D8:7F:E8:D2"), beacon3);

    //beaconModel.loadBeaconsFromMap(map, Settings::WiFiModel::TXP, Settings::WiFiModel::EXP, Settings::WiFiModel::WAF);
    Assert::isFalse(beaconModel.getAllBeacons().empty(), "no AccessPoints stored within the map.xml");

    // build the grid
    Grid<MyNode> grid(20);
    GridFactory<MyNode> factory(grid);
    factory.build(map);

    // add node-importance
    Importance::addImportance(grid);

    // stamp WiFi signal-strengths onto the grid
    WiFiGridEstimator::estimate(grid, WiFiModel, Settings::smartphoneAboveGround);


    // reading file
    FileReader fr(setup.training[numFile]);

    //std::vector<int> gt;

    // doing ground truth stuff
    //fr.getGroundTruthPath(map, gt_1);


    Plotti plot;
    plot.addFloors(map);
    plot.addOutline(map);
    plot.addStairs(map);
    plot.gp << "set autoscale xy\n";
    //plot.addGrid(grid);


    // init ctrl and observation
    MyControl ctrl;
    ctrl.resetAfterTransition();
    MyObs obs;

    int numParticles = 5000;

    PFEval* eval = new PFEval(WiFiModel, beaconModel, grid);

    //filter init
    //std::unique_ptr<PFInit> init =
    K::ParticleFilterHistory<MyState, MyControl, MyObs> pf(numParticles, std::unique_ptr<PFInit>(new PFInit(grid)));
    pf.setTransition(std::unique_ptr<PFTrans>(new PFTrans(grid, &ctrl)));
    pf.setEvaluation(std::unique_ptr<PFEval>(eval));

    //resampling
    //pf.setResampling(std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()));
    pf.setResampling(std::unique_ptr<K::ParticleFilterResamplingPercent<MyState>>(new K::ParticleFilterResamplingPercent<MyState>(0.04)));
    pf.setNEffThreshold(0.85);

    //estimation
    //pf.setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
    //pf.setEstimation(std::unique_ptr<K::ParticleFilterEstimationRegionalWeightedAverage<MyState>>(new K::ParticleFilterEstimationRegionalWeightedAverage<MyState>()));
    pf.setEstimation(std::unique_ptr<K::ParticleFilterEstimationOrderedWeightedAverage<MyState>>(new K::ParticleFilterEstimationOrderedWeightedAverage<MyState>(0.95)));
    //pf.setEstimation(std::unique_ptr<K::ParticleFilterEstimationKernelDensity<MyState, 3>>(new K::ParticleFilterEstimationKernelDensity<MyState, 3>()));


    Timestamp lastTimestamp = Timestamp::fromMS(0);

    StepDetection sd;
    TurnDetection td;
    RelativePressure relBaro;	relBaro.setCalibrationTimeframe( Timestamp::fromMS(5000) );

    K::Statistics<float> errorStats;

    //file writing for offline competition
    long int t = static_cast<long int>(time(NULL));
    std::ofstream errorFile;
    errorFile.open (errorDir +  folder + "/error_" + std::to_string(numFile) + "_" + std::to_string(t) + ".csv");

    // parse each sensor-value within the offline data
    for (const FileReader::Entry& e : fr.getEntries()) {

        const Timestamp ts = Timestamp::fromMS(e.ts);

        if (e.type == FileReader::Sensor::WIFI) {
            obs.wifi = fr.getWiFiGroupedByTime()[e.idx].data;

        } else if (e.type == FileReader::Sensor::BEACON){
            obs.beacons.entries.push_back(fr.getBeacons()[e.idx].data);

            // remove to old beacon measurements
            obs.beacons.removeOld(ts);

        } else if (e.type == FileReader::Sensor::ACC) {
            if (sd.add(ts, fr.getAccelerometer()[e.idx].data)) {
                ++ctrl.numStepsSinceLastTransition;
            }
            const FileReader::TS<AccelerometerData>& _acc = fr.getAccelerometer()[e.idx];
            td.addAccelerometer(ts, _acc.data);

        } else if (e.type == FileReader::Sensor::GYRO) {
            const FileReader::TS<GyroscopeData>& _gyr = fr.getGyroscope()[e.idx];
            const float delta = td.addGyroscope(ts, _gyr.data);
            ctrl.turnSinceLastTransition_rad += delta;

        } else if (e.type == FileReader::Sensor::BARO) {
            relBaro.add(ts, fr.getBarometer()[e.idx].data);
            obs.relativePressure = relBaro.getPressureRealtiveToStart();
            obs.sigmaPressure = relBaro.getSigma();
        }

        if (ts.ms() -  lastTimestamp.ms() > 500) {

            obs.currentTime = ts;

            MyState est = pf.update(&ctrl, obs);
            Point3 estPos = est.position.inMeter();

            plot.pInterest.clear();

            // plotting stuff
            static float angleSum = 0; angleSum += ctrl.turnSinceLastTransition_rad;
            //plot.showAngle(1, ctrl.turnAngle);
            plot.showAngle(2, angleSum + M_PI);

            //plot.debugWiFi(eval->model, obs.wifis, obs.curTS);
            //plot.debugProb(grid, std::bind(&PFEval::getGPS, eval, std::placeholders::_1, std::placeholders::_2), obs);
            //plot.debugProb(grid, std::bind(&PFEval::getWIFI, eval, std::placeholders::_1, std::placeholders::_2), obs);
            //plot.debugProb(grid, std::bind(&PFEval::getALL, eval, std::placeholders::_1, std::placeholders::_2), obs);

            plot.setEst(estPos);
            //plot.setGT(mapPos);
            plot.addEstimationNode(estPos);
            plot.addParticles(pf.getParticles());
            //plot.gp << "set arrow 919 from " << tt.pos.x << "," << tt.pos.y << "," << tt.pos.z << " to "<< tt.pos.x << "," << tt.pos.y << "," << tt.pos.z+1 << "lw 3\n";

            //plot.gp << "set label 1001 at screen 0.02, 0.98 'base:" << relBaro.getBaseAvg() << " sigma:" << relBaro.getSigma() << " cur:" << relBaro.getPressureRealtiveToStart() << " hPa " << -relBaro.getPressureRealtiveToStart()/0.10/4.0f << " floor'\n";
            int minutes = static_cast<int>(ts.sec()) / 60;
            plot.gp << "set label 1002 at screen 0.02, 0.94 'Time: " << minutes << ":" << static_cast<int>(static_cast<int>(ts.sec())%60) << "'\n";
            //plot.gp << "set label 1002 at screen 0.98, 0.98 'act:" <<  ctrl.barometer.act << "'\n";

            // error between GT and estimation
            //float err_m = mapPos.getDistance(estPos);
           // errorStats.add(err_m);
            //errorFile << err_m << "\n";

            plot.show();
            usleep(100*10);


            lastTimestamp = ts;

            // reset control
            ctrl.resetAfterTransition();
        }

    }

    errorFile.close();

    //Write the current plotti buffer into file
    std::ofstream plotFile;
    plotFile.open(errorDir + std::to_string(numFile) + "_" + std::to_string(t) + ".gp");
    plot.saveToFile(plotFile);
    plotFile.close();

//    for(int i = 0; i < map->floors.size(); ++i){
//        plot.printSingleFloor("/home/toni/Documents/programme/localization/IPIN2016/competition/eval/"+ folder + "/image" + std::to_string(numFile) + "_" + std::to_string(t), i);
//        plot.show();
//        usleep(1000*10);
//    }

//    plot.printSideView("/home/toni/Documents/programme/localization/IPIN2016/competition/eval/"+ folder + "/image" + std::to_string(numFile) + "_" + std::to_string(t), 90);
//    plot.show();

//    plot.printSideView("/home/toni/Documents/programme/localization/IPIN2016/competition/eval/"+ folder + "/image" + std::to_string(numFile) + "_" + std::to_string(t), 0);
//    plot.show();

//    plot.printOverview("/home/toni/Documents/programme/localization/IPIN2016/competition/eval/"+ folder + "/image" + std::to_string(numFile) + "_" + std::to_string(t));
//    plot.show();

    sleep(1);

}

int main(int argc, char** argv) {

    //Testing files
    run(data.SHL, 6, "EVAL");    // Nexus vor


}