#include <cstdlib>
#include <iostream>
#include <boost/filesystem.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/chrono.hpp>
#include <string>
#include <chrono>

auto tp_alarm = std::chrono::steady_clock::now();
auto duration_display = std::chrono::milliseconds(0);
auto duration_display_interval = std::chrono::milliseconds(500);
bool duration_display_toggle = false;

// io_service for timer
boost::asio::io_service io_service;
boost::asio::steady_timer timer_alarm(io_service);
boost::asio::steady_timer timer_display(io_service);

void handle_timer_alarm(const boost::system::error_code& error);
void handle_timer_display(const boost::system::error_code& error);

void setup_timer_alarm(std::string duration) {
    int hours, minutes, seconds;

    // match hours, minutes and seconds
    sscanf_s(duration.c_str(), "%2d:%2d:%2d", &hours, &minutes, &seconds);

    // set timepoint
    tp_alarm = std::chrono::steady_clock::now();
    tp_alarm += std::chrono::hours(hours);
    tp_alarm += std::chrono::minutes(minutes);
    tp_alarm += std::chrono::seconds(seconds);

    // set duration_display
    duration_display = std::chrono::hours(hours);
    duration_display += std::chrono::minutes(minutes);
    duration_display += std::chrono::seconds(seconds);

    // set timer
    timer_alarm.expires_at(tp_alarm);
    timer_alarm.async_wait(handle_timer_alarm);

    // output
    //std::cout << duration.c_str() << std::endl;
    //std::cout << hours << ":" << minutes << ":" << seconds << std::endl;
    //std::cout << "expires in " << std::chrono::time_point_cast<std::chrono::minutes>(tp_alarm).time_since_epoch().count() << std::endl;
}

void setup_timer_display() {
    // create timepoint
    auto tp = std::chrono::steady_clock::now();
    tp += duration_display_interval;

    // set timer
    timer_display.expires_at(tp);
    timer_display.async_wait(handle_timer_display);
}

void handle_timer_alarm(const boost::system::error_code& error) {
    std::cout << "it's is happening!111" << std::endl;

    // disable all io_services
    io_service.stop();
}

void handle_timer_display(const boost::system::error_code& error) {
    // reduce duration_display by duration_display_interval
    duration_display -= duration_display_interval;

    // convert duration_display into seconds, and use it together with gmtime_s for easy printing
    time_t time_t_display = std::chrono::duration_cast<std::chrono::seconds>(duration_display).count();
    struct tm tm_display;
    gmtime_s(&tm_display, &time_t_display);

    if (duration_display_toggle) {
        printf("remaining: %.2d:%.2d:%.2d\r", tm_display.tm_hour, tm_display.tm_min, tm_display.tm_sec);
    }
    else {
        printf("remaining: %.2d %.2d %.2d\r", tm_display.tm_hour, tm_display.tm_min, tm_display.tm_sec);
    }

    // toggle
    duration_display_toggle = !duration_display_toggle;

    // reset timer
    setup_timer_display();
}


int main(int argc, char * argv[]) {

    // missing time
    if (argc < 2) {
        boost::filesystem::path path(argv[0]);
        std::cerr << "Missing clock time!" << std::endl;
        std::cerr << "Use '" << path.filename().string() << " 00:02:00'" << std::endl;
        return -1;
    }

    // setup timer alarm
    setup_timer_alarm(argv[1]);

    // setup timer display
    setup_timer_display();

    // start services
    io_service.run();

    // alarm!
    // ???

    return 0;

}