#include "trygvis/sensor.h"
#include "trygvis/sensor/io.h"
#include "apps.h"
#include <fstream>
#include <boost/tokenizer.hpp>
#include "apps.h"

namespace trygvis {
namespace apps {

using namespace std;
using namespace trygvis::apps;
using namespace trygvis::sensor;
using namespace trygvis::sensor::io;
using boost::tokenizer;
namespace po = boost::program_options;

class sample_convert : public app {
private:
    string fields;
    string timestamp_field;
    bool add_timestamp;
    string input_file, output_file;
    sample_format_type output_format;

    string table_name;

public:
    sample_convert() : app("sample-convert") {}

    ~sample_convert() = default;

    void add_options(po::options_description_easy_init &options) override {
        options("input", po::value<string>(&input_file)->default_value("-"));
        // ("input-format", po::value<string>(&input_format)->default_value("csv"))
        options("output", po::value<string>(&output_file)->default_value("-"));
        options("output-format",
                po::value<sample_format_type>(&output_format)->default_value(sample_format_type::KEY_VALUE));
        options("fields", po::value<string>(&fields));
        options("add-timestamp", po::value<bool>(&add_timestamp)->default_value(true));
        options("timestamp-field", po::value<string>(&timestamp_field)->default_value("timestamp"));
    }

    void add_extra_options(po::options_description &all_options) override {
        po::options_description sql("SQL");
        sql.add_options()("table-name", po::value<string>(&table_name));

        all_options.add(sql);
    };

    int main(app_execution &execution) override {
        auto desc = execution.desc;
        auto vm = execution.vm;

        KeyDictionary dict;

        istream *inputStream;
        if (input_file == "-") {
            inputStream = &cin;
        } else {
            inputStream = new ifstream(input_file);
            if (inputStream->fail()) {
                cerr << "Unable to open input file " << input_file << endl;
                return EXIT_FAILURE;
            }
        }

        shared_ptr<ostream> outputStream;
        if (output_file == "-") {
            outputStream = shared_ptr<ostream>(&cout, noop_deleter);
        } else {
            outputStream = make_shared<ofstream>(output_file);
            if (outputStream->fail()) {
                cerr << "Unable to open output file " << output_file << endl;
                return EXIT_FAILURE;
            }
        }

        sample_output_stream_options options;
        trygvis::sensor::io::timestamp_field_option tf(timestamp_field);

        options.push_back(&tf);

        table_name_option tno(table_name);
        if (table_name != "") {
            options.push_back(&tno);
        }

        tokenizer<> tok(fields);
        output_fields_option fs;
        std::copy(tok.begin(), tok.end(), std::back_inserter(fs.fields));
        if (!fs.fields.empty()) {
            options.push_back(&fs);
        }

        unique_ptr<SampleConsumer> o = open_sample_writer(outputStream, dict, output_format, options);

        if (add_timestamp) {
            o = make_unique<AddTimestampSampleConsumer>(move(o), dict, timestamp_field);
        }

        shared_ptr<SampleConsumer> output(move(o));

        auto input = make_shared<KeyValueSampleStreamParser>(output, dict);

        char data[100];
        while (!inputStream->eof()) {
            inputStream->get(data[0]);
            auto buf = boost::asio::buffer(data, 1);
            input->process(buf);
        }

        return EXIT_SUCCESS;
    }
};
}
}

int main(int argc, const char *argv[]) {
    using namespace trygvis::apps;

    return real_main(new sample_convert(), argc, argv);
}