"""Python codec for CSS."""

import codecs
import functools
import marshal

# We're using bits to store all possible candidate encodings (or variants, i.e.
# we have two bits for the variants of UTF-16 and two for the
# variants of UTF-32).
#
# Prefixes for various CSS encodings
# UTF-8-SIG   xEF  xBB  xBF
# UTF-16 (LE) xFF  xFE ~x00|~x00
# UTF-16 (BE) xFE  xFF
# UTF-16-LE    @   x00   @   x00
# UTF-16-BE   x00   @
# UTF-32 (LE) xFF  xFE  x00  x00
# UTF-32 (BE) x00  x00  xFE  xFF
# UTF-32-LE    @   x00  x00  x00
# UTF-32-BE   x00  x00  x00   @
# CHARSET      @    c    h    a  ...


def chars(bytestring):
    return "".join(chr(byte) for byte in bytestring)


def detectencoding_str(input, final=False):  # noqa: C901
    """
    Detect the encoding of the byte string ``input``, which contains the
    beginning of a CSS file. This function returns the detected encoding (or
    ``None`` if it hasn't got enough data), and a flag that indicates whether
    that encoding has been detected explicitely or implicitely. To detect the
    encoding the first few bytes are used (or if ``input`` is ASCII compatible
    and starts with a charset rule the encoding name from the rule). "Explicit"
    detection means that the bytes start with a BOM or a charset rule.

    If the encoding can't be detected yet, ``None`` is returned as the encoding.
    ``final`` specifies whether more data will be available in later calls or
    not. If ``final`` is true, ``detectencoding_str()`` will never return
    ``None`` as the encoding.
    """

    # A bit for every candidate
    CANDIDATE_UTF_8_SIG = 1
    CANDIDATE_UTF_16_AS_LE = 2
    CANDIDATE_UTF_16_AS_BE = 4
    CANDIDATE_UTF_16_LE = 8
    CANDIDATE_UTF_16_BE = 16
    CANDIDATE_UTF_32_AS_LE = 32
    CANDIDATE_UTF_32_AS_BE = 64
    CANDIDATE_UTF_32_LE = 128
    CANDIDATE_UTF_32_BE = 256
    CANDIDATE_CHARSET = 512

    candidates = 1023  # all candidates

    # input = chars(input)
    li = len(input)
    if li >= 1:
        # Check first byte
        c = input[0]
        if c != b"\xef"[0]:
            candidates &= ~CANDIDATE_UTF_8_SIG
        if c != b"\xff"[0]:
            candidates &= ~(CANDIDATE_UTF_32_AS_LE | CANDIDATE_UTF_16_AS_LE)
        if c != b"\xfe"[0]:
            candidates &= ~CANDIDATE_UTF_16_AS_BE
        if c != b"@"[0]:
            candidates &= ~(
                CANDIDATE_UTF_32_LE | CANDIDATE_UTF_16_LE | CANDIDATE_CHARSET
            )
        if c != b"\x00"[0]:
            candidates &= ~(
                CANDIDATE_UTF_32_AS_BE | CANDIDATE_UTF_32_BE | CANDIDATE_UTF_16_BE
            )
        if li >= 2:
            # Check second byte
            c = input[1]
            if c != b"\xbb"[0]:
                candidates &= ~CANDIDATE_UTF_8_SIG
            if c != b"\xfe"[0]:
                candidates &= ~(CANDIDATE_UTF_16_AS_LE | CANDIDATE_UTF_32_AS_LE)
            if c != b"\xff"[0]:
                candidates &= ~CANDIDATE_UTF_16_AS_BE
            if c != b"\x00"[0]:
                candidates &= ~(
                    CANDIDATE_UTF_16_LE
                    | CANDIDATE_UTF_32_AS_BE
                    | CANDIDATE_UTF_32_LE
                    | CANDIDATE_UTF_32_BE
                )
            if c != b"@"[0]:
                candidates &= ~CANDIDATE_UTF_16_BE
            if c != b"c"[0]:
                candidates &= ~CANDIDATE_CHARSET
            if li >= 3:
                # Check third byte
                c = input[2]
                if c != b"\xbf"[0]:
                    candidates &= ~CANDIDATE_UTF_8_SIG
                if c != b"c"[0]:
                    candidates &= ~CANDIDATE_UTF_16_LE
                if c != b"\x00"[0]:
                    candidates &= ~(
                        CANDIDATE_UTF_32_AS_LE
                        | CANDIDATE_UTF_32_LE
                        | CANDIDATE_UTF_32_BE
                    )
                if c != b"\xfe"[0]:
                    candidates &= ~CANDIDATE_UTF_32_AS_BE
                if c != b"h"[0]:
                    candidates &= ~CANDIDATE_CHARSET
                if li >= 4:
                    # Check fourth byte
                    c = input[3]
                    if input[2:4] == b"\x00\x00"[0:2]:
                        candidates &= ~CANDIDATE_UTF_16_AS_LE
                    if c != b"\x00"[0]:
                        candidates &= ~(
                            CANDIDATE_UTF_16_LE
                            | CANDIDATE_UTF_32_AS_LE
                            | CANDIDATE_UTF_32_LE
                        )
                    if c != b"\xff"[0]:
                        candidates &= ~CANDIDATE_UTF_32_AS_BE
                    if c != b"@"[0]:
                        candidates &= ~CANDIDATE_UTF_32_BE
                    if c != b"a"[0]:
                        candidates &= ~CANDIDATE_CHARSET
    if candidates == 0:
        return ("utf-8", False)
    if not (candidates & (candidates - 1)):  # only one candidate remaining
        if candidates == CANDIDATE_UTF_8_SIG and li >= 3:
            return ("utf-8-sig", True)
        elif candidates == CANDIDATE_UTF_16_AS_LE and li >= 2:
            return ("utf-16", True)
        elif candidates == CANDIDATE_UTF_16_AS_BE and li >= 2:
            return ("utf-16", True)
        elif candidates == CANDIDATE_UTF_16_LE and li >= 4:
            return ("utf-16-le", False)
        elif candidates == CANDIDATE_UTF_16_BE and li >= 2:
            return ("utf-16-be", False)
        elif candidates == CANDIDATE_UTF_32_AS_LE and li >= 4:
            return ("utf-32", True)
        elif candidates == CANDIDATE_UTF_32_AS_BE and li >= 4:
            return ("utf-32", True)
        elif candidates == CANDIDATE_UTF_32_LE and li >= 4:
            return ("utf-32-le", False)
        elif candidates == CANDIDATE_UTF_32_BE and li >= 4:
            return ("utf-32-be", False)
        elif candidates == CANDIDATE_CHARSET and li >= 4:
            prefix = '@charset "'
            charsinput = chars(input)
            if charsinput[: len(prefix)] == prefix:
                pos = charsinput.find('"', len(prefix))
                if pos >= 0:
                    # TODO: return str and not bytes!
                    return (charsinput[len(prefix) : pos], True)
    # if this is the last call, and we haven't determined an encoding yet,
    # we default to UTF-8
    if final:
        return ("utf-8", False)
    return (None, False)  # dont' know yet


