"""FakePopen class declaration"""

import asyncio
import collections.abc
import concurrent.futures
import copy
import io
import os
import signal
import subprocess
import sys
import time
from functools import partial
from typing import Any as AnyType
from typing import Callable
from typing import cast
from typing import Dict
from typing import IO
from typing import List
from typing import Optional
from typing import Sequence
from typing import Tuple
from typing import Union

from . import exceptions
from .types import BUFFER
from .types import OPTIONAL_TEXT
from .types import OPTIONAL_TEXT_OR_ITERABLE
from .utils import Thread

if sys.platform.startswith("win") and sys.version_info < (3, 8):
    COMMAND_SEQ = Sequence[Union[str, bytes]]
else:
    COMMAND_SEQ = Sequence[Union[str, bytes, "os.PathLike[str]", "os.PathLike[bytes]"]]


class FakePopen:
    """Base class that fakes the real subprocess.Popen()"""

    stdout: Optional[BUFFER] = None
    stderr: Optional[BUFFER] = None
    stdin: Optional[BUFFER] = None
    returncode: Optional[int] = None
    text_mode: bool = False
    pid: int = 0

    def __init__(
        self,
        command: Union[
            Union[bytes, str],
            COMMAND_SEQ,
        ],
        stdout: OPTIONAL_TEXT_OR_ITERABLE = None,
        stderr: OPTIONAL_TEXT_OR_ITERABLE = None,
        returncode: int = 0,
        wait: Optional[float] = None,
        callback: Optional[Callable] = None,
        callback_kwargs: Optional[Dict[str, AnyType]] = None,
        signal_callback: Optional[Callable] = None,
        stdin_callable: Optional[Callable] = None,
        **_: Dict[str, AnyType],
    ) -> None:
        if (
            not isinstance(command, (str, bytes))
            and sys.platform.startswith("win")
            and sys.version_info < (3, 8)
        ):
            for arg in command:
                if isinstance(arg, os.PathLike):
                    msg = f"argument of type {arg.__class__.__name__!r} is not iterable"
                    raise TypeError(msg)
        self.args = command
        self.__kwargs: Optional[Dict[str, AnyType]] = None
        self.__stdout: OPTIONAL_TEXT_OR_ITERABLE = stdout
        self.__stderr: OPTIONAL_TEXT_OR_ITERABLE = stderr
        self.__thread: Optional[Thread] = None
        self.__signal_callback: Optional[Callable] = signal_callback
        self.__stdin_callable: Optional[Optional[Callable]] = stdin_callable
        self.__universal_newlines: Optional[Dict[AnyType, AnyType]] = None
        self._signals: List[int] = []
        self._returncode: Optional[int] = returncode
        self._wait_timeout: Optional[float] = wait
        self._callback: Optional[Optional[Callable]] = callback
        self._callback_kwargs: Optional[Dict[str, AnyType]] = callback_kwargs

    @property
    def kwargs(self) -> Optional[Dict[str, AnyType]]:
        return self.__kwargs

    def __enter__(self) -> "FakePopen":
        return self

    def __exit__(self, *args: List, **kwargs: Dict) -> None:
        if self.__thread and self.__thread.exception:
            raise self.__thread.exception

    def communicate(
        self, input: OPTIONAL_TEXT = None, timeout: Optional[float] = None
    ) -> Tuple[AnyType, AnyType]:
        self._handle_stdin(input)
        self._finalize_thread(timeout)

        if isinstance(self.stdout, asyncio.StreamReader) or isinstance(
            self.stderr, asyncio.StreamReader
        ):
            raise exceptions.PluginInternalError

        return (
            self.stdout.getvalue() if self.stdout else None,
            self.stderr.getvalue() if self.stderr else None,
        )

    def _handle_stdin(self, input: OPTIONAL_TEXT) -> None:
        if input and self.__stdin_callable:
            callable_output = self.__stdin_callable(input)
            if isinstance(callable_output, dict):
                self.stdout = self._extend_stream_from_dict(
                    callable_output, "stdout", self.stdout
                )
                self.stderr = self._extend_stream_from_dict(
                    callable_output, "stderr", self.stderr
                )

    def _finalize_thread(self, timeout: Optional[float]) -> None:
        if self.__thread is None:
            return
        self.__thread.join(timeout)
        if self.returncode is None and self._returncode is not None:
            self.returncode = self._returncode
        if self.__thread.exception:
            raise self.__thread.exception

    def _extend_stream_from_dict(
        self, dictionary: Dict[str, AnyType], key: str, stream: Optional[BUFFER]
    ) -> Optional[BUFFER]:
        data = dictionary.get(key)
        if data:
            return self._prepare_buffer(input=data, io_base=stream)
        return None

    def poll(self) -> Optional[int]:
        if (
            self.returncode is None
            and self.__thread is not None
            and not self.__thread.is_alive()
        ):
            # The callback/wait thread has finished but _finalize_thread() has
            # not been called yet (e.g. the caller uses poll() instead of
            # wait()/communicate()).  Finalise now so returncode is updated,
            # mirroring real subprocess.Popen.poll() behaviour.
            self._finalize_thread(None)
        return self.returncode

    def wait(self, timeout: Optional[float] = None) -> int:
        if timeout and self._wait_timeout:
            self._wait_timeout -= timeout
            if timeout < self._wait_timeout:
                raise subprocess.TimeoutExpired(self.args, timeout)
        self._finalize_thread(timeout)
        if self.returncode is None:
            raise exceptions.PluginInternalError
        return self.returncode

    def send_signal(self, sig: int) -> None:
        self._signals.append(sig)
        if self.__signal_callback:
            self.__signal_callback(self, sig)

    def terminate(self) -> None:
        self.send_signal(signal.SIGTERM)

    def kill(self) -> None:
        if sys.platform == "win32":
            self.terminate()
        else:
            self.send_signal(signal.SIGKILL)

    def configure(self, **kwargs: Optional[Dict]) -> None:
        """Setup the FakePopen instance based on a real Popen arguments."""
        self.__kwargs = self.safe_copy(kwargs)
        self.__universal_newlines = kwargs.get("universal_newlines", None)

        text = kwargs.get("text", None)
        encoding = kwargs.get("encoding", None)
        errors = kwargs.get("errors", None)

        if text and sys.version_info < (3, 7):
            raise TypeError("__init__() got an unexpected keyword argument 'text'")

        self.text_mode = bool(text or self.__universal_newlines or encoding or errors)

        stdin = kwargs.get("stdin")
        if stdin == subprocess.PIPE:
            self.stdin = self._get_empty_buffer(self.text_mode)

        # validation taken from the real subprocess
        if (
            text is not None
            and self.__universal_newlines is not None
            and bool(self.__universal_newlines) != bool(text)
        ):
            raise subprocess.SubprocessError(
                "Cannot disambiguate when both text "
                "and universal_newlines are supplied but "
                "different. Pass one or the other."
            )

        stdout = kwargs.get("stdout")
        stdout_writer = self._get_io_writer(stdout)
        if stdout == subprocess.PIPE:
            self.stdout = self._prepare_buffer(self.__stdout)
        elif stdout_writer is not None:
            self._write_to_buffer(self.__stdout, stdout_writer)
        stderr = kwargs.get("stderr")
        if stderr == subprocess.STDOUT and self.__stderr:
            if stdout_writer is not None:
                self._write_to_buffer(self.__stderr, stdout_writer)
            elif self.stdout is not None:
                self.stdout = self._prepare_buffer(self.__stderr, self.stdout)
        elif stderr == subprocess.PIPE:
            self.stderr = self._prepare_buffer(self.__stderr)
        else:
            stderr_writer = self._get_io_writer(stderr)
            if stderr_writer is not None:
                self._write_to_buffer(self.__stderr, stderr_writer)

    @staticmethod
    def safe_copy(kwargs: Dict[str, AnyType]) -> Dict[str, AnyType]:
        """
        Deepcopy can fail if the value is not serializable, fallback to shallow copy.
        """
        try:
            return copy.deepcopy(kwargs)
        except TypeError:
            return dict(**kwargs)

    @staticmethod
    def _get_io_writer(stream: AnyType) -> Optional[IO]:
        if callable(getattr(stream, "write", None)) and isinstance(
            getattr(stream, "mode", None), str
        ):
            return cast(IO, stream)
        return None

    def _prepare_buffer(
        self,
        input: OPTIONAL_TEXT_OR_ITERABLE,
        io_base: Optional[BUFFER] = None,
    ) -> Union[io.BytesIO, io.StringIO, asyncio.StreamReader]:
        linesep = self._convert(os.linesep)

        if isinstance(input, (list, tuple)):
            # need to disable mypy, as input and linesep are unions,
            # mypy thinks that the types might be incompatible, but
            # the _convert() function handles that
            input = linesep.join(map(self._convert, input))  # type: ignore

            # Add trailing newline if data is present.
            if input:
                # same reason to disable mypy as above
                input += linesep  # type: ignore

        if isinstance(input, str) and not self.text_mode:
            input = input.encode()

        if isinstance(input, bytes) and self.text_mode:
            input = input.decode()

        if input and self.__universal_newlines and isinstance(input, str):
            input = input.replace("\r\n", "\n")

        if (
            io_base
            and not isinstance(io_base, asyncio.StreamReader)
            and io_base.tell() == 0
        ):
            # same reason for disabling mypy as in `input = linesep.join...`:
            # both are union so could be incompatible if not _convert()
            input = io_base.getvalue() + (input)  # type: ignore

        if io_base is None:
            io_base = self._get_empty_buffer(self.text_mode)

        if input is None:
            return io_base

        # similar as above - mypy has to be disabled because unions
        if isinstance(io_base, asyncio.StreamReader):
            io_base.feed_data(self._data_to_bytes(input))
        else:
            io_base.write(input)  # type: ignore
        return io_base

    def _get_empty_buffer(self, text: bool) -> BUFFER:
        return io.StringIO() if text else io.BytesIO()

    def _to_bytes(self, data: Sequence[Union[str, bytes]]) -> Sequence[bytes]:
        return [elem if isinstance(elem, bytes) else elem.encode() for elem in data]

    def _data_to_bytes(self, data: OPTIONAL_TEXT_OR_ITERABLE) -> bytes:
        if isinstance(data, collections.abc.Sequence) and not isinstance(data, bytes):
            return b"\n".join(
                (item if isinstance(item, bytes) else item.encode() for item in data)
            )
        if isinstance(data, str):
            return data.encode()
        if not data:
            return b""
        return data

    def _write_to_buffer(self, data: OPTIONAL_TEXT_OR_ITERABLE, buffer: IO) -> None:
        if data is None:
            return
        binary_mode = "b" in buffer.mode
        if isinstance(data, (list, tuple)):
            self._write_lines(buffer, data, binary_mode)
        else:
            self._write_value(buffer, data, binary_mode)

    def _write_lines(self, buffer: IO, lines: Sequence[AnyType], binary: bool) -> None:
        if binary:
            buffer.writelines([self._to_bytes_value(line) + b"\n" for line in lines])
        else:
            buffer.writelines([self._to_text_value(line) + "\n" for line in lines])

    def _write_value(self, buffer: IO, value: AnyType, binary: bool) -> None:
        if binary:
            buffer.write(self._to_bytes_value(value))
        else:
            buffer.write(self._to_text_value(value))

    def _to_text_value(self, value: AnyType) -> str:
        return value if isinstance(value, str) else str(value)

    def _to_bytes_value(self, value: AnyType) -> bytes:
        if isinstance(value, bytes):
            return value
        return str(value).encode(sys.getfilesystemencoding())

    def _convert(self, input: Union[str, bytes]) -> Union[str, bytes]:
        if isinstance(input, bytes) and self.text_mode:
            return input.decode()
        if isinstance(input, str) and not self.text_mode:
            return input.encode()
        return input

    def _wait(self, wait_period: float) -> None:
        time.sleep(wait_period)
        if self.returncode is None:
            self._finish_process()

    def run_thread(self) -> None:
        """Run the user-defined callback or wait in a thread."""
        if self._wait_timeout is None and self._callback is None:
            self._finish_process()
        else:
            if self._callback:
                self.__thread = Thread(
                    target=self._callback,
                    args=(self,),
                    kwargs=self._callback_kwargs or {},
                )
            else:
                self.__thread = Thread(target=self._wait, args=(self._wait_timeout,))
            self.__thread.start()

    def _finish_process(self) -> None:
        self.returncode = self._returncode

        self._finalize_streams()

    def _finalize_streams(self) -> None:
        self._finalize_stream(self.stdout)
        self._finalize_stream(self.stderr)

    def _finalize_stream(self, stream: Optional[BUFFER]) -> None:
        if isinstance(stream, asyncio.StreamReader):
            stream.feed_eof()
        elif stream:
            stream.seek(0)

    def received_signals(self) -> Tuple[int, ...]:
        """Get a tuple of signals received by the process."""
        return tuple(self._signals)


class AsyncFakePopen(FakePopen):
    """Class to handle async processes"""

    async def communicate(  # type: ignore
        self, input: OPTIONAL_TEXT = None, timeout: Optional[float] = None
    ) -> Tuple[AnyType, AnyType]:
        if input:
            # streams were fed with eof, need to be reopened
            await self._reopen_streams()

            self._handle_stdin(input)

            # feed eof one more time as streams were opened
            self._finalize_streams()
        await self._finalize(timeout)
        stdout = self.stdout
        stderr = self.stderr
        return (
            await stdout.read() if isinstance(stdout, asyncio.StreamReader) else None,
            await stderr.read() if isinstance(stderr, asyncio.StreamReader) else None,
        )

    async def wait(self, timeout: Optional[float] = None) -> int:  # type: ignore
        if timeout and self._wait_timeout and timeout < self._wait_timeout:
            self._wait_timeout -= timeout
            raise subprocess.TimeoutExpired(self.args, timeout)
        await self._finalize(timeout)
        if self.returncode is None:
            raise exceptions.PluginInternalError
        return self.returncode

    def _get_empty_buffer(self, text: bool) -> asyncio.StreamReader:
        return asyncio.StreamReader()

    async def _reopen_streams(self) -> None:
        self.stdout = await self._reopen_stream(self.stdout)
        self.stderr = await self._reopen_stream(self.stderr)

    async def _reopen_stream(
        self, stream: Optional[BUFFER]
    ) -> Optional[asyncio.StreamReader]:
        if isinstance(stream, asyncio.StreamReader):
            data = await stream.read()
            fresh_stream = self._get_empty_buffer(False)
            fresh_stream.feed_data(data)
            return fresh_stream
        return None

    def run_thread(self) -> None:
        """Async impl should not contain any thread based implementation"""

    def evaluate(self) -> None:
        """Check if process needs to be finished."""
        if self._wait_timeout is None and self._callback is None:
            self._finish_process()

    async def _run_callback_in_executor(self) -> None:
        """Run in executor the user-defined callback or wait."""
        loop = asyncio.get_running_loop()
        with concurrent.futures.ThreadPoolExecutor() as pool:
            if self._callback:
                kwargs = self._callback_kwargs or {}
                cbk = partial(self._callback, **kwargs)
                await loop.run_in_executor(pool, cbk, self)
            elif self._wait_timeout is not None:
                await loop.run_in_executor(pool, self._wait, self._wait_timeout)

    async def _finalize(self, timeout: Optional[float] = None) -> None:
        """Run the user-defined callback or wait. Finish process"""
        if self.returncode is not None:
            return
        if timeout is not None:
            await asyncio.wait_for(self._run_callback_in_executor(), timeout=timeout)
        else:
            await self._run_callback_in_executor()
        if self.returncode is None:
            self.returncode = self._returncode
        self._finalize_streams()
