#ifndef SOIL_MOISTURE_IO_H
#define SOIL_MOISTURE_IO_H

#include <ostream>
#include <vector>
#include <map>
#include <map>
#include <memory>
#include <boost/asio/buffer.hpp>
#include <boost/optional.hpp>
#include <boost/lexical_cast.hpp>
#include <functional>

namespace trygvis {
namespace soil_moisture {

using namespace std;
using namespace boost::asio;

template<typename A>
using o = boost::optional<A>;

enum class sample_format_type {
    AUTO,
    CSV,
    JSON,
    SQL
};

string to_string(const sample_format_type &arg);

class SampleStreamParser;

class SampleOutputStream;

unique_ptr<SampleStreamParser> open_sample_input_stream(shared_ptr<SampleOutputStream> output, sample_format_type type = sample_format_type::AUTO);

unique_ptr<SampleOutputStream> open_sample_output_stream(sample_format_type type, unique_ptr<ostream> output,
        o<vector<string>> fields = o<vector<string>>());

class Sample {
public:
    Sample() : entries() {
    }

    Sample(map<string, string> entries) : entries(entries) {
    }

    map<string, string>::iterator find(string &s) {
        return entries.find(s);
    }

    map<string, string>::iterator begin() {
        return entries.begin();
    }

    map<string, string>::iterator end() {
        return entries.end();
    }

    /**
    * @throws std::out_of_range
    */
    inline const string &operator[](string key) {
        return at(key);
    }

    /**
    * @throws std::out_of_range
    */
    const string &at(string key) {
        return entries.at(key);
    }

    template<class A>
    const A lexical_at(string key) {
        return boost::lexical_cast<A>(entries.at(key));
    }

    void set(const std::string &key, const std::string &value) {
        entries[key] = value;
    }

private:
    map<string, string> entries;
};

class sample_exception : public runtime_error {
public:
    sample_exception(const string &what) : runtime_error(what) {
    }
};

class SampleOutputStream {
public:
    virtual void write(Sample sample) = 0;
};

class VectorSampleOutputStream : public SampleOutputStream {

public:
    virtual void write(Sample sample) override;

public:
    vector<Sample> samples;
};

class CsvSampleOutputStream : public SampleOutputStream {
public:
    CsvSampleOutputStream(unique_ptr<ostream> stream);

    CsvSampleOutputStream(unique_ptr<ostream> stream, vector<string> fields);

    void write(Sample values);

private:
    void writeHeader();

    unique_ptr<ostream> stream;
    bool headerWritten;
    bool filterFields;
    vector<string> fields;
};

class JsonSampleOutputStream : public SampleOutputStream {
public:
    JsonSampleOutputStream(unique_ptr<ostream> stream);

    JsonSampleOutputStream(unique_ptr<ostream> stream, vector<string> fields);

    void write(Sample values);

private:
    unique_ptr<ostream> stream;
    bool filterFields;
    vector<string> fields;
};

class SqlSampleOutputStream : public SampleOutputStream {
public:
    SqlSampleOutputStream(unique_ptr<ostream> stream, string table_name);

    SqlSampleOutputStream(unique_ptr<ostream> stream, string table_name, vector<string> fields);

    void write(Sample values);

private:
    unique_ptr<ostream> stream;
    bool filter_fields;
    vector<string> fields;
    const string table_name;
};

class SampleStreamParser {
public:
    virtual void process(mutable_buffers_1 buffer) = 0;

    virtual sample_format_type type() {
        return type_;
    }

protected:
    sample_format_type type_;

    SampleStreamParser(const sample_format_type type) : type_(type) {
    }
};

class CsvSampleParser : public SampleStreamParser {

public:
    CsvSampleParser(shared_ptr<SampleOutputStream> output) : SampleStreamParser(sample_format_type::CSV),
                                                       output(output), line(make_shared<vector<uint8_t>>()) {
    }

    void process(mutable_buffers_1 buffer) override;

private:
    void process_line(shared_ptr<vector<uint8_t>> packet);

    static const uint8_t packet_delimiter = '\n';
    shared_ptr<SampleOutputStream> output;
    shared_ptr<vector<uint8_t>> line;
};

class AutoSampleParser : public SampleStreamParser {
public:
    AutoSampleParser(shared_ptr<SampleOutputStream> output);

private:
    unique_ptr<SampleStreamParser> parser;
    unique_ptr<CsvSampleParser> csvParser;
public:
    virtual void process(mutable_buffers_1 buffer);
};

}
}

#endif