#include <stdio.h>
#include <common/string.hpp>
#include <common/block.hpp>
#include <common/pointer.hpp>
#include <common/fileio.hpp>
#include <common/profiler.hpp>
#include <common/mmap.hpp>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <tuple>
#include <utility>
#include <complex>
#include <csignal>
#include <common/callback.hpp>


bool registerSignalHandler(void);             // registers a Control-c handler
void signalHandler(int signal);               // The Control-C handler

class Info
{
  public:
  Info();
  ~Info();
  String getMessage(void);
  void setMessage(const String &message);
  private:
  String mMessage;
};

Info::Info()
{
  std::cout << "Info" << std::endl;
}

Info::~Info()
{
  std::cout << "~Info" << std::endl;
}

String Info::getMessage(void)
{
    return mMessage;
}

void Info::setMessage(const String &message)
{
    mMessage = message;
}

class B 
{
  public:
    B();
    LONG callback(CallbackData<Info> &callbackData);
    ~B();
  private:
    String mFoo;
};

B::B()
{
}

B::~B()
{
}

LONG B::callback(CallbackData<Info> &callbackData)
{
  std::cout << "callback with data " << callbackData.getData().getMessage().str() << std::endl;  
  return 0;
}

class Monitor
{
  public:
  Monitor();
  ~Monitor();
  void setCallback(Callback<B,Info> &callback);
  void doCallback(CallbackData<Info> &callbackData);
  private:
  Callback<B,Info> mCallback;
};

Monitor::Monitor()
{
  std::cout << "Monitor" << std::endl;
}


Monitor::~Monitor()
{
  std::cout << "~Monitor" << std::endl;
}

void Monitor::setCallback(Callback<B,Info> &callback)
{
  mCallback=callback;
}

void Monitor::doCallback(CallbackData<Info> &callbackData)
{
  CallbackPointer cbptr(&mCallback);
  cbptr.callback(callbackData);
}

int main(int argc, char ** argv)
{
    registerSignalHandler();
    while(true)
    {
      // do stuff
    }
    // std::vector<int> myBigVec(10000000, 2011);
    // std::vector<std::string> s1;
    // std::vector<std::string> s2;

    // s1.push_back("hello");
    // s1.push_back("world");

    // s2 = std::move(s1);


  // Monitor monitor;
  // SmartPointer<B> b(true);
  // Callback<B,Info> callback(&(*b),&B::callback);
  // monitor.setCallback(callback);

  // Info info;
  // info.setMessage("Hello");

  // CallbackData<Info> callbackData(info);
  // monitor.doCallback(callbackData);

}

/// @brief The signal handler
void signalHandler(int signal)
{
  std::cout << "Received signal " << signal << std::endl;
  exit(signal);
}

/// @brief Method that registers the signal handler
/// @param  
bool registerSignalHandler(void)
{
  struct sigaction sa;
  sa.sa_handler = signalHandler; 
  sigemptyset(&sa.sa_mask);   // Clear the mask of blocked signals
  sa.sa_flags = 0;            // No special flags

  if (-1==sigaction(SIGINT, &sa, nullptr))
  {
    std::cerr << "Error registering SIGINT handler." << std::endl;
    return false;
  }  
  return true;
}



//  Callback callback(&(*b),C


//  SmartPointer<B> b1 = b;
//  b1->foo();
//  b->foo();

//  String str="Hello";
//  b->setFoo(str);
//  str="Goodbye";
//  String str2=b->getFoo();
//  str2="world";

void readFile()
{
  //  MemoryMappedFile memoryMappedFile("/home/pi/Boneyard/ctest/main.cpp",MemoryMappedFile::CreationFlags::ReadOnly);
//  MemoryMappedFile memoryMappedFile("/home/pi/Boneyard/ctest/test.txt",MemoryMappedFile::CreationFlags::ReadOnly);
  MemoryMappedFile memoryMappedFile("/mnt/mariadb/backupdb.sql",MemoryMappedFile::CreationFlags::ReadOnly);  
  Profiler profiler = Profiler();
  String strLine;

  DWORD lines = 0;
  strLine.reserve(1400000,0);
  while(memoryMappedFile.readLine(strLine))
  {
//    printf("%s\n",(char*)strLine);
    lines++;
    if(!(lines%1000000))
    {
      printf("reading %d %s\n",lines,(char*)strLine);
    }    
  }
  memoryMappedFile.close();
  printf("done, took %d(ms)...\n",profiler.end());
}