# this is a @hikariatama library, im modified this for my modules
# thk @hikariatama <3

import struct
from collections import deque
from html import escape
from html.parser import HTMLParser
from typing import Iterable, List, Optional, Tuple

from telethon import helpers
from telethon.tl.types import (
    MessageEntityBlockquote,
    MessageEntityBold,
    MessageEntityCode,
    MessageEntityEmail,
    MessageEntityItalic,
    MessageEntityMentionName,
    MessageEntityPre,
    MessageEntitySpoiler,
    MessageEntityStrike,
    MessageEntityTextUrl,
    MessageEntityUnderline,
    MessageEntityUrl,
    TypeMessageEntity,
    MessageEntityCustomEmoji,
)

from .. import loader


# Helpers from markdown.py
def _add_surrogate(text):
    return "".join(
        "".join(chr(y) for y in struct.unpack("<HH", x.encode("utf-16le")))
        if (0x10000 <= ord(x) <= 0x10FFFF)
        else x
        for x in text
    )


def _del_surrogate(text):
    return text.encode("utf-16", "surrogatepass").decode("utf-16")


class HTMLToTelegramParser(HTMLParser):
    def __init__(self):
        super().__init__()
        self.text = ""
        self.entities = []
        self._building_entities = {}
        self._open_tags = deque()
        self._open_tags_meta = deque()

    def handle_starttag(self, tag, attrs):
        self._open_tags.appendleft(tag)
        self._open_tags_meta.appendleft(None)

        attrs = dict(attrs)
        EntityType = None
        args = {}
        if tag in ["strong", "b"]:
            EntityType = MessageEntityBold
        elif tag in ["em", "i"]:
            EntityType = MessageEntityItalic
        elif tag in ["tg-spoiler"]:
            EntityType = MessageEntitySpoiler
        elif tag == "u":
            EntityType = MessageEntityUnderline
        elif tag in ["del", "s"]:
            EntityType = MessageEntityStrike
        elif tag == "blockquote":
            EntityType = MessageEntityBlockquote
        elif tag == "code":
            try:
                # If we're in the middle of a <pre> tag, this <code> tag is
                # probably intended for syntax highlighting.
                #
                # Syntax highlighting is set with
                #     <code class='language-...'>codeblock</code>
                # inside <pre> tags
                pre = self._building_entities["pre"]
                try:
                    pre.language = attrs["class"][len("language-") :]
                except KeyError:
                    pass
            except KeyError:
                EntityType = MessageEntityCode
        # @vsecoder append start #
        elif tag == "emoji":
            try:
                # Emoji have document_id parameter
                # <emoji document_id="...">❤️</emoji>
                emoji = self._building_entities["emoji"]
                try:
                    emoji.document_id = attrs["document_id"]
                except KeyError:
                    pass
            except KeyError:
                EntityType = MessageEntityCode
        # @vsecoder append end #
        elif tag == "pre":
            EntityType = MessageEntityPre
            args["language"] = ""
        elif tag == "a":
            try:
                url = attrs["href"]
            except KeyError:
                return
            if url.startswith("mailto:"):
                url = url[len("mailto:") :]
                EntityType = MessageEntityEmail
            elif self.get_starttag_text() == url:
                EntityType = MessageEntityUrl
            else:
                EntityType = MessageEntityTextUrl
                args["url"] = url
                url = None
            self._open_tags_meta.popleft()
            self._open_tags_meta.appendleft(url)

        if EntityType and tag not in self._building_entities:
            self._building_entities[tag] = EntityType(
                offset=len(self.text),
                # The length will be determined when closing the tag.
                length=0,
                **args,
            )

    def handle_data(self, text):
        previous_tag = self._open_tags[0] if len(self._open_tags) > 0 else ""
        if previous_tag == "a":
            if url := self._open_tags_meta[0]:
                text = url

        for tag, entity in self._building_entities.items():
            entity.length += len(text)

        self.text += text

    def handle_endtag(self, tag):
        try:
            self._open_tags.popleft()
            self._open_tags_meta.popleft()
        except IndexError:
            pass
        if entity := self._building_entities.pop(tag, None):
            self.entities.append(entity)


