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

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

using current_decider = neural_decider<24, 12, 12, 32, 16>;

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.parse(argc, argv);

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

    args({ "m", "money" }, 1000.)   >> money;
    args({ "s", "stock" }, 1000)    >> stock;
    args({ "p", "population" }, 25) >> population;
    args({ "n", "iterations" }, 4)  >> iterations;
    args(1) >> input_file;

    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;

    //
    // Engines 
    //
    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 erf(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;
    input.open(input_file);

    for (int i = 0; i < iterations; i++) {
        input.clear();
        input.seekg(0);

        train.test(input);
    }

    input.clear();
    input.seekg(0);

    train.see_best(input);
}