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

namespace trygvis {
namespace apps {

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

class sample_select : public app {
private:
    string fields;

public:
    sample_select() : app("sample-select") {}

    ~sample_select() = default;

    void add_options(po::options_description_easy_init &options) override {
        options("fields", po::value<string>(&fields)->required());
    }

    int main(app_execution &execution) override {
        tokenizer<> tok(fields);

        for (tokenizer<>::iterator beg = tok.begin(); beg != tok.end(); ++beg) {
            cout << *beg << "\n";
        }

        /*
        KeyDictionary dict;

        relative_key = dict.indexOf(relative_name);

        auto sample_buffer = make_shared<VectorSampleOutputStream>();
        auto parser = open_sample_input_stream(sample_buffer, dict);
        while (!input.fail()) {
            char buffer[buffer_size];
            input.read(buffer, buffer_size);
            auto count = (size_t) input.gcount();

            cerr << "eof? " << input.eof() << endl;
            mutable_buffers_1 b = boost::asio::buffer(buffer, count);
            parser->process(b);
        }

        if (sample_buffer->samples.empty()) {
            cerr << "Could not find any samples" << endl;
            return EXIT_FAILURE;
        }

        time_t end_time = buf.st_mtim.tv_sec;

        SampleRecord sample = *--sample_buffer->samples.end();

        o<string> s = sample.at(relative_key);
        if (!s) {
            cerr << "Missing key '" + relative_name + "'." << endl;
            cerr << "Found " << sample_buffer->samples.size() << " samples." << endl;
            cerr << "keys: " << sample.to_string() << endl;
            return EXIT_FAILURE;
        }

        long relative;
        try {
            relative = boost::lexical_cast<long>(s.get());
        } catch (const boost::bad_lexical_cast &e) {
            cerr << "Bad integer value '" + s.get() + "'." << endl;
            return EXIT_FAILURE;
        }

        if (relative_resolution == time_resolution::MILLISECONDS) {
            relative /= 1000;
        }

        time_t start_time = end_time - relative;
        cerr << "end_time   " << end_time << endl;
        cerr << "relative        " << relative << endl;
        cerr << "start_time " << start_time << endl;

        // Restart the reading of the input file and add the adjusted timestamp
        input.clear(ios::eofbit);
        input.seekg(0);
        if(input.fail()) {
            cerr << "Coult not seek input file" << endl;
            return EXIT_FAILURE;
        }

        vector<sample_output_stream_option*> options = {};
        unique_ptr<SampleConsumer> unique_output_stream = open_sample_writer(shared_ptr<ostream>(&cout,
        noop_deleter), dict, parser->type(), options);
        shared_ptr<SampleConsumer> output_stream{std::move(unique_output_stream)};
        shared_ptr<SampleConsumer> p = make_shared<TimestampFixingSampleOutputStream>(output_stream, dict,
        timestamp_name, relative_name, relative_resolution, start_time);
        parser = open_sample_stream_parser(p, dict, parser->type());

        int recordCount = 0;

        while (!input.eof()) {
            char buffer[buffer_size];
            input.read(buffer, buffer_size);
            size_t gcount = (size_t)input.gcount();

            recordCount++;

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

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

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