#include <iostream>
#include <functional>
#include <math.h>
#include <typeinfo>
#include <random>
#include <ctime> 
#include <algorithm>
#include <fstream>
#include <vector>
#include <map>

#include "argh.h"
#include "matrix.h"
#include "network.h"
#include "decider.h"
#include "trainer.h"
#include "common.h"

int main(int argc, char* argv[])
{
    argh::parser args;
    args.add_params({"-m", "--money"});
    args.add_params({"-s", "--stock"});
    args.add_params({"-p", "--population"});
    args.add_params({"-n", "--iterations"});
    args.add_params({"-o", "--output-dir"});
    args.add_params({"-s", "--samples"});

    args.parse(argc, argv);

    double   money;
    unsigned stock, population, iterations, sampling;
    std::string input_file, output_dir;

    args({ "m", "money" }, 1000.)   >> money;
    args({ "s", "stock" }, 1000)    >> stock;
    args({ "p", "population" }, 25) >> population;
    args({ "n", "iterations" }, 4)  >> iterations;
    args({ "s", "samples" }, 0)     >> sampling;
    args({ "o", "output-dir" }, "") >> output_dir;

    std::uniform_real_distribution<double> distribution(-2.0, 2.0);
    std::uniform_real_distribution<double> bias_distribution(-16.0, 16.0);

    std::random_device rd;
    std::mt19937 random_engine(rd());

    std::function<double(const int&, const int&)> randomizer = [&](const int&, const int&) -> double {
        return distribution(random_engine);
    };

    std::function<double(const int&, const int&)> bias_randomizer = [&](const int&, const int&) -> double {
        return distribution(random_engine);
    };

    std::function<double(const double&)> normalizer = [](const double& result) -> double { return result / (1 + abs(result)); };

    std::function<current_decider ()> factory = [&]() -> current_decider {
        current_decider decider(normalizer);
        decider.network.fill(randomizer, bias_randomizer);

        return decider;
    };

    trainer<current_decider> train(money, stock, population, factory);
    std::fstream input;
    std::map<std::string, trainer<current_decider>::dataset> datasets;
    for (auto it = args.begin() + 1; it != args.end(); it++) {
        std::string filename = *it;
        std::ifstream file;
        file.open(filename);
        if (!file.is_open()) continue;

        trainer<current_decider>::dataset set;
        double price;
        while (file >> price) set.push_back(price);

        datasets[filename] = set;

        if (sampling) {
            trainer<current_decider>::dataset sample;
          
            int i = 1;
            for(double price : set) {
                sample.push_back(price);
                if (i % sampling == 0) {
                    std::stringstream stream;
                    stream << filename << "-" << i;

                    datasets[stream.str()] = sample;
                    sample = trainer<current_decider>::dataset();
                    std::cout << "Probka " << stream.str() << std::endl;
                }
                i++;
            }
        }

        file.close();
        std::cout << "Zaladowano zestaw testowy " << filename << " z " << set.size() << " wartosciami." << std::endl;
    }

    if (datasets.size() == 0) {
        std::cout << "Brak poprawnie zaladowanych zestawow testowych." << std::endl;
        return -1;
    }

    std::cout << "generation,score_med,score_high,profit_med,profit_high,best" << std::endl;
    while (train.generation <= iterations) {
        train.evolve();
        for (auto pair : datasets) {
            train.train(pair.second, pair.first);
        }
        train.sort();
        std::cout 
            << train.generation << ","
            << train.population()[population / 2]->score << ","
            << train.population()[0]->score << ","
            << train.population()[population / 2]->profit << ","
            << train.population()[0]->profit << ","
            << train.population()[0]->id
            << std::endl;
    }

    if (!output_dir.empty()) {
        int i = 0;
        for (auto trained : train.population()) {
        std::stringstream stream;
            stream << output_dir << ++i << ".net";
            std::string filename = stream.str();

            std::cout << "Zapisuje siec #" << trained->id << " do pliku " << filename << std::endl;

            std::ofstream file(filename, std::ios::out | std::ios::binary);
            trained->decider.save(file);
            file.close();
        }
    }
}