/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "primpl.h"

#include <string.h> /* for memset() */

/************************************************************************/

PRLock* _pr_flock_lock;
PRCondVar* _pr_flock_cv;

#ifdef WINCE
/*
 * There are no stdin, stdout, stderr in Windows CE.  INVALID_HANDLE_VALUE
 * should cause all I/O functions on the handle to fail.
 */
#  define STD_INPUT_HANDLE ((DWORD) - 10)
#  define STD_OUTPUT_HANDLE ((DWORD) - 11)
#  define STD_ERROR_HANDLE ((DWORD) - 12)

static HANDLE GetStdHandle(DWORD nStdHandle) {
  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  return INVALID_HANDLE_VALUE;
}
#endif

void _PR_InitIO(void) {
  const PRIOMethods* methods = PR_GetFileMethods();

  _PR_InitFdCache();

  _pr_flock_lock = PR_NewLock();
  _pr_flock_cv = PR_NewCondVar(_pr_flock_lock);

#ifdef WIN32
  _pr_stdin = PR_AllocFileDesc((PROsfd)GetStdHandle(STD_INPUT_HANDLE), methods);
  _pr_stdout =
      PR_AllocFileDesc((PROsfd)GetStdHandle(STD_OUTPUT_HANDLE), methods);
  _pr_stderr =
      PR_AllocFileDesc((PROsfd)GetStdHandle(STD_ERROR_HANDLE), methods);
#  ifdef WINNT
  _pr_stdin->secret->md.sync_file_io = PR_TRUE;
  _pr_stdout->secret->md.sync_file_io = PR_TRUE;
  _pr_stderr->secret->md.sync_file_io = PR_TRUE;
#  endif
#else
  _pr_stdin = PR_AllocFileDesc(0, methods);
  _pr_stdout = PR_AllocFileDesc(1, methods);
  _pr_stderr = PR_AllocFileDesc(2, methods);
#endif
  _PR_MD_INIT_FD_INHERITABLE(_pr_stdin, PR_TRUE);
  _PR_MD_INIT_FD_INHERITABLE(_pr_stdout, PR_TRUE);
  _PR_MD_INIT_FD_INHERITABLE(_pr_stderr, PR_TRUE);

  _PR_MD_INIT_IO();
}

void _PR_CleanupIO(void) {
  PR_FreeFileDesc(_pr_stdin);
  _pr_stdin = NULL;
  PR_FreeFileDesc(_pr_stdout);
  _pr_stdout = NULL;
  PR_FreeFileDesc(_pr_stderr);
  _pr_stderr = NULL;

  if (_pr_flock_cv) {
    PR_DestroyCondVar(_pr_flock_cv);
    _pr_flock_cv = NULL;
  }
  if (_pr_flock_lock) {
    PR_DestroyLock(_pr_flock_lock);
    _pr_flock_lock = NULL;
  }

  _PR_CleanupFdCache();
}

PR_IMPLEMENT(PRFileDesc*) PR_GetSpecialFD(PRSpecialFD osfd) {
  PRFileDesc* result = NULL;
  PR_ASSERT((int)osfd >= PR_StandardInput && osfd <= PR_StandardError);

  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  switch (osfd) {
    case PR_StandardInput:
      result = _pr_stdin;
      break;
    case PR_StandardOutput:
      result = _pr_stdout;
      break;
    case PR_StandardError:
      result = _pr_stderr;
      break;
    default:
      (void)PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
  }
  return result;
}

PR_IMPLEMENT(PRFileDesc*)
PR_AllocFileDesc(PROsfd osfd, const PRIOMethods* methods) {
  PRFileDesc* fd;

#ifdef XP_UNIX
  /*
   * Assert that the file descriptor is small enough to fit in the
   * fd_set passed to select
   */
  PR_ASSERT(osfd < FD_SETSIZE);
#endif
  fd = _PR_Getfd();
  if (fd) {
    /* Initialize the members of PRFileDesc and PRFilePrivate */
    fd->methods = methods;
    fd->secret->state = _PR_FILEDESC_OPEN;
    fd->secret->md.osfd = osfd;
#if defined(_WIN64)
    fd->secret->alreadyConnected = PR_FALSE;
    fd->secret->overlappedActive = PR_FALSE;
#endif
    _PR_MD_INIT_FILEDESC(fd);
  } else {
    PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
  }

  return fd;
}

PR_IMPLEMENT(void) PR_FreeFileDesc(PRFileDesc* fd) {
  PR_ASSERT(fd);
  _PR_Putfd(fd);
}

#if defined(_WIN64) && defined(WIN95)

PRFileDescList* _fd_waiting_for_overlapped_done = NULL;
PRLock* _fd_waiting_for_overlapped_done_lock = NULL;

void CheckOverlappedPendingSocketsAreDone() {
  if (!_fd_waiting_for_overlapped_done_lock ||
      !_fd_waiting_for_overlapped_done) {
    return;
  }

  PR_Lock(_fd_waiting_for_overlapped_done_lock);

  PRFileDescList* cur = _fd_waiting_for_overlapped_done;
  PRFileDescList* previous = NULL;
  while (cur) {
    PR_ASSERT(cur->fd->secret->overlappedActive);
    PRFileDesc* fd = cur->fd;
    DWORD rvSent;
    if (GetOverlappedResult((HANDLE)fd->secret->md.osfd, &fd->secret->ol,
                            &rvSent, FALSE) == TRUE) {
      fd->secret->overlappedActive = PR_FALSE;
      PR_LOG(_pr_io_lm, PR_LOG_MIN,
             ("CheckOverlappedPendingSocketsAreDone GetOverlappedResult "
              "succeeded\n"));
    } else {
      DWORD err = WSAGetLastError();
      PR_LOG(_pr_io_lm, PR_LOG_MIN,
             ("CheckOverlappedPendingSocketsAreDone GetOverlappedResult failed "
              "%d\n",
              err));
      if (err != ERROR_IO_INCOMPLETE) {
        fd->secret->overlappedActive = PR_FALSE;
      }
    }

    if (!fd->secret->overlappedActive) {
      _PR_MD_CLOSE_SOCKET(fd->secret->md.osfd);
      fd->secret->state = _PR_FILEDESC_CLOSED;
#  ifdef _PR_HAVE_PEEK_BUFFER
      if (fd->secret->peekBuffer) {
        PR_ASSERT(fd->secret->peekBufSize > 0);
        PR_DELETE(fd->secret->peekBuffer);
        fd->secret->peekBufSize = 0;
        fd->secret->peekBytes = 0;
      }
#  endif

      PR_FreeFileDesc(fd);

      if (previous) {
        previous->next = cur->next;
      } else {
        _fd_waiting_for_overlapped_done = cur->next;
      }
      PRFileDescList* del = cur;
      cur = cur->next;
      PR_Free(del);
    } else {
      previous = cur;
      cur = cur->next;
    }
  }

  PR_Unlock(_fd_waiting_for_overlapped_done_lock);
}
#endif

/*
** Wait for some i/o to finish on one or more more poll descriptors.
*/
PR_IMPLEMENT(PRInt32)
PR_Poll(PRPollDesc* pds, PRIntn npds, PRIntervalTime timeout) {
#if defined(_WIN64) && defined(WIN95)
  // For each iteration check if TFO overlapped IOs are down.
  CheckOverlappedPendingSocketsAreDone();
#endif

  return (_PR_MD_PR_POLL(pds, npds, timeout));
}

/*
** Set the inheritance attribute of a file descriptor.
*/
PR_IMPLEMENT(PRStatus) PR_SetFDInheritable(PRFileDesc* fd, PRBool inheritable) {
#if defined(XP_UNIX) || defined(WIN32)
  /*
   * Only a non-layered, NSPR file descriptor can be inherited
   * by a child process.
   */
  if (fd->identity != PR_NSPR_IO_LAYER) {
    PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
    return PR_FAILURE;
  }
  if (fd->secret->inheritable != inheritable) {
    if (_PR_MD_SET_FD_INHERITABLE(fd, inheritable) == PR_FAILURE) {
      return PR_FAILURE;
    }
    fd->secret->inheritable = inheritable;
  }
  return PR_SUCCESS;
#else
  PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
  return PR_FAILURE;
#endif
}

/*
** This function only has a useful implementation in the debug build of
** the pthreads version.
*/
PR_IMPLEMENT(void) PT_FPrintStats(PRFileDesc* debug_out, const char* msg) {
  /* do nothing */
} /* PT_FPrintStats */