class HTMLParserLib(loader.Library):
    developer = "@hikariatama" # and @vsecoder
    version = (2, 0, 0)

    def parse(self, html: str) -> Tuple[str, List[TypeMessageEntity]]:
        """
        Parses the given HTML message and returns its stripped representation
        plus a list of the MessageEntity's that were found.
        :param html: the message with HTML to be parsed.
        :return: a tuple consisting of (clean message, [message entities]).
        """
        if not html:
            return html, []

        parser = HTMLToTelegramParser()
        parser.feed(_add_surrogate(html))
        text = helpers.strip_text(parser.text, parser.entities)
        return _del_surrogate(text), parser.entities

    def unparse(
        self,
        text: str,
        entities: Iterable[TypeMessageEntity],
        _offset: int = 0,
        _length: Optional[int] = None,
    ) -> str:
        """
        Performs the reverse operation to .parse(), effectively returning HTML
        given a normal text and its MessageEntity's.
        :param text: the text to be reconverted into HTML.
        :param entities: the MessageEntity's applied to the text.
        :return: a HTML representation of the combination of both inputs.
        """
        if not text:
            return text
        elif not entities:
            return escape(text)

        text = _add_surrogate(text)
        if _length is None:
            _length = len(text)
        html = []
        last_offset = 0
        for i, entity in enumerate(entities):
            if entity.offset >= _offset + _length:
                break
            relative_offset = entity.offset - _offset
            if relative_offset > last_offset:
                html.append(escape(text[last_offset:relative_offset]))
            elif relative_offset < last_offset:
                continue

            skip_entity = False
            length = entity.length

            # If we are in the middle of a surrogate nudge the position by +1.
            # Otherwise we would end up with malformed text and fail to encode.
            # For example of bad input: "Hi \ud83d\ude1c"
            # https://en.wikipedia.org/wiki/UTF-16#U+010000_to_U+10FFFF
            while helpers.within_surrogate(text, relative_offset, length=_length):
                relative_offset += 1

            while helpers.within_surrogate(
                text, relative_offset + length, length=_length
            ):
                length += 1

            entity_text = self.unparse(
                text=text[relative_offset : relative_offset + length],
                entities=entities[i + 1 :],
                _offset=entity.offset,
                _length=length,
            )
            entity_type = type(entity)

            if entity_type == MessageEntityBold:
                html.append("<strong>{}</strong>".format(entity_text))
            elif entity_type == MessageEntityItalic:
                html.append("<em>{}</em>".format(entity_text))
            elif entity_type == MessageEntitySpoiler:
                html.append("<tg-spoiler>{}</tg-spoiler>".format(entity_text))
            elif entity_type == MessageEntityCode:
                html.append("<code>{}</code>".format(entity_text))
            elif entity_type == MessageEntityUnderline:
                html.append("<u>{}</u>".format(entity_text))
            elif entity_type == MessageEntityStrike:
                html.append("<del>{}</del>".format(entity_text))
            elif entity_type == MessageEntityBlockquote:
                html.append("<blockquote>{}</blockquote>".format(entity_text))
            elif entity_type == MessageEntityPre:
                if entity.language:
                    html.append(
                        "<pre>\n"
                        "    <code class='language-{}'>\n"
                        "        {}\n"
                        "    </code>\n"
                        "</pre>".format(entity.language, entity_text)
                    )
                else:
                    html.append("<pre><code>{}</code></pre>".format(entity_text))
            # @vsecoder append start
            elif entity_type == MessageEntityCustomEmoji:
                html.append('<emoji document_id="{}">{}</emoji>'.format(entity.document_id, entity_text))
            # @vsecoder append end
            elif entity_type == MessageEntityEmail:
                html.append('<a href="mailto:{0}">{0}</a>'.format(entity_text))
            elif entity_type == MessageEntityUrl:
                html.append('<a href="{0}">{0}</a>'.format(entity_text))
            elif entity_type == MessageEntityTextUrl:
                html.append(
                    '<a href="{}">{}</a>'.format(escape(entity.url), entity_text)
                )
            elif entity_type == MessageEntityMentionName:
                html.append(
                    '<a href="tg://user?id={}">{}</a>'.format(
                        entity.user_id, entity_text
                    )
                )
            else:
                skip_entity = True
            last_offset = relative_offset + (0 if skip_entity else length)

        while helpers.within_surrogate(text, last_offset, length=_length):
            last_offset += 1

        html.append(escape(text[last_offset:]))
        return _del_surrogate("".join(html))