def detectencoding_unicode(input, final=False):
    """
    Detect the encoding of the unicode string ``input``, which contains the
    beginning of a CSS file. The encoding is detected from the charset rule
    at the beginning of ``input``. If there is no charset rule, ``"utf-8"``
    will be returned.

    If the encoding can't be detected yet, ``None`` is returned. ``final``
    specifies whether more data will be available in later calls or not. If
    ``final`` is true, ``detectencoding_unicode()`` will never return ``None``.
    """
    prefix = '@charset "'
    if input.startswith(prefix):
        pos = input.find('"', len(prefix))
        if pos >= 0:
            return (input[len(prefix) : pos], True)
    elif final or not prefix.startswith(input):
        # if this is the last call, and we haven't determined an encoding yet,
        # (or the string definitely doesn't start with prefix) we default to UTF-8
        return ("utf-8", False)
    return (None, False)  # don't know yet


def _fixencoding(input, encoding, final=False):
    """
    Replace the name of the encoding in the charset rule at the beginning of
    ``input`` with ``encoding``. If ``input`` doesn't starts with a charset
    rule, ``input`` will be returned unmodified.

    If the encoding can't be found yet, ``None`` is returned. ``final``
    specifies whether more data will be available in later calls or not.
    If ``final`` is true, ``_fixencoding()`` will never return ``None``.
    """
    prefix = '@charset "'
    if len(input) > len(prefix):
        if input.startswith(prefix):
            pos = input.find('"', len(prefix))
            if pos >= 0:
                if encoding.replace("_", "-").lower() == "utf-8-sig":
                    encoding = "utf-8"
                return prefix + encoding + input[pos:]
            # we haven't seen the end of the encoding name yet => fall through
        else:
            return input  # doesn't start with prefix, so nothing to fix
    elif not prefix.startswith(input) or final:
        # can't turn out to be a @charset rule later (or there is no "later")
        return input
    if final:
        return input
    return None  # don't know yet


