#include <iostream>
#include <array>
#include <string>

#include "NeuronsNetworkBase.h"

using data_item = std::array<double, 7>;

class TitanicAI : public NeuronsNetworkBase<data_item>
{
    constexpr static size_t count_neurons = 6;
protected:
    double activation(double x) override
    {
        return 1/(1+exp(-x));
    }
    
public:
    TitanicAI() : NeuronsNetworkBase(count_neurons, 0.01)
    {}
    
    double call(const data_item& data) override
    {
        double sum = 0;
        for (size_t i = 0; i < count_neurons; ++i)
        {
            sum += (*this)[i] * data[i + 1];
        }
        
        return activation(sum);
    }

    void train(double error, const data_item& data) override
    {
        for (size_t i = 0; i < count_neurons; ++i)
        {
            (*this)[i] += get_rate_train() * error * data[i + 1];
        }
    }
    
    void print_masses()
    {
        for (size_t i = 0; i < count_neurons; ++i)
        {
            std::cout << (*this)[i] << " ";
        }
        std::cout << "\n";
    }
};

constexpr size_t count_train_items = 700;
std::vector<data_item> train_data;

int main(int argc, char* argv[])
{
    TitanicAI ai;
    std::ifstream file("train.txt");
    
    while (file.eof() == false)
    {
        data_item item{};
        
        std::string vec;
        file >> vec;
        if (vec.empty() == false)
            item[0] = std::stod(vec);
        file >> vec;
        if (vec.empty() == false)
            item[1] = std::stod(vec);
        file >> vec;
        if (vec.empty() == false)
            item[2] = std::stod(vec);
        file >> vec;
        if (vec.empty() == false)
            item[3] = std::stod(vec);
        file >> vec;
        if (vec.empty() == false)
            item[4] = std::stod(vec);
        file >> vec;
        if (vec.empty() == false)
            item[5] = std::stod(vec);
        if (vec.empty() == false)
            item[6] = std::stod(vec);
        
        train_data.push_back(item);
    }
    
    for (size_t i = 0; i < count_train_items; ++i)
    {
        ai.train(train_data[i][0] - ai.call(train_data[i]), train_data[i]);
    }
    
    size_t score = 0;
    const size_t max_score = train_data.size() - count_train_items;
    constexpr double delta = 0.001;
    for (size_t i = count_train_items + 1; i < train_data.size(); ++i)
    {
        double activate_result = ai.call(train_data[i]);
        bool is_dead =  activate_result + delta > 0.5;
        if (is_dead == static_cast<bool>(train_data[i][0]))
            ++score;
    }
    
    std::cout << "Accuracy: " << score << '/' << max_score << " (float: " << (static_cast<double>(score) / static_cast<double>(max_score)) << ")\n";
    std::cout << "Masses: "; ai.print_masses();
    
    return 0;
}