#include <boost/function.hpp>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>



class Counter
{
public:
   Counter():m_value(0)
   {
   
   }
   void onIncrement()
   {
      ++m_value;
      std::cout<<"Counter is "<<m_value<<std::endl;
   }
protected:
   int m_value;
};

class IntervalEvent
{
public:
   IntervalEvent(size_t id, boost::asio::io_service &io,
                 long durationSeconds,
         boost::function<void(void)> event):
    m_id(id),
    m_intervalDuration(durationSeconds),
    m_timer(io,boost::posix_time::seconds(m_intervalDuration)),
    m_event(event)
    {
		std::cerr<<"Creating IntervalEvent id: "<<id<<" duration : "<<m_intervalDuration<<std::endl;

        //io_service::run is running in only one thread
		io.post(boost::bind(&IntervalEvent::handleReset, this, m_intervalDuration));
    }
    void reset(long duration)
	{
		std::cout<<"Timer id: "<< m_id<<" Reseting timer duration. Old : "<<m_intervalDuration<<" New: "<<duration<<std::endl;
		m_timer.get_io_service().post(boost::bind(&IntervalEvent::handleReset, this, duration));
	}
    
    void cancel()
    {
		m_timer.get_io_service().post(boost::bind(&IntervalEvent::handleCancel, this));
    }
    size_t getCurrentInterval() const
    {
        return m_intervalDuration;
    }
protected:
	void handleCancel()
	{
		m_timer.cancel();
	}
	void handleReset(long duration)
	{
        if (m_timer.expires_from_now(boost::posix_time::seconds(duration)) > 0)
        {
			m_intervalDuration = duration;
			//reset the async wait
			m_timer.async_wait(boost::bind(&IntervalEvent::handleTimerExpiration, this,_1));
        }
        else
        {
			//Timer already expired, reschedule a wait
			m_timer.async_wait(boost::bind(&IntervalEvent::handleTimerExpiration, this,_1));
        }
    }
	void handleTimerExpiration(const boost::system::error_code& error)
    {
		//If timer is not cancelled
        if(error!= boost::asio::error::operation_aborted)
        {
           m_event();
           handleReset(m_intervalDuration);
        }
    }
	size_t m_id;
    long m_intervalDuration;
    boost::asio::deadline_timer m_timer;
    boost::function<void(void)> m_event;
};

int main()
{

   boost::asio::io_service io;
   boost::shared_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(io));

   boost::thread ioservice_thread(boost::bind(&boost::asio::io_service::run, &io));

   std::map<size_t,boost::shared_ptr<IntervalEvent> > events;

   Counter count;
   long duration = 1;
   size_t timerId = 0;

   char response = 'Y';
   while(response != 'Q')
   {
	   std::cout<<"Options :"<<std::endl;
	   std::cout<<"Quit         -- [Q] :"<<std::endl;
	   std::cout<<"Add Timer    -- [A] :"<<std::endl;
	   std::cout<<"Modify Timer -- [M] :"<<std::endl;
	   std::cout<<"Cancel Timer -- [C] :"<<std::endl;

       std::cin>>response;
       if(response == 'A')
       {
		   ++timerId;
			boost::shared_ptr<IntervalEvent> test(new IntervalEvent(timerId,io,
                                        duration,
                            boost::bind(&Counter::onIncrement,boost::ref(count)
                            ))
                                    );
			events.insert(std::make_pair(timerId,test));
       }
	   else if(response == 'M')
	   {
		   size_t id;
		   long duration;
		   std::cout<<"Enter timerid"<<std::endl;
		   std::cin>>id;
		   std::cout<<"Enter new Duration"<<std::endl;
		   std::cin>>duration;
		   std::map<size_t,boost::shared_ptr<IntervalEvent> >::iterator it = events.find(id);
		   if(it!=events.end())
		   {
			 it->second->reset(duration);
		   }
		   else
		   {
			   std::cerr<<"Cannot find timer id: "<<id<<std::endl;
		   }
	   }
	   else if(response == 'C')
	   {
		   size_t id;
		   long duration;
		   std::cout<<"Enter timerid"<<std::endl;
		   std::cin>>id;
		  
		   std::map<size_t,boost::shared_ptr<IntervalEvent> >::iterator it = events.find(id);
		   if(it!=events.end())
		   {
			 it->second->cancel();
		   }
		   else
		   {
			   std::cerr<<"Cannot find timer id: "<<id<<std::endl;
		   }
	   }
   }
 
   //cancel interval events
   for(std::map<size_t,boost::shared_ptr<IntervalEvent> >::iterator it = events.begin(), itEnd = events.end();
      it!=itEnd;
      ++it)
   {
    (it->second)->cancel();
   }
   //reset ioservice_work
   work.reset();

   ioservice_thread.join();

   return 0;
}