#include <vector>
#include <functional>
#include <iostream>
#include <algorithm>

template<class T>
struct trained {
    unsigned int id;
    T decider;
    
    double   monies;
    unsigned stock;

    double   result;
};

template <class T>
class trainer {
    std::vector< trained<T>* > trainees;
    std::function<T()> factory;

    unsigned int id;

public:
    double money;
    unsigned stock;

    trainer(double money, unsigned stock, std::size_t n, std::function<T()> factory) 
        : factory(factory), id(0), money(money), stock(stock)
    {
        add(n);
    }

    void add(std::size_t n, std::function<T()> factory)
    {
        for(std::size_t i = 0; i < n; i++) {
            trained<T> *trainee = new trained<T>();
            trainee->id = ++id;
            trainee->result = 0.0;
            trainee->decider = factory();

            trainees.push_back(trainee);
        }
    }

    void add(std::size_t n) 
    {
        add(n, factory);
    }

    void test(std::istream& input)
    {
        for (auto trainee : trainees) {
            trainee->monies = money;
            trainee->stock  = stock;

            trainee->decider.start_money = money;
            trainee->decider.start_stock = stock;
        }

        double price, start;
        input >> price;
        start = price*stock + money;

        do {
            for (auto trainee : trainees) {
                auto decision   = trainee->decider.decide(price, trainee->monies, trainee->stock);
                auto current    = price*trainee->stock + trainee->monies;
                auto max_credit = std::max(current * 0.05, -1e4);

                /* std::cout << "D: " << decision << " C: " << current << " P: " << price << " MC: " << max_credit << std::endl; */ 
                if (decision > 0 && trainee->monies - decision*price < -max_credit) {
                    decision = floor((trainee->monies + max_credit) / price);
                }

                if (decision < 0 && -decision > trainee->stock) {
                    decision = -trainee->stock;
                }

                trainee->stock  += decision;
                trainee->monies -= price*decision;
            }
        } while (input >> price);

        auto hodl = price * stock + money;
        std::cout << "Zakonczono testy " << trainees.size() << " przypadkow." << std::endl;
        std::cout << "HODL: " << hodl << " START: " << start << std::endl;
        std::cout << "-----------------------" << std::endl;

        std::sort(trainees.begin(), trainees.end(), [=](trained<T> *a, trained<T> *b){
            return (a->monies + a->stock * price) > (b->monies + b->stock * price);
        });

        for (auto trainee : trainees) {
            auto earned = trainee->monies + trainee->stock * price;
            std::cout << "#" << trainee->id << ": " << earned << " [" << earned - hodl << "] " << trainee->stock << " akcji, " << trainee->monies << " gelda w banku. " << std::endl; 
        }
    }
};