#ifndef _WIN32

#include <errno.h>

#include "pollset.h"

#include <winpr/handle.h>

#include <winpr/sysinfo.h>

#include <winpr/assert.h>

#include "../log.h"

#if defined(__EMSCRIPTEN__)

#include <emscripten.h>

#endif

#define TAG WINPR_TAG("sync.pollset")

#ifdef WINPR_HAVE_POLL_H

static INT16 handle_mode_to_pollevent(ULONG mode)

{

  INT16 event = 0;

  if (mode & WINPR_FD_READ)

    event |= POLLIN;

  if (mode & WINPR_FD_WRITE)

    event |= POLLOUT;

  return event;

}

#endif

BOOL pollset_init(WINPR_POLL_SET* set, size_t nhandles)

{

  WINPR_ASSERT(set);

#ifdef WINPR_HAVE_POLL_H

  if (nhandles > MAXIMUM_WAIT_OBJECTS)

  {

    set->isStatic = FALSE;

    set->pollset = calloc(nhandles, sizeof(*set->pollset));

    if (!set->pollset)

      return FALSE;

  }

  else

  {

    set->pollset = set->staticSet;

    set->isStatic = TRUE;

  }

#else

  set->fdIndex = calloc(nhandles, sizeof(*set->fdIndex));

  if (!set->fdIndex)

    return FALSE;

  FD_ZERO(&set->rset_base);

  FD_ZERO(&set->rset);

  FD_ZERO(&set->wset_base);

  FD_ZERO(&set->wset);

  set->maxFd = 0;

  set->nread = set->nwrite = 0;

#endif

  set->size = nhandles;

  set->fillIndex = 0;

  return TRUE;

}

void pollset_uninit(WINPR_POLL_SET* set)

{

  WINPR_ASSERT(set);

#ifdef WINPR_HAVE_POLL_H

  if (!set->isStatic)

    free(set->pollset);

#else

  free(set->fdIndex);

#endif

}

void pollset_reset(WINPR_POLL_SET* set)

{

  WINPR_ASSERT(set);

#ifndef WINPR_HAVE_POLL_H

  FD_ZERO(&set->rset_base);

  FD_ZERO(&set->wset_base);

  set->maxFd = 0;

  set->nread = set->nwrite = 0;

#endif

  set->fillIndex = 0;

}

BOOL pollset_add(WINPR_POLL_SET* set, int fd, ULONG mode)

{

  WINPR_ASSERT(set);

#ifdef WINPR_HAVE_POLL_H

  struct pollfd* item = NULL;

  if (set->fillIndex == set->size)

    return FALSE;

  item = &set->pollset[set->fillIndex];

  item->fd = fd;

  item->revents = 0;

  item->events = handle_mode_to_pollevent(mode);

#else

  FdIndex* fdIndex = &set->fdIndex[set->fillIndex];

  if (mode & WINPR_FD_READ)

  {

    FD_SET(fd, &set->rset_base);

    set->nread++;

  }

  if (mode & WINPR_FD_WRITE)

  {

    FD_SET(fd, &set->wset_base);

    set->nwrite++;

  }

  if (fd > set->maxFd)

    set->maxFd = fd;

  fdIndex->fd = fd;

  fdIndex->mode = mode;

#endif

  set->fillIndex++;

  return TRUE;

}

int pollset_poll(WINPR_POLL_SET* set, DWORD dwMilliseconds)

{

  WINPR_ASSERT(set);

  int ret = 0;

  UINT64 dueTime = 0;

  UINT64 now = 0;

  now = GetTickCount64();

  if (dwMilliseconds == INFINITE)

    dueTime = 0xFFFFFFFFFFFFFFFF;

  else

    dueTime = now + dwMilliseconds;

#ifdef WINPR_HAVE_POLL_H

  int timeout = 0;

  do

  {

    if (dwMilliseconds == INFINITE)

      timeout = -1;

    else

      timeout = (int)(dueTime - now);

    ret = poll(set->pollset, set->fillIndex, timeout);

    if (ret >= 0)

    {

#if defined(__EMSCRIPTEN__)

      /* If we have tried 10 times unsuccessfully we will yield in emscripten so pending event

       * handlers might be run */

      if (ret == 0)

      {

        if (++set->yieldCounter > 10)

        {

          emscripten_sleep(0);

          set->yieldCounter = 0;

        }

      }

      else

        set->yieldCounter = 0;

#endif

      return ret;

    }

    if (errno != EINTR)

      return -1;

    now = GetTickCount64();

  } while (now < dueTime);

#else

  do

  {

    struct timeval staticTimeout;

    struct timeval* timeout;

    fd_set* rset = NULL;

    fd_set* wset = NULL;

    if (dwMilliseconds == INFINITE)

    {

      timeout = NULL;

    }

    else

    {

      long waitTime = (long)(dueTime - now);

      timeout = &staticTimeout;

      timeout->tv_sec = waitTime / 1000;

      timeout->tv_usec = (waitTime % 1000) * 1000;

    }

    if (set->nread)

    {

      rset = &set->rset;

      memcpy(rset, &set->rset_base, sizeof(*rset));

    }

    if (set->nwrite)

    {

      wset = &set->wset;

      memcpy(wset, &set->wset_base, sizeof(*wset));

    }

    ret = select(set->maxFd + 1, rset, wset, NULL, timeout);

    if (ret >= 0)

      return ret;

    if (errno != EINTR)

      return -1;

    now = GetTickCount64();

  } while (now < dueTime);

  FD_ZERO(&set->rset);

  FD_ZERO(&set->wset);

#endif

  return 0; /* timeout */

}

BOOL pollset_isSignaled(WINPR_POLL_SET* set, size_t idx)

{

  WINPR_ASSERT(set);

  if (idx > set->fillIndex)

  {

    WLog_ERR(TAG, "index=%d out of pollset(fillIndex=%" PRIuz ")", idx, set->fillIndex);

    return FALSE;

  }

#ifdef WINPR_HAVE_POLL_H

  return !!(set->pollset[idx].revents & set->pollset[idx].events);

#else

  FdIndex* fdIndex = &set->fdIndex[idx];

  if (fdIndex->fd < 0)

    return FALSE;

  if ((fdIndex->mode & WINPR_FD_READ) && FD_ISSET(fdIndex->fd, &set->rset))

    return TRUE;

  if ((fdIndex->mode & WINPR_FD_WRITE) && FD_ISSET(fdIndex->fd, &set->wset))

    return TRUE;

  return FALSE;

#endif

}

BOOL pollset_isReadSignaled(WINPR_POLL_SET* set, size_t idx)

{

  WINPR_ASSERT(set);

  if (idx > set->fillIndex)

  {

    WLog_ERR(TAG, "index=%d out of pollset(fillIndex=%" PRIuz ")", idx, set->fillIndex);

    return FALSE;

  }

#ifdef WINPR_HAVE_POLL_H

  return !!(set->pollset[idx].revents & POLLIN);

#else

  FdIndex* fdIndex = &set->fdIndex[idx];

  if (fdIndex->fd < 0)

    return FALSE;

  return FD_ISSET(fdIndex->fd, &set->rset);

#endif

}

BOOL pollset_isWriteSignaled(WINPR_POLL_SET* set, size_t idx)

{

  WINPR_ASSERT(set);

  if (idx > set->fillIndex)

  {

    WLog_ERR(TAG, "index=%d out of pollset(fillIndex=%" PRIuz ")", idx, set->fillIndex);

    return FALSE;

  }

#ifdef WINPR_HAVE_POLL_H

  return !!(set->pollset[idx].revents & POLLOUT);

#else

  FdIndex* fdIndex = &set->fdIndex[idx];

  if (fdIndex->fd < 0)

    return FALSE;

  return FD_ISSET(fdIndex->fd, &set->wset);

#endif

}

#endif