def decode(input, errors="strict", encoding=None, force=True):
    try:
        # py 3 only, memory?! object to bytes
        input = input.tobytes()
    except AttributeError:
        pass

    if encoding is None or not force:
        (_encoding, explicit) = detectencoding_str(input, True)
        if _encoding == "css":
            raise ValueError("css not allowed as encoding name")
        if (
            explicit and not force
        ) or encoding is None:  # Take the encoding from the input
            encoding = _encoding

    # NEEDS: change in parse.py (str to bytes!)
    (input, consumed) = codecs.getdecoder(encoding)(input, errors)
    return (_fixencoding(input, str(encoding), True), consumed)


def encode(input, errors="strict", encoding=None):
    consumed = len(input)
    if encoding is None:
        encoding = detectencoding_unicode(input, True)[0]
        if encoding.replace("_", "-").lower() == "utf-8-sig":
            input = _fixencoding(input, "utf-8", True)
    else:
        input = _fixencoding(input, str(encoding), True)
    if encoding == "css":
        raise ValueError("css not allowed as encoding name")
    encoder = codecs.getencoder(encoding)
    return (encoder(input, errors)[0], consumed)


def _bytes2int(bytes):
    # Helper: convert an 8 bit string into an ``int``.
    i = 0
    for byte in bytes:
        i = (i << 8) + ord(byte)
    return i


def _int2bytes(i):
    # Helper: convert an ``int`` into an 8-bit string.
    v = []
    while i:
        v.insert(0, chr(i & 0xFF))
        i >>= 8
    return "".join(v)


class IncrementalDecoder(codecs.IncrementalDecoder):
    def __init__(self, errors="strict", encoding=None, force=True):
        self.decoder = None
        self.encoding = encoding
        self.force = force
        codecs.IncrementalDecoder.__init__(self, errors)
        # Store ``errors`` somewhere else,
        # because we have to hide it in a property
        self._errors = errors
        self.buffer = b""
        self.headerfixed = False

    def iterdecode(self, input):
        for part in input:
            result = self.decode(part, False)
            if result:
                yield result
        result = self.decode("", True)
        if result:
            yield result

    def decode(self, input, final=False):
        # We're doing basically the same as a ``BufferedIncrementalDecoder``,
        # but since the buffer is only relevant until the encoding has been
        # detected (in which case the buffer of the underlying codec might
        # kick in), we're implementing buffering ourselves to avoid some
        # overhead.
        if self.decoder is None:
            input = self.buffer + input
            # Do we have to detect the encoding from the input?
            if self.encoding is None or not self.force:
                (encoding, explicit) = detectencoding_str(input, final)
                if encoding is None:  # no encoding determined yet
                    self.buffer = input  # retry the complete input on the next call
                    return ""  # no encoding determined yet, so no output
                elif encoding == "css":
                    raise ValueError("css not allowed as encoding name")
                if (
                    explicit and not self.force
                ) or self.encoding is None:  # Take the encoding from the input
                    self.encoding = encoding
            self.buffer = ""  # drop buffer, as the decoder might keep its own
            decoder = codecs.getincrementaldecoder(self.encoding)
            self.decoder = decoder(self._errors)
        if self.headerfixed:
            return self.decoder.decode(input, final)
        # If we haven't fixed the header yet,
        # the content of ``self.buffer`` is a ``unicode`` object
        output = self.buffer + self.decoder.decode(input, final)
        encoding = self.encoding
        if encoding.replace("_", "-").lower() == "utf-8-sig":
            encoding = "utf-8"
        newoutput = _fixencoding(output, str(encoding), final)
        if newoutput is None:
            # retry fixing the @charset rule (but keep the decoded stuff)
            self.buffer = output
            return ""
        self.headerfixed = True
        return newoutput

    def reset(self):
        codecs.IncrementalDecoder.reset(self)
        self.decoder = None
        self.buffer = b""
        self.headerfixed = False

    def _geterrors(self):
        return self._errors

    def _seterrors(self, errors):
        # Setting ``errors`` must be done on the real decoder too
        if self.decoder is not None:
            self.decoder.errors = errors
        self._errors = errors

    errors = property(_geterrors, _seterrors)

    def getstate(self):
        if self.decoder is not None:
            state = (
                self.encoding,
                self.buffer,
                self.headerfixed,
                True,
                self.decoder.getstate(),
            )
        else:
            state = (self.encoding, self.buffer, self.headerfixed, False, None)
        return ("", _bytes2int(marshal.dumps(state)))

    def setstate(self, state):
        state = _int2bytes(marshal.loads(state[1]))  # ignore buffered input
        self.encoding = state[0]
        self.buffer = state[1]
        self.headerfixed = state[2]
        if state[3] is not None:
            self.decoder = codecs.getincrementaldecoder(self.encoding)(self._errors)
            self.decoder.setstate(state[4])
        else:
            self.decoder = None


