//
// Created by martin on 7/13/18.
//

#include <iostream>
#include <fstream>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

#include "DataSet.h"

InvalidDimension::InvalidDimension() : std::runtime_error("Invalid dimension specified!") {};

InvalidDimension::InvalidDimension(std::string msg) : std::runtime_error(msg.c_str()) {};

DataSet::DataSet(std::string file_path) {
    std::ifstream ifs (file_path);
    boost::archive::text_iarchive ia(ifs);
    ia >> *this;
    ifs.close();
}

DataSet::DataSet(std::vector<std::pair<std::vector<double>, std::vector<double>>> *data_ptr) {
    this->n_elements = data_ptr->size();
    this->data = *data_ptr;

    this->input_dim = std::get<0>(this->data[0]).size();
    this->output_dim = std::get<1>(this->data[0]).size();

    //TODO check the complete data set for input/output dimensions
}

DataSet::DataSet(double lower_bound, double upper_bound, unsigned int size, double output) {
    std::vector<std::pair<std::vector<double>, std::vector<double>>> new_data_vec;
    this->data = new_data_vec;
    this->n_elements = size;
    this->input_dim = 1;
    this->output_dim = 1;

    this->add_isotropic_data(lower_bound, upper_bound, size, output);
}

void DataSet::add_data_pair(std::vector<double> inputs, std::vector<double> outputs) {
    if(inputs.size() != this->input_dim) {
        throw InvalidDimension("Bad input dimension.");
    } else if(outputs.size() != this->output_dim) {
        throw InvalidDimension("Bad output dimension.");
    }

    this->n_elements++;
    this->data.emplace_back(std::make_pair(inputs, outputs));
}

void DataSet::add_isotropic_data(double lower_bound, double upper_bound, unsigned int size, double output) {
    if(this->input_dim != 1 || this->output_dim != 1) {
        throw InvalidDimension("Cannot add data with dimensionality 1:1 when the data set "
                               "is of different dimensionality!");
    }

    double frac = (upper_bound - lower_bound) / (size - 1);
    std::vector<double> inp, out;

    out = {output};

    for(unsigned int i = 0; i < size; ++i){
        inp = {frac*i};
        this->data.emplace_back(std::make_pair(inp, out));
    }
}

std::vector<std::pair<std::vector<double>, std::vector<double>>>* DataSet::get_data() {
    return &(this->data);
}

size_t DataSet::get_n_elements() {
    return this->n_elements;
}

unsigned int DataSet::get_input_dim() {
    return this->input_dim;
}

unsigned int DataSet::get_output_dim() {
    return this->output_dim;
}

void DataSet::print_data() {
    if (n_elements) {
        for (auto p : this->data) {
            /* INPUT */
            for (auto v : std::get<0>(p)) {
                std::cout << v << " ";
            }

            std::cout << "-> ";

            /* OUTPUT */
            for (auto v : std::get<1>(p)) {
                std::cout << v << " ";
            }

            std::cout << std::endl;
        }
    }
}

void DataSet::store_text(std::string file_path) {
    //TODO check if stream was successfully opened
    std::ofstream ofs(file_path);
    boost::archive::text_oarchive oa(ofs);
    oa << *this;
    ofs.close();
}