"""

Adapted from pymdownx.tabbed (https://github.com/facelessuser/pymdown-extensions/)

"""

import re

import xml.etree.ElementTree as etree

from markdown import Extension

from markdown.blockprocessors import BlockProcessor

from markdown.extensions.attr_list import AttrListTreeprocessor, get_attrs

def assign_attrs(elem, attrs):

    """Assign `attrs` to element."""

    for k, v in get_attrs(attrs):

        if k == ".":

            # add to class

            cls = elem.get("class")

            if cls:

                elem.set("class", "{} {}".format(cls, v))

            else:

                elem.set("class", v)

        else:

            # assign attribute `k` with `v`

            elem.set(AttrListTreeprocessor.NAME_RE.sub("_", k), v)

class CardProcessor(BlockProcessor):

    """card block processor."""

    START = re.compile(r"(?:^|\n)={3} *(card)?(?: +({:.*?}) *(?:\n|$))?")

    COMPRESS_SPACES = re.compile(r" {2,}")

    def __init__(self, parser, config):

        """Initialize."""

        super().__init__(parser)

        self.card_group_count = 0

        self.current_sibling = None

        self.content_indention = 0

    def detab_by_length(self, text, length):

        """Remove a card from the front of each line of the given text."""

        newtext = []

        lines = text.split("\n")

        for line in lines:

            if line.startswith(" " * length):

                newtext.append(line[length:])

            elif not line.strip():

                newtext.append("")  # pragma: no cover

            else:

                break

        return "\n".join(newtext), "\n".join(lines[len(newtext) :])

    def parse_content(self, parent, block):

        """

        Get sibling card.

        Retrieve the appropriate sibling element. This can get tricky when

        dealing with lists.

        """

        old_block = block

        non_cards = ""

        card_set = "card-set"

        # We already acquired the block via test

        if self.current_sibling is not None:

            sibling = self.current_sibling

            block, non_cards = self.detab_by_length(block, self.content_indent)

            self.current_sibling = None

            self.content_indent = 0

            return sibling, block, non_cards

        sibling = self.lastChild(parent)

        if (

            sibling is None

            or sibling.tag.lower() != "div"

            or sibling.attrib.get("class", "") != card_set

        ):

            sibling = None

        else:

            # If the last child is a list and the content is indented sufficient

            # to be under it, then the content's is sibling is in the list.

            last_child = self.lastChild(sibling)

            card_content = "card-content"

            child_class = (

                last_child.attrib.get("class", "") if last_child is not None else ""

            )

            indent = 0

            while last_child is not None:

                if (

                    sibling is not None

                    and block.startswith(" " * self.tab_length * 2)

                    and last_child is not None

                    and (

                        last_child.tag in ("ul", "ol", "dl")

                        or (last_child.tag == "div" and child_class == card_content)

                    )

                ):

                    # Handle nested card content

                    if last_child.tag == "div" and child_class == card_content:

                        temp_child = self.lastChild(last_child)

                        if temp_child is None or temp_child.tag not in (

                            "ul",

                            "ol",

                            "dl",

                        ):

                            break

                        last_child = temp_child

                    # The expectation is that we'll find an `<li>`.

                    # We should get it's last child as well.

                    sibling = self.lastChild(last_child)

                    last_child = (

                        self.lastChild(sibling) if sibling is not None else None

                    )

                    child_class = (

                        last_child.attrib.get("class", "")

                        if last_child is not None

                        else ""

                    )

                    # Context has been lost at this point, so we must adjust the

                    # text's indentation level so it will be evaluated correctly

                    # under the list.

                    block = block[self.tab_length :]

                    indent += self.tab_length

                else:

                    last_child = None

            if not block.startswith(" " * self.tab_length):

                sibling = None

            if sibling is not None:

                indent += self.tab_length

                block, non_cards = self.detab_by_length(old_block, indent)

                self.current_sibling = sibling

                self.content_indent = indent

        return sibling, block, non_cards

    def test(self, parent, block):

        """Test block."""

        if self.START.search(block):

            return True

        else:

            return self.parse_content(parent, block)[0] is not None

    def run(self, parent, blocks):

        """Convert to card block."""

        block = blocks.pop(0)

        m = self.START.search(block)

        card_set = "card-set"

        if m:

            # removes the first line

            if m.start() > 0:

                self.parser.parseBlocks(parent, [block[: m.start()]])

            block = block[m.end() :]

            sibling = self.lastChild(parent)

            block, non_cards = self.detab(block)

        else:

            sibling, block, non_cards = self.parse_content(parent, block)

        if m:

            if (

                sibling is not None

                and sibling.tag.lower() == "div"

                and sibling.attrib.get("class", "") == card_set

            ):

                card_group = sibling

            else:

                self.card_group_count += 1

                card_group = etree.SubElement(

                    parent,

                    "div",

                    {

                        "class": card_set,

                        "data-cards": "%d:0" % self.card_group_count,

                    },

                )

            data = card_group.attrib["data-cards"].split(":")

            card_set = int(data[0])

            card_count = int(data[1]) + 1

            div = etree.SubElement(

                card_group,

                "div",

                {

                    "class": "card-content",

                },

            )

            attributes = m.group(2)

            if attributes:

                attr_m = AttrListTreeprocessor.INLINE_RE.search(attributes)

                if attr_m:

                    assign_attrs(div, attr_m.group(1))

                    if div.get("href"):

                        div.tag = "a"

            card_group.attrib["data-cards"] = "%d:%d" % (card_set, card_count)

        else:

            if sibling.tag in ("li", "dd") and sibling.text:

                # Sibling is a list item, but we need to wrap it's content should be

                # wrapped in <p>

                text = sibling.text

                sibling.text = ""

                p = etree.SubElement(sibling, "p")

                p.text = text

                div = sibling

            elif sibling.tag == "div" and sibling.attrib.get("class", "") == card_set:

                # Get `card-content` under `card-set`

                div = self.lastChild(sibling)

            else:

                # Pass anything else as the parent

                div = sibling

        self.parser.parseChunk(div, block)

        if non_cards:

            # Insert the card content back into blocks

            blocks.insert(0, non_cards)

class CardExtension(Extension):

    """Add card extension."""

    def __init__(self, *args, **kwargs):

        """Initialize."""

        self.config = {

            "slugify": [

                0,

                "Slugify function used to create card specific IDs - Default: None",

            ],

            "combine_header_slug": [

                False,

                "Combine the card slug with the slug of the parent header - "

                "Default: False",

            ],

            "separator": ["-", "Slug separator - Default: '-'"],

        }

        super(CardExtension, self).__init__(*args, **kwargs)

    def extendMarkdown(self, md):

        """Add card to Markdown instance."""

        md.registerExtension(self)

        config = self.getConfigs()

        self.card_processor = CardProcessor(md.parser, config)

        md.parser.blockprocessors.register(

            self.card_processor,

            "card",

            105,

        )

    def reset(self):

        """Reset."""

        self.card_processor.card_group_count = 0

def makeExtension(*args, **kwargs):

    """Return extension."""

    return CardExtension(*args, **kwargs)