class IncrementalEncoder(codecs.IncrementalEncoder):
    def __init__(self, errors="strict", encoding=None):
        self.encoder = None
        self.encoding = encoding
        codecs.IncrementalEncoder.__init__(self, errors)
        # Store ``errors`` somewhere else,
        # because we have to hide it in a property
        self._errors = errors
        self.buffer = ""

    def iterencode(self, input):
        for part in input:
            result = self.encode(part, False)
            if result:
                yield result
        result = self.encode("", True)
        if result:
            yield result

    def encode(self, input, final=False):
        if self.encoder is None:
            input = self.buffer + input
            if self.encoding is not None:
                # Replace encoding in the @charset rule with the specified one
                encoding = self.encoding
                if encoding.replace("_", "-").lower() == "utf-8-sig":
                    encoding = "utf-8"
                newinput = _fixencoding(input, str(encoding), final)
                if newinput is None:  # @charset rule incomplete => Retry next time
                    self.buffer = input
                    return ""
                input = newinput
            else:
                # Use encoding from the @charset declaration
                self.encoding = detectencoding_unicode(input, final)[0]
            if self.encoding is not None:
                if self.encoding == "css":
                    raise ValueError("css not allowed as encoding name")
                info = codecs.lookup(self.encoding)
                encoding = self.encoding
                if self.encoding.replace("_", "-").lower() == "utf-8-sig":
                    input = _fixencoding(input, "utf-8", True)
                self.encoder = info.incrementalencoder(self._errors)
                self.buffer = ""
            else:
                self.buffer = input
                return ""
        return self.encoder.encode(input, final)

    def reset(self):
        codecs.IncrementalEncoder.reset(self)
        self.encoder = None
        self.buffer = ""

    def _geterrors(self):
        return self._errors

    def _seterrors(self, errors):
        # Setting ``errors ``must be done on the real encoder too
        if self.encoder is not None:
            self.encoder.errors = errors
        self._errors = errors

    errors = property(_geterrors, _seterrors)

    def getstate(self):
        if self.encoder is not None:
            state = (self.encoding, self.buffer, True, self.encoder.getstate())
        else:
            state = (self.encoding, self.buffer, False, None)
        return _bytes2int(marshal.dumps(state))

    def setstate(self, state):
        state = _int2bytes(marshal.loads(state))
        self.encoding = state[0]
        self.buffer = state[1]
        if state[2] is not None:
            self.encoder = codecs.getincrementalencoder(self.encoding)(self._errors)
            self.encoder.setstate(state[4])
        else:
            self.encoder = None


class StreamWriter(codecs.StreamWriter):
    def __init__(self, stream, errors="strict", encoding=None, header=False):
        codecs.StreamWriter.__init__(self, stream, errors)
        self.streamwriter = None
        self.encoding = encoding
        self._errors = errors
        self.buffer = ""

    def encode(self, input, errors="strict"):
        li = len(input)
        if self.streamwriter is None:
            input = self.buffer + input
            li = len(input)
            if self.encoding is not None:
                # Replace encoding in the @charset rule with the specified one
                encoding = self.encoding
                if encoding.replace("_", "-").lower() == "utf-8-sig":
                    encoding = "utf-8"
                newinput = _fixencoding(input, str(encoding), False)
                if newinput is None:  # @charset rule incomplete => Retry next time
                    self.buffer = input
                    return ("", 0)
                input = newinput
            else:
                # Use encoding from the @charset declaration
                self.encoding = detectencoding_unicode(input, False)[0]
            if self.encoding is not None:
                if self.encoding == "css":
                    raise ValueError("css not allowed as encoding name")
                self.streamwriter = codecs.getwriter(self.encoding)(
                    self.stream, self._errors
                )
                encoding = self.encoding
                if self.encoding.replace("_", "-").lower() == "utf-8-sig":
                    input = _fixencoding(input, "utf-8", True)
                self.buffer = ""
            else:
                self.buffer = input
                return ("", 0)
        return (self.streamwriter.encode(input, errors)[0], li)

    def _geterrors(self):
        return self._errors

    def _seterrors(self, errors):
        # Setting ``errors`` must be done on the streamwriter too
        try:
            if self.streamwriter is not None:
                self.streamwriter.errors = errors
        except AttributeError:
            # TODO: py3 only exception?
            pass

        self._errors = errors

    errors = property(_geterrors, _seterrors)


class StreamReader(codecs.StreamReader):
    def __init__(self, stream, errors="strict", encoding=None, force=True):
        codecs.StreamReader.__init__(self, stream, errors)
        self.streamreader = None
        self.encoding = encoding
        self.force = force
        self._errors = errors

    def decode(self, input, errors="strict"):
        if self.streamreader is None:
            if self.encoding is None or not self.force:
                (encoding, explicit) = detectencoding_str(input, False)
                if encoding is None:  # no encoding determined yet
                    return ("", 0)  # no encoding determined yet, so no output
                elif encoding == "css":
                    raise ValueError("css not allowed as encoding name")
                if (
                    explicit and not self.force
                ) or self.encoding is None:  # Take the encoding from the input
                    self.encoding = encoding
            streamreader = codecs.getreader(self.encoding)
            streamreader = streamreader(self.stream, self._errors)
            (output, consumed) = streamreader.decode(input, errors)
            encoding = self.encoding
            if encoding.replace("_", "-").lower() == "utf-8-sig":
                encoding = "utf-8"
            newoutput = _fixencoding(output, str(encoding), False)
            if newoutput is not None:
                self.streamreader = streamreader
                return (newoutput, consumed)
            return ("", 0)  # we will create a new streamreader on the next call
        return self.streamreader.decode(input, errors)

    def _geterrors(self):
        return self._errors

    def _seterrors(self, errors):
        # Setting ``errors`` must be done on the streamreader too
        try:
            if self.streamreader is not None:
                self.streamreader.errors = errors
        except AttributeError:
            # TODO: py3 only exception?
            pass

        self._errors = errors

    errors = property(_geterrors, _seterrors)


@codecs.register
def search_function(name):
    if name != "css":
        return
    return codecs.CodecInfo(
        name="css",
        encode=encode,
        decode=decode,
        incrementalencoder=IncrementalEncoder,
        incrementaldecoder=IncrementalDecoder,
        streamwriter=StreamWriter,
        streamreader=StreamReader,
    )


@functools.partial(codecs.register_error, "cssescape")
def cssescape(exc):
    """
    Error handler for CSS escaping.
    """
    if not isinstance(exc, UnicodeEncodeError):
        raise TypeError("don't know how to handle %r" % exc)
    return (
        "".join("\\%06x" % ord(c) for c in exc.object[exc.start : exc.end]),
        exc.end,
    )