#include <test_helpers.hxx>

#include <iostream>
#include <string.h>
#include <math.h>
#include <errno.h>
#include <sys/times.h>
#include <time.h>
#include <signal.h>
#include <sys/time.h>



using namespace std;
using namespace PGSTD;
using namespace pqxx;

namespace
{

//a very simple StopWatch class to measure time between issuing query and cancelling query
class CStopWatch
{
public:
    CStopWatch();
    void Start();
    double Stop();
    double Get() const { return elapsed_time; }    
    void Reset() { elapsed_time = 0.0; start = end = 0; }

private:
    clock_t start, end;
    long int clktck;
    double elapsed_time;
};

//class to generate a SIGALRM which activates cancel_query after a defined time
class CSigAlrmTimer
{
public:
    CSigAlrmTimer(double time_period, void(*sig_handler)(int));  
    ~CSigAlrmTimer();
    static void alarm_handler(int signum);

private:
    sigset_t oset;
    struct sigaction oact;
};

//definiton of global alarm handler class
//IT NEEDS A GLOBAL CNX, NEED TO RESTRUCTURE THE CODE TO DO THIS
void alarm_handler(int signum);

//YOU NEED A GLOBAL Connection_base variable instead of 'cnx' here
//instead of a local cnx for the signal handler to cancel the query
// I DON'T ENOUGH ABOUT THE TEST FRAMEWORK TO RESTRUCTURE THIS TEST
// TO DO THIS.
void test_cancel_query(connection_base & cnx, transaction_base &trans)
{
    string sql_cmd;
    sql_cmd = "SELECT * FROM  pg_sleep(2) "; 
    //cout << "sql_cmd is: \n" << sql_cmd << endl;
    CStopWatch stopwatch;
    stopwatch.Start();
    try
    {
      CSigAlrmTimer sigAlrmTimer(1.0, alarm_handler);
      trans.exec(sql_cmd, "Sleep for 2s\n");       
    }
    catch(sql_error& e)
    {
      stopwatch.Stop();
      cerr << "SQL error: " << e.what() << endl << "Query was: '" << e.query() << "'" << endl;
      if(stopwatch.Get() < 1.1)
        cout << "PASS: alarm interrupted sleeping after " << stopwatch.Get() << " seconds\n";
      else
        cout << "FAIL: alarm interrupted sleeping after " << stopwatch.Get() << " seconds\n";
       return;
    }
    stopwatch.Stop();
    cout << "FAILURE: Failed to cancel sleeping " << stopwatch.Get() << " seconds\n";
    return;
}



//definitons of CStopWatch class
CStopWatch::CStopWatch()
:clktck(0)
{
    errno = 0;
    if((clktck = sysconf(_SC_CLK_TCK)) < 0)
    {
        cout << "sysconf failed with: " << strerror(errno) << endl;
        return; //<! @todo, throw exception
    }

}


void CStopWatch::Start()
{

    struct tms tmsstart;
    errno = 0;
    if((start = times(&tmsstart)) == -1)
    {
        cout << "times failed with: " << strerror(errno) << endl;
        return; //<! @todo, throw exception
    }
}


double CStopWatch::Stop()
{

    struct tms tmsend;
    errno = 0;
    if((end = times(&tmsend)) == -1)
    {
        cout << "times failed with: " << strerror(errno) << endl;
        return 0.0; //<! @todo, throw exception
    }
    return elapsed_time = (end - start)/(double) clktck;
}

//definiton of global alarm handler class
//IT NEEDS A GLOBAL CNX, NEED TO RESTRUCTURE THE CODE TO DO THIS
void alarm_handler(int signum)
{
    printf("caught alarm\n"); 
    fflush(stdout);
    //cnx.cancel_query();    //WE NEED A GLOBAL Connection variable, cnx, in this test framework
    return;
}

//definitions of CSigAlrmTimer class
CSigAlrmTimer::CSigAlrmTimer(double time_period, 
                             void (*signal_handler)(int))
{
    //save oset and currsetn set to SIGALRM
   sigset_t set;
   sigemptyset(&set);
   sigaddset(&set, SIGALRM);
   sigprocmask(SIG_SETMASK, 0 , &oset);

   //register 'act' for SIGALRM and save oact
   struct sigaction act;
   act.sa_handler = signal_handler;
   act.sa_flags = 0;
   sigemptyset(&act.sa_mask);
   errno = 0;
   if(sigaction(SIGALRM, &act,&oact) == -1) 
   {
       cout << "sigaction failed with: " << strerror(errno) << endl;
       return; //<! @todo,  throw exception
   }

   //start timer
   double intpart, fractpart = 0.0;
   fractpart = modf(time_period, &intpart);
   //cout << "intpart is: " << intpart << " and fractpart is: " << fractpart << endl;
   //alarm((unsigned int)intpart);    //will later use a better timer like setitimer
   struct itimerval itv;
   itv.it_interval.tv_sec = 0;
   itv.it_interval.tv_usec = 0;
   itv.it_value.tv_sec = (unsigned int)intpart;
   itv.it_value.tv_usec = (unsigned long)fractpart * 1000000;   
   setitimer(ITIMER_REAL, &itv, 0);
   return;

}

CSigAlrmTimer::~CSigAlrmTimer()
{
    //alarm(0);

    //restore old sigaction
    errno = 0;
    if(sigaction(SIGALRM, &oact,0) == -1)
    {
        cout << "sigaction failed with: " << strerror(errno) << endl;
        return; //<! @todo throw exception
    }
    sigprocmask(SIG_SETMASK, &oset, 0);

}

} // namespace

PQXX_REGISTER_TEST(test_cancel_query)