from __future__ import unicode_literals

from codecs import getincrementaldecoder
import os
import six
import select

__all__ = [
    'PosixStdinReader',
]


class PosixStdinReader(object):
    """
    Wrapper around stdin which reads (nonblocking) the next available 1024
    bytes and decodes it.

    Note that you can't be sure that the input file is closed if the ``read``
    function returns an empty string. When ``errors=ignore`` is passed,
    ``read`` can return an empty string if all malformed input was replaced by
    an empty string. (We can't block here and wait for more input.) So, because
    of that, check the ``closed`` attribute, to be sure that the file has been
    closed.

    :param stdin_fd: File descriptor from which we read.
    :param errors:  Can be 'ignore', 'strict' or 'replace'.
        On Python3, this can be 'surrogateescape', which is the default.

        'surrogateescape' is preferred, because this allows us to transfer
        unrecognised bytes to the key bindings. Some terminals, like lxterminal
        and Guake, use the 'Mxx' notation to send mouse events, where each 'x'
        can be any possible byte.
    """
    # By default, we want to 'ignore' errors here. The input stream can be full
    # of junk.  One occurrence of this that I had was when using iTerm2 on OS X,
    # with "Option as Meta" checked (You should choose "Option as +Esc".)

    def __init__(self, stdin_fd,
                 errors=('ignore' if six.PY2 else 'surrogateescape')):
        assert isinstance(stdin_fd, int)
        self.stdin_fd = stdin_fd
        self.errors = errors

        # Create incremental decoder for decoding stdin.
        # We can not just do `os.read(stdin.fileno(), 1024).decode('utf-8')`, because
        # it could be that we are in the middle of a utf-8 byte sequence.
        self._stdin_decoder_cls = getincrementaldecoder('utf-8')
        self._stdin_decoder = self._stdin_decoder_cls(errors=errors)

        #: True when there is nothing anymore to read.
        self.closed = False

    def read(self, count=1024):
            # By default we choose a rather small chunk size, because reading
            # big amounts of input at once, causes the event loop to process
            # all these key bindings also at once without going back to the
            # loop. This will make the application feel unresponsive.
        """
        Read the input and return it as a string.

        Return the text. Note that this can return an empty string, even when
        the input stream was not yet closed. This means that something went
        wrong during the decoding.
        """
        if self.closed:
            return u''

        # Check whether there is some input to read. `os.read` would block
        # otherwise.
        # (Actually, the event loop is responsible to make sure that this
        # function is only called when there is something to read, but for some
        # reason this happens in certain situations.)
        try:
            if not select.select([self.stdin_fd], [], [], 0)[0]:
                return u''
        except IOError:
            # Happens for instance when the file descriptor was closed.
            # (We had this in ptterm, where the FD became ready, a callback was
            # scheduled, but in the meantime another callback closed it already.)
            self.closed = True

        # Note: the following works better than wrapping `self.stdin` like
        #       `codecs.getreader('utf-8')(stdin)` and doing `read(1)`.
        #       Somehow that causes some latency when the escape
        #       character is pressed. (Especially on combination with the `select`.)
        try:
            data = os.read(self.stdin_fd, count)

            # Nothing more to read, stream is closed.
            if data == b'':
                self.closed = True
                return ''
        except OSError:
            # In case of SIGWINCH
            data = b''

        return self._stdin_decoder.decode(data)
