#include "trygvis/sensor.h"
#include "trygvis/sensor/io.h"
#include "apps.h"

namespace trygvis {
namespace apps {

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

class TimestampAddingSampleOutputStream : public SampleConsumer {
public:
    TimestampAddingSampleOutputStream(shared_ptr<SampleConsumer> output, KeyDictionary &dict,
                                      time_resolution resolution, string timestamp_name) :
            output_(output), resolution_(resolution), timestamp_key(dict.indexOf(timestamp_name)) {
        if (resolution_ == time_resolution::MILLISECONDS) {
            factor = 1000;
        } else {
            factor = 1;
        }
    }

    virtual void onSample(const SampleRecord &sample) override {
        time_t now = time(NULL) * factor;

        SampleRecord updated_sample(sample);

        updated_sample.set(timestamp_key, std::to_string(now));

        output_->onSample(updated_sample);
    };

private:
    const SampleKey *timestamp_key;
    const time_resolution resolution_;
    int factor;
    shared_ptr<SampleConsumer> output_;
};

class sample_add_timestamp : public app {
private:
    string timestamp_name;
    time_resolution resolution;
    sample_format_type output_format;

public:
    sample_add_timestamp() : app("sample-add-timestamp") {}

    ~sample_add_timestamp() = default;

    void add_options(po::options_description_easy_init &options) override {
        options("resolution", po::value<time_resolution>(&resolution)->default_value(time_resolution::SECONDS));
        options("timestamp-name", po::value<string>(&timestamp_name)->default_value("timestamp"));
        options("output-format",
                po::value<sample_format_type>(&output_format)->default_value(sample_format_type::KEY_VALUE));
    }

    const int buffer_size = 1024;

    int main(app_execution &execution) override {

        auto out = shared_ptr<ostream>(&cout, noop_deleter);

        KeyDictionary dict;
        sample_output_stream_options options = {};
        auto writer = open_sample_writer(out, dict, output_format, options);
        auto p = make_shared<TimestampAddingSampleOutputStream>(std::move(writer), dict, resolution, timestamp_name);
        auto parser = open_sample_stream_parser(p, dict);

        int recordCount = 0;

        auto in = shared_ptr<istream>(&cin, noop_deleter);
//        in->rdbuf(nullptr);

        while (!in->eof()) {
            char buffer[buffer_size];
            in->read(buffer, buffer_size);
            auto gcount = static_cast<size_t>(in->gcount());

            recordCount++;

            mutable_buffers_1 b = boost::asio::buffer(buffer, gcount);
            parser->process(b);
        }

        out->flush();

        return EXIT_SUCCESS;
    };
};
}
}

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

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