import re
from typing import TYPE_CHECKING, List, Match, Optional

from ._base import BaseDirective, DirectiveParser, DirectivePlugin

if TYPE_CHECKING:
    from ..block_parser import BlockParser
    from ..core import BlockState
    from ..markdown import Markdown


__all__ = ["FencedDirective"]


_type_re = re.compile(r"^ *\{[a-zA-Z0-9_-]+\}")
_directive_re = re.compile(
    r"\{(?P<type>[a-zA-Z0-9_-]+)\} *(?P<title>[^\n]*)(?:\n|$)"
    r"(?P<options>(?:\:[a-zA-Z0-9_-]+\: *[^\n]*\n+)*)"
    r"\n*(?P<text>(?:[^\n]*\n+)*)"
)


class FencedParser(DirectiveParser):
    name = "fenced_directive"

    @staticmethod
    def parse_type(m: Match[str]) -> str:
        return m.group("type")

    @staticmethod
    def parse_title(m: Match[str]) -> str:
        return m.group("title")

    @staticmethod
    def parse_content(m: Match[str]) -> str:
        return m.group("text")


class FencedDirective(BaseDirective):
    """A **fenced** style of directive looks like a fenced code block, it is
    inspired by markdown-it-docutils. The syntax looks like:

    .. code-block:: text

        ```{directive-type} title
        :option-key: option value
        :option-key: option value

        content text here
        ```

    To use ``FencedDirective``, developers can add it into plugin list in
    the :class:`Markdown` instance:

    .. code-block:: python

        import mistune
        from mistune.directives import FencedDirective, Admonition

        md = mistune.create_markdown(plugins=[
            # ...
            FencedDirective([Admonition()]),
        ])

    FencedDirective is using >= 3 backticks or curly-brackets for the fenced
    syntax. Developers can change it to other characters, e.g. colon:

    .. code-block:: python

            directive = FencedDirective([Admonition()], ':')

    And then the directive syntax would look like:

    .. code-block:: text

        ::::{note} Nesting directives
        You can nest directives by ensuring the start and end fence matching
        the length. For instance, in this example, the admonition is started
        with 4 colons, then it should end with 4 colons.

        You can nest another admonition with other length of colons except 4.

        :::{tip} Longer outermost fence
        It would be better that you put longer markers for the outer fence,
        and shorter markers for the inner fence. In this example, we put 4
        colons outsie, and 3 colons inside.
        :::
        ::::

    :param plugins: list of directive plugins
    :param markers: characters to determine the fence, default is backtick
                    and curly-bracket
    """

    parser = FencedParser

    def __init__(self, plugins: List[DirectivePlugin], markers: str = "`~") -> None:
        super(FencedDirective, self).__init__(plugins)
        self.markers = markers
        _marker_pattern = "|".join(re.escape(c) for c in markers)
        self.directive_pattern = (
            r"^(?P<fenced_directive_mark>(?:" + _marker_pattern + r"){3,})"
            r"\{[a-zA-Z0-9_-]+\}"
        )

    def _process_directive(self, block: "BlockParser", marker: str, start: int, state: "BlockState") -> Optional[int]:
        mlen = len(marker)
        cursor_start = start + len(marker)

        _end_pattern = (
            r"^ {0,3}" + marker[0] + "{" + str(mlen) + r",}"
            r"[ \t]*(?:\n|$)"
        )
        _end_re = re.compile(_end_pattern, re.M)

        _end_m = _end_re.search(state.src, cursor_start)
        if _end_m:
            text = state.src[cursor_start : _end_m.start()]
            end_pos = _end_m.end()
        else:
            text = state.src[cursor_start:]
            end_pos = state.cursor_max

        m = _directive_re.match(text)
        if not m:
            return None

        self.parse_method(block, m, state)
        return end_pos

    def parse_directive(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
        marker = m.group("fenced_directive_mark")
        return self._process_directive(block, marker, m.start(), state)

    def parse_fenced_code(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
        info = m.group("fenced_3")
        if not info or not _type_re.match(info):
            return block.parse_fenced_code(m, state)

        if state.depth() >= block.max_nested_level:
            return block.parse_fenced_code(m, state)

        marker = m.group("fenced_2")
        return self._process_directive(block, marker, m.start(), state)

    def __call__(self, md: "Markdown") -> None:
        super(FencedDirective, self).__call__(md)
        if self.markers == "`~":
            md.block.register("fenced_code", None, self.parse_fenced_code)
        else:
            self.register_block_parser(md, "fenced_code")