#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.0000001)
    {}
    
    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";
    }
};

void test(TitanicAI& ai)
{
    std::ifstream file("test.txt");
    std::vector<data_item> test_data;

    data_item item;
    while (file >> item[0] >> item[1] >> item[2] >> item[3] >> item[4] >> item[5] >> item[6])
    {
        test_data.push_back(item);
    }
    
    std::ofstream answer("answer.txt");
    
    answer << "PassengerId,Survived\n";
    for (auto& i : test_data)
    {
        answer << static_cast<int>(i[0]) << ',' << (ai.call(i) > 0.5) << '\n';
    }
}

int main(int argc, char* argv[])
{
    TitanicAI ai;
    std::ifstream file("train.txt");
    
    std::vector<data_item> train_data;
    data_item item;
    while (file >> item[0] >> item[1] >> item[2] >> item[3] >> item[4] >> item[5] >> item[6])
    {
        train_data.push_back(item);
    }
    file.close();
    
    for (auto& i : train_data)
    {
        ai.train(i[0] - ai.call(i), i);
    }
    
    size_t score = 0;
    const size_t max_score = train_data.size();
    for (auto& i : train_data)
    {
        constexpr double delta = 0.001;
        double activate_result = ai.call(i);
        bool is_dead =  activate_result + delta > 0.5;
        if (is_dead == static_cast<bool>(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();
    
    test(ai);
    
    return 0;
}