#include <errno.h>
#include <limits>
#include <assert.h>

#include "LogFile.h"
#include "ThreadMonitor.h"

#include "IPollSet.h"


IPollSet::IPollSet() :
  _timeout(-1),
  _epollHandle(0),
  _eventCount(0),
  _events(NULL)
{
}

IPollSet::~IPollSet()
{
  clearFileDescriptors();
  delete[](_events);
}

void IPollSet::createEPollHandle()
{
  if (!_epollHandle)
  { // I use 5 as my hint.  The man pages say that this hint isn't really
    // used any more.  Any number greater than 0 will do.
    _epollHandle = epoll_create(5);
    if (_epollHandle < 1)
    { // Report error and abort.
      LogFile::primary().quoteAndSend("IPollSet.C epoll_create",
                                      errorString(), 0);
      LogFile::primary().scheduleShutdown();
    }
  }
}

void IPollSet::closeEPollHandle()
{
  if (_epollHandle > 0)
  {
    int result = close(_epollHandle);
    if (result)
    {// Report error and abort.
      LogFile::primary().quoteAndSend("IPollSet.C close",
                                      errorString(), 0);
      LogFile::primary().scheduleShutdown();
      // Mark this as a bad handle so we don't try to open it again.
      _epollHandle = -1;
    }
    else
    { // Mark this so that we know we need to recreate the handle next
      // time.
      _epollHandle = 0;
    }
  }
}

void IPollSet::createEvents(bool forceBigger)
{
  if (forceBigger || !_events)
  { // Make the size big enough to hold all possible events plus one extra.
    // By having one extra it makes it easy to know when we need to grow
    // again.  If the number of events received is less than this size, we
    // we are okay.  If it is equal to this size, then we grow.
    // Also, this thing has to be at least one record long or epoll_wait
    // will fail.  Adding 1 will satisfy that precondition.
    int newSize = _actions.size() + 1;
    if (_events)
    {
      delete[](_events);
      TclList msg;
      msg<<"IPollSet.C"
         <<"growing"
         <<_eventCount
         <<newSize;
      LogFile::primary().sendString(msg, 0);
      //m.increment("poll_rebuild");
    }
    _events = new epoll_event[newSize];
    _eventCount = newSize;
  }
}

void IPollSet::loadFromOther(IPollSet const &other)
{
  _timeout = other._timeout;
  _woken = other._woken;
  _actions = other._actions;
  if (!_actions.empty())
  {
    createEPollHandle();
    for (std::map< int, int >::const_iterator it = other._actions.begin();
         it != other._actions.end();
         it++)
    {
      epoll_event event;
      event.events = it->second;
      event.data.fd = it->first;
      int result =
        epoll_ctl(_epollHandle, EPOLL_CTL_ADD, it->first, &event);
      if (result)
      { // Report error and abort.
        LogFile::primary().quoteAndSend("IPollSet.C loadFromOther",
                                        errorString(), 0);
        LogFile::primary().scheduleShutdown();
      }
    }
  }
}

IPollSet &IPollSet::operator =(IPollSet const &other)
{
  clearFileDescriptors();
  loadFromOther(other);
  return *this;
}

IPollSet::IPollSet(IPollSet const &other) :
  _timeout(-1),
  _epollHandle(0),
  _eventCount(0),
  _events(NULL)
{
  loadFromOther(other);
}

void IPollSet::setTimeoutNone()
{
  _timeout = -1;
}

void IPollSet::setTimeoutMs(int timeout)
{
  _timeout = std::max(0, timeout);
}

void IPollSet::setTimeout(timeval const *timeVal)
{
  if (timeVal)
  {
    TimeVal::Microseconds microseconds =
      ((TimeVal *)timeVal)->asMicroseconds();
    // Always round up.  Otherwise, if we have less than a millisecond to
    // go, it is likely that we will immediately return, and the calling
    // function will call us again because it is not time yet.
    TimeVal::Microseconds milliseconds = (microseconds + 999) / 1000;
    // It is possible to request a time that is longer than we can represent
    // and send to the poll() call.  In this case we wait as long as we can,
    // then it is up to the caller to ask us to wait again if necessary.
    setTimeoutMs(std::min((TimeVal::Microseconds)std::numeric_limits< int >::max(),
                          milliseconds));
  }
  else
  {
    setTimeoutNone();
  }
}

void IPollSet::addAction(int fd, int action)
{
  if (fd < 0) return;
  int &actions = _actions[fd];
  if (actions & action)
  {
    // Nothing to do.  We are already watching this action for this fd.
  }
  else
  { // If there was already an action for this fd, then this is a
    // modification, otherwise this is an add.
    int operation = actions?EPOLL_CTL_MOD:EPOLL_CTL_ADD;
    actions |= action;
    epoll_event event;
    event.events = actions;
    event.data.u64 = 0;  // Make valgrind happy.
    event.data.fd = fd;
    createEPollHandle();
    int result = epoll_ctl(_epollHandle, operation, fd, &event);
    if (result)
    { // Report error and abort.
      TclList msg;
      msg<<FLF<<"epoll_ctl"<<fd<<errorString();
      LogFile::primary().sendString(msg);
      LogFile::primary().scheduleShutdown();
    }
  }
}

void IPollSet::removeAction(int fd, int action)
{
  if (fd < 0) return;
  int &actions = _actions[fd];
  if (actions & action)
  {
    actions &= ~action;
    if (actions)
    { // Removing one type of listener, but leaving the other.
      epoll_event event;
      event.events = actions;
      event.data.fd = fd;
      int result = epoll_ctl(_epollHandle, EPOLL_CTL_MOD, fd, &event);
      if (result)
      {
        if (errno == EBADF)
          // Bad file descriptor.  Presumably the socket is dead now.
          ThreadMonitor::find().increment("EBADF");
        else
        { // Report error and abort.
          TclList msg;
          msg<<FLF<<"EPOLL_CTL_MOD"<<fd<<errorString();
          LogFile::primary().sendString(msg);
          LogFile::primary().scheduleShutdown();
        }
      }
    }
    else
    { // Removing the entire fd.
      int result = epoll_ctl(_epollHandle, EPOLL_CTL_DEL, fd, NULL);
      if (result)
      {
        if (errno == EBADF)
          // Bad file descriptor.  Presumably the socket is dead now.
          ThreadMonitor::find().increment("EBADF");
        else
        { // Report error and abort.
          TclList msg;
          msg<<FLF<<"EPOLL_CTL_DEL"<<fd<<errorString();
          LogFile::primary().sendString(msg);
          LogFile::primary().scheduleShutdown();
        }
      }
      _actions.erase(fd);
    }
  }
  else
  {
    // Nothing to do.  We were not listening for this action.
  }
  // Interesting.  We never try to remove an empty entry from _actions.
  // We probably should.  This probably won't do much, but it is a small
  // memory leak.
}

void IPollSet::addForRead(int fd)
{
  addAction(fd, EPOLLIN);
}

void IPollSet::removeForRead(int fd)
{
  removeAction(fd, EPOLLIN);
}

void IPollSet::addForWrite(int fd)
{
  addAction(fd, EPOLLOUT);
}

void IPollSet::removeForWrite(int fd)
{
  removeAction(fd, EPOLLOUT);
}

bool IPollSet::watchingForRead(int fd)
{
  return getPropertyDefault(_actions, fd) & EPOLLIN;
}

bool IPollSet::watchingForWrite(int fd)
{
  return getPropertyDefault(_actions, fd) & EPOLLOUT;
}

void IPollSet::clearFileDescriptors()
{
  _actions.clear();
  closeEPollHandle();
}

void IPollSet::poll()
{
  ThreadMonitor &m = ThreadMonitor::find();
  std::string prevState = m.getState();
  m.setState("poll() prepair");
  _woken.clear();
  createEvents(false);
  m.setState("poll");
  int result = epoll_wait(_epollHandle, _events, _eventCount, _timeout);
  m.setState("poll() finish");
  if ((result < 0) && (errno != EINTR))
  { // Report error and abort.  Interrupt is not really an error because
    // we just report nothing is ready.  That's no different than a
    // timeout.  EINTR does not appear in the man page for epoll_wait,
    // but I've seen this error so I know that it really happens
    LogFile::primary().quoteAndSend("IPollSet.C epoll_wait",
                                    errorString(), 0);
    LogFile::primary().scheduleShutdown();
  }
  else
  {
    for (int i = 0; i < result; i++)
    {
      _woken.insert(_events[i].data.fd);
    }
    if (result == _eventCount)
    { // The result list was full.  We might have missed something.  Make
      // the result list bigger for next time.
      createEvents(true);
    }
  }
  m.setState(prevState);
}

IPollSet::HandleSet const &IPollSet::woken() const
{
  return _woken;
}