"""Various Windows specific bits and pieces."""

import sys

if sys.platform != 'win32': # pragma: no cover
 raise ImportError('win32 only')

import _winapi
import itertools
import msvcrt
import os
import subprocess
import tempfile
import warnings


__all__ = 'pipe', 'Popen', 'PIPE', 'PipeHandle'


# Constants/globals


BUFSIZE = 8192
PIPE = subprocess.PIPE
STDOUT = subprocess.STDOUT
_mmap_counter = itertools.count()


# Replacement for os.pipe() using handles instead of fds


def pipe(*, duplex=False, overlapped=(True, True), bufsize=BUFSIZE):
 """Like os.pipe() but with overlapped support and using handles not fds."""
 address = tempfile.mktemp(
 prefix=r'\\.\pipe\python-pipe-{:d}-{:d}-'.format(
 os.getpid(), next(_mmap_counter)))

 if duplex:
 openmode = _winapi.PIPE_ACCESS_DUPLEX
 access = _winapi.GENERIC_READ | _winapi.GENERIC_WRITE
 obsize, ibsize = bufsize, bufsize
 else:
 openmode = _winapi.PIPE_ACCESS_INBOUND
 access = _winapi.GENERIC_WRITE
 obsize, ibsize = 0, bufsize

 openmode |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE

 if overlapped[0]:
 openmode |= _winapi.FILE_FLAG_OVERLAPPED

 if overlapped[1]:
 flags_and_attribs = _winapi.FILE_FLAG_OVERLAPPED
 else:
 flags_and_attribs = 0

 h1 = h2 = None
 try:
 h1 = _winapi.CreateNamedPipe(
 address, openmode, _winapi.PIPE_WAIT,
 1, obsize, ibsize, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL)

 h2 = _winapi.CreateFile(
 address, access, 0, _winapi.NULL, _winapi.OPEN_EXISTING,
 flags_and_attribs, _winapi.NULL)

 ov = _winapi.ConnectNamedPipe(h1, overlapped=True)
 ov.GetOverlappedResult(True)
 return h1, h2
 except:
 if h1 is not None:
 _winapi.CloseHandle(h1)
 if h2 is not None:
 _winapi.CloseHandle(h2)
 raise


# Wrapper for a pipe handle


class PipeHandle:
 """Wrapper for an overlapped pipe handle which is vaguely file-object like.

 The IOCP event loop can use these instead of socket objects.
 """
 def __init__(self, handle):
 self._handle = handle

 def __repr__(self):
 if self._handle is not None:
 handle = f'handle={self._handle!r}'
 else:
 handle = 'closed'
 return f'<{self.__class__.__name__}{handle}>'

 @property
 def handle(self):
 return self._handle

 def fileno(self):
 if self._handle is None:
 raise ValueError("I/O operation on closed pipe")
 return self._handle

 def close(self, *, CloseHandle=_winapi.CloseHandle):
 if self._handle is not None:
 CloseHandle(self._handle)
 self._handle = None

 def __del__(self):
 if self._handle is not None:
 warnings.warn(f"unclosed {self!r}", ResourceWarning,
 source=self)
 self.close()

 def __enter__(self):
 return self

 def __exit__(self, t, v, tb):
 self.close()


# Replacement for subprocess.Popen using overlapped pipe handles


class Popen(subprocess.Popen):
 """Replacement for subprocess.Popen using overlapped pipe handles.

 The stdin, stdout, stderr are None or instances of PipeHandle.
 """
 def __init__(self, args, stdin=None, stdout=None, stderr=None, **kwds):
 assert not kwds.get('universal_newlines')
 assert kwds.get('bufsize', 0) == 0
 stdin_rfd = stdout_wfd = stderr_wfd = None
 stdin_wh = stdout_rh = stderr_rh = None
 if stdin == PIPE:
 stdin_rh, stdin_wh = pipe(overlapped=(False, True), duplex=True)
 stdin_rfd = msvcrt.open_osfhandle(stdin_rh, os.O_RDONLY)
 else:
 stdin_rfd = stdin
 if stdout == PIPE:
 stdout_rh, stdout_wh = pipe(overlapped=(True, False))
 stdout_wfd = msvcrt.open_osfhandle(stdout_wh, 0)
 else:
 stdout_wfd = stdout
 if stderr == PIPE:
 stderr_rh, stderr_wh = pipe(overlapped=(True, False))
 stderr_wfd = msvcrt.open_osfhandle(stderr_wh, 0)
 elif stderr == STDOUT:
 stderr_wfd = stdout_wfd
 else:
 stderr_wfd = stderr
 try:
 super().__init__(args, stdin=stdin_rfd, stdout=stdout_wfd,
 stderr=stderr_wfd, **kwds)
 except:
 for h in (stdin_wh, stdout_rh, stderr_rh):
 if h is not None:
 _winapi.CloseHandle(h)
 raise
 else:
 if stdin_wh is not None:
 self.stdin = PipeHandle(stdin_wh)
 if stdout_rh is not None:
 self.stdout = PipeHandle(stdout_rh)
 if stderr_rh is not None:
 self.stderr = PipeHandle(stderr_rh)
 finally:
 if stdin == PIPE:
 os.close(stdin_rfd)
 if stdout == PIPE:
 os.close(stdout_wfd)
 if stderr == PIPE:
 os.close(stderr_wfd)