#include <pthread.h>
#include <boost/chrono.hpp> 
#include <boost/thread.hpp> 
#include "condition_variable_steady.hpp"

#include <boost/program_options.hpp> 
#include <iostream> 
#include <string> 
#include <stdint.h>

#define WAIT_UNTIL 1 
 
using namespace std; 
using namespace boost; 
namespace ch = boost::chrono; 
namespace po = boost::program_options; 
 
int main(int argc, char ** argv) 
{
   string   type; 
   uint32_t sleepTime; 
    
   po::options_description desc("Arguments"); 
   desc.add_options() 
   ("help", "Help message") 
   ("type", po::value<string>(&type)->default_value("steady"),
    "Type of test: steady, until (wait_until), for (wait_for) or sleep (sleep_until)") 
   ("time", po::value<uint32_t>(&sleepTime)->default_value(10), "Sleep time (sec)"); 

   try { 
      po::variables_map vm; 
      po::store(po::parse_command_line(argc, argv, desc), vm); 
      po::notify(vm); 
      if (vm.count("help"))  
         throw po::error(""); 
   } catch(const std::exception&) { 
      cout << desc << endl; 
      return 1; 
   } 

   ch::steady_clock::time_point startSteady, endSteady; 
   ch::system_clock::time_point startSystem, endSystem; 
    
   startSteady = ch::steady_clock::now(); 
   startSystem = ch::system_clock::now(); 
    
   boost::mutex                signalLock;     
   boost::condition_variable   signal;        // Signal for Timer Queue Processing thread
   boost::condition_variable_steady steady_signal;

   cout << "Waiting for " << sleepTime << " sec" << endl; 
    
   if (type == "sleep") { 
      cout << "SLEEP_UNTIL" << endl; 
      boost::this_thread::sleep_until(startSteady + ch::seconds(sleepTime)); 
   } else if (type == "steady") { 
      cout << "STEADY_WAIT" << endl; 
      boost::unique_lock<boost::mutex> lock(signalLock);
      ch::time_point<ch::steady_clock> wait_time = startSteady + ch::seconds(sleepTime);
      steady_signal.wait_until(lock, wait_time);
   } else if (type == "until") { 
      cout << "WAIT_UNTIL" << endl; 
      boost::unique_lock<boost::mutex> lock(signalLock);
      ch::time_point<ch::steady_clock> wait_time = startSteady + ch::seconds(sleepTime);
      signal.wait_until(lock, wait_time); 
   } else if (type == "for") { 
      cout << "WAIT_FOR" << endl; 
      boost::unique_lock<boost::mutex> lock(signalLock);       
      signal.wait_for(lock, ch::seconds(sleepTime)); 
   } else { 
      cout << "Unexpected test type: '" << type << "'" << endl; 
      return 1; 
   } 
 
   endSteady = ch::steady_clock::now(); 
   endSystem = ch::system_clock::now();

   int ms = ch::duration_cast<ch::milliseconds>(endSteady - startSteady).count();
   cout << "Steady duration/start/stop: " << (float)ms / 1000.0 << endl; 
   cout << "   " << startSteady << " / " << endSteady << endl; 
   cout << "System duration/start/stop: " << ch::duration_cast<ch::seconds>(endSystem - startSystem) << endl; 
   cout << "   " << startSystem << " / " << endSystem << endl; 
}