class ErrorBlock(BaseModel):
    """This object represents a portion of the markdown document
    that gave rise to parsing errors.

    Important functions:
    serialize()     a textual representation of the error
    get_content()   the string with the error description
    self.origin     the markdown text that gave rise to the error

    Note:
        ErrorBlocks use identity equality (is) rather than value
        equality (==). This ensures that error instances remain
        distinct even when they have identical content, which is
        important for tracking multiple similar errors separately.
    """

    content: str = ""
    errormsg: str = ""
    origin: str = ""
    type: Literal['error'] = 'error'

    def __eq__(self, obj: object) -> bool:
        return self is obj

    def __ne__(self, obj: object) -> bool:
        return not self.__eq__(obj)

    def serialize(self) -> str:
        """A textual representation of the error. When parsed, it will
        reconstitute the markdown text that gave rise to the error."""
        content = "** ERROR: " + self.content + "**\n"
        if self.errormsg:
            content += self.errormsg + "\n"
        if self.origin:
            content += "\n" + self.origin + "\n\n"
        return content

    def get_info(self) -> str:
        """Printable block properties and content."""
        info = "\n-------------\nError block\n"
        info += self.content
        info = info if info else "empty error block"
        return info

    def get_content(self) -> str:
        """Returns the error message"""
        return self.content

    def deep_copy(self) -> 'ErrorBlock':
        return self.model_copy(deep=True)

class HeaderBlock(MetadataBlock):
    """This object represents the header block of a markdown document.
    It is the first block of the block list obtained from loading a
    markdown file with load_markdown.
    The behaviour of functions in this package when a header block is
    is inserted by code in a position other than the first is
    undefined.

    Important functions:
    serialize()     reconstitute a text representation of the metadata
    get_content()   the metadata
    get_key(key, default) a metadata value indexed by key
    """

    type: Literal['header'] = 'header'  # type: ignore

    def get_info(self) -> str:
        """Printable block properties and content."""
        info = "\n-------------\nHeader block"
        info += f" # {self.comment}\n" if self.comment else "\n"
        info += (
            pya.dump_yaml(self.content) if self.content else "<empty>"
        )
        if self.private_:
            info += "\n\nAdditional data:" + pya.dump_yaml(
                self.private_
            )
        return info

    def deep_copy(self) -> 'HeaderBlock':
        return self.model_copy(deep=True)

    @staticmethod
    def _from_metadata_block(
        block: MetadataBlock,
    ) -> 'HeaderBlock':
        if 'title' not in block.content:
            block.content['title'] = "Title"
        hblock = HeaderBlock(
            content=block.content,
            comment=block.comment,
            private_=block.private_,
        )
        return hblock

    @staticmethod
    def _from_tokens(
        stack: list[tuple['Token', str]],
        mapped_keys: Mapping[str, str] | None = None,
    ) -> 'HeaderBlock | ErrorBlock':
        block = MetadataBlock._from_tokens(stack, mapped_keys)
        if isinstance(block, MetadataBlock):
            return HeaderBlock._from_metadata_block(block)
        return block

    @staticmethod
    def _from_dict(
        dct: MetadataDict | dict[object, object],
    ) -> 'HeaderBlock|ErrorBlock':
        block = MetadataBlock._from_dict(dct)
        match block:
            case ErrorBlock():
                return block
            case MetadataBlock():
                return HeaderBlock._from_metadata_block(block)

    @staticmethod
    def from_default(source: str = "") -> 'HeaderBlock':
        """Instantiate a default header block."""
        if not source:
            source = "Title"
        return HeaderBlock(content={'title': source})

class HeadingBlock(BaseModel):
    """This object represents a heading of the markdown document.
    A heading is a single line starting with one to six '#'
    characters followed by a space, and the title text.

    Important functions:
    serialize()     reconstitutes a text representation of the heading
    get_content()   the title given by the heading text
    """

    level: int
    content: str
    attributes: str = ""
    type: Literal['heading'] = 'heading'

    def __eq__(self, obj: object) -> bool:
        if not isinstance(obj, HeadingBlock):
            return False
        if not (
            self.level == obj.level
            and self.content == obj.content
            and self.attributes == obj.attributes
        ):
            return False
        return True

    def __ne__(self, obj: object) -> bool:
        return not self.__eq__(obj)

    def serialize(self) -> str:
        """A parsable textual representation of the block."""
        strrep = "#" * self.level + " " + self.content
        if self.attributes:
            strrep = strrep + " {" + self.attributes + "}"
        return strrep + "\n"

    def get_info(self) -> str:
        """Printable block properties and content."""
        info = "\n-------------\nHeading block\n"
        info += str(self.content) if self.content else "<empty>"
        return info

    def get_content(self) -> str:
        """Returns the heading text"""
        return self.content

    def deep_copy(self) -> 'HeadingBlock':
        return self.model_copy(deep=True)

    @staticmethod
    def _from_tokens(
        stack: list[tuple['Token', str]],
    ) -> 'HeadingBlock | ErrorBlock':
        # we assume that this is a single token with a heading content
        if len(stack) > 1:
            # throw error: this should not happen
            raise RuntimeError(
                "Unexpected token stack: Heading block should only "
                + "contain one line"
            )

        content = stack[0][1]

        # empty heading
        m = re.match(r'^#{1,6}\s*$', content)
        if m:
            return ErrorBlock(
                content="Empty heading content (a series of '#'"
                + " followed by space)",
                origin=content,
            )

        # check attributes: text delimited by '{' '}' at end of line
        m = re.search(r'\s+\{(.*?)\}\s*$', content)
        if m:
            # Extract the content before the attributes
            content = content[: m.start()].strip()
            attr_text = m.group(1).strip()
        else:
            attr_text = ""

        # parse heading at last, 1 to 6 '#' (guaranteed by
        # tokenization) followed by space and text
        m = re.search(r'^(#+)\s+(.+)', content)
        if not m:
            if attr_text:
                return ErrorBlock(
                    content="The heading specifies attributes, but "
                    + "there is no heading text",
                    origin=stack[0][1],
                )
            else:
                return ErrorBlock(
                    content="Cannot parse heading content",
                    origin=stack[0][1],
                )
        try:
            block = HeadingBlock(
                level=len(m.group(1)),
                content=m.group(2).strip(),
                attributes=attr_text,
            )
        except Exception as e:
            return ErrorBlock(
                content="Could not parse heading",
                errormsg=str(e),
                origin=stack[0][1],
            )
        return block

class MetadataBlock(BaseModel):
    """This object represents the data of a metadata block in a
    markdown document.

    Important functions:
    serialize()     reconstitute a text representation of the metadata
    get_content()   the metadata
    get_key(key, default) a metadata value indexed by key
    """

    content: MetadataDict = {}
    comment: str = ""
    private_: list[object] = []
    type: Literal['metadata'] = 'metadata'

    def __eq__(self, obj: object) -> bool:
        if not isinstance(obj, MetadataBlock | HeaderBlock):
            return False
        if not (
            self.content == obj.content
            and self.comment == obj.comment
        ):
            return False
        if len(self.private_) != len(obj.private_):
            return False
        for i, d in enumerate(self.private_):
            try:
                if not d == obj.private_[i]:
                    return False
            except Exception:
                # Comparison may fail for complex objects
                return False
        return True

    def __ne__(self, obj: object) -> bool:
        return not self.__eq__(obj)

    def serialize(self) -> str:
        """A parsable textual representation of the block."""
        strrep = "---"
        if self.comment:
            strrep = strrep + " # " + self.comment
        # reconstitute original yaml block (see parse_yaml.py)
        content: str = pya.serialize_yaml_parse(
            (self.content, self.private_)
        )
        strrep = strrep + '\n' + content
        return strrep + "---\n"

    def get_info(self) -> str:
        """Printable block properties and content."""
        info = "\n-------------\nMetadata block"
        info += f" # {self.comment}\n" if self.comment else "\n"
        info += (
            pya.dump_yaml(self.content) if self.content else "<empty>"
        )
        if self.private_:
            info += "\n\nAdditional data:\n" + pya.dump_yaml(
                self.private_
            )
        return info

    def get_content(self) -> MetadataDict:
        """Returns a dictionary with the metadata."""
        return self.content

    def get_key(
        self, key: str, default: MetadataValue = None
    ) -> MetadataValue:
        """Returns the value of a key in the metadata."""
        return (
            self.content[key]
            if key in self.content.keys()
            else default
        )

    def get_key_type(
        self, key: str, value_type: type[T], default: T
    ) -> T:
        """Get a metadata value if of type T. The argument
        default must be given.

        Args:
            key: the key (a string)
            value_type: the type of the value. Due to the limitations
                of the Python type system, no algebraic or parametric
                type may be used here.
            default: (of type value_type) a default return value.

        Returns:
            a value of type value_type.

        Note:
            To code for a checkable None (but violate the type model)
            ```python
            value = get_key_type('title', str | None, None)
            ```
            Here, value is of type str | None, and the function will
            return None if 'title' is not found or is not a
            string.
        """
        value: MetadataValue = (
            self.content[key] if key in self.content.keys() else None
        )
        if isinstance(value, value_type):
            return value
        else:
            return default

    def deep_copy(self) -> 'MetadataBlock':
        return self.model_copy(deep=True)

    @staticmethod
    def _from_tokens(
        stack: list[tuple['Token', str]],
        mapped_keys: Mapping[str, str] | None = None,
    ) -> 'MetadataBlock | ErrorBlock':
        if not stack:
            # this is a programming error
            raise ValueError(
                "Invalid call to _from_tokens with empty list."
            )

        # check for comments
        comment_match = stack[0][1].strip().split('#', 1)
        comment = (
            comment_match[1].strip() if len(comment_match) > 1 else ''
        )

        # we assume the first and last tokens to be metadata markers
        content = '\n'.join([y for (_, y) in stack[1:-1]])

        # Check YAML content size to prevent YAML bombs
        if len(content) > MAX_YAML_BLOCK_SIZE:
            offending_meta = '\n'.join([y for (_, y) in stack])
            return ErrorBlock(
                content=f"Metadata block too large ({len(content)} bytes, max {MAX_YAML_BLOCK_SIZE})",
                origin=offending_meta[:500] + "..." if len(offending_meta) > 500 else offending_meta,
            )

        # first use yaml parser, catching any error
        try:
            yamldata: Any = yaml.safe_load(content)
        except yaml.YAMLError as e:
            offending_meta = '\n'.join([y for (_, y) in stack])
            return ErrorBlock(
                content="\nYAML parse error in metadata block.",
                errormsg=str(e),
                origin=offending_meta,
            )

        # this returns the part of the yaml block that we want to
        # use here in 'part', the rest of the block in 'whole'.
        # See parse_yaml.py for explanation.
        try:
            part: dict[str, MetadataValue]
            whole: list[object]
            part, whole = pya.split_yaml_parse(yamldata, mapped_keys)
        except ValueError as e:
            # These are metadata fields rejected by split_yaml_parse
            offending_meta = '\n'.join([y for (_, y) in stack])
            return ErrorBlock(
                content="Invalid markdown header.",
                errormsg=str(e),
                origin=offending_meta,
            )

        if (not part) and (not whole):
            return ErrorBlock(
                content="Invalid or empty metadata block.",
                origin="---\n---",
            )
        # We should be able to cope with this now
        # if not part:
        #     invalid_meta = '\n'.join([y for (_, y) in stack])
        #     return ErrorBlock(
        #         content="Metadata contains a dictionary or a list"
        #         + "of dictionaries that not acceptable for use in"
        #         + " LM markdown",
        #         origin=invalid_meta,
        #     )

        try:
            block = MetadataBlock(
                content=part, private_=whole, comment=comment
            )
        except (ValidationError, TypeError, ValueError, KeyError):
            # First fallback: try to store in private_ field
            try:
                block = MetadataBlock(
                    content={},
                    private_=[part] + whole,
                    comment=(
                        "Invalid (too deeply nested?) metadata, "
                        "ignored by model."
                    )
                )
            except ValidationError:
                # Pydantic errors ensue from nested dictionaries
                return ErrorBlock(
                    content="Could not parse metadata:"
                    + " YAML object type not supported.",
                    errormsg="",  # a convoluted pydantic message
                    origin='\n'.join([y for (_, y) in stack]),
                )
            except (TypeError, ValueError, KeyError) as e:
                return ErrorBlock(
                    content="Could not parse metadata.",
                    errormsg=str(e),
                    origin='\n'.join([y for (_, y) in stack]),
                )
        return block

    @staticmethod
    def _from_dict(
        dct: MetadataDict | dict[object, object],
    ) -> 'MetadataBlock|ErrorBlock':
        if not pya.is_metadata_dict(dct):
            return ErrorBlock(content="Invalid data for metadata.")
        # now dct is a metadata dict
        try:
            block = MetadataBlock(content=dct)
        except ValidationError:
            # This is a pydantic type error
            return ErrorBlock(
                content="Invalid dictionary for metadata "
                + "(too deep nesting, or invalid data types)."
            )
        except Exception as e:
            return ErrorBlock(
                content="Invalid dictionary for metadata",
                errormsg=str(e),
            )
        return block

class TextBlock(BaseModel):
    """This object represents a text block from the markdown document.
    The text block starts after a heading, a metadata block, or a
    blank line, and ends with a blank line or the end of the document.

    Important functions:
    serialize()     reconstitutes a text representation of the block
    get_content()   returns a string with the text content
    extend()        extends the text with that of another text block
    """

    content: str
    type: Literal['text'] = 'text'

    def __eq__(self, obj: object) -> bool:
        if not isinstance(obj, TextBlock):
            return False
        if not self.content == obj.content:
            return False
        return True

    def __ne__(self, obj: object) -> bool:
        return not self.__eq__(obj)

    def serialize(self) -> str:
        """A parsable textual representation of the block."""
        return self.content + "\n"

    def get_info(self) -> str:
        """Printable block properties and content."""
        info = "\n-------------\nText block\n"
        if self.content:
            content = self.content.split()
            if len(content) > MAX_INFO_WORDS:
                content = content[:MAX_INFO_WORDS - 1] + ["..."]
            info += " ".join(content) if content else "<empty>"
        else:
            info += "<empty>"
        return info

    def get_word_count(self) -> int:
        """Get the word count in the text block"""
        return len(self.content.split())

    def get_content(self) -> str:
        """Returns the text of the text block"""
        return self.content

    def is_empty(self) -> bool:
        return not self.content

    def extend(self, text: 'str | TextBlock') -> 'TextBlock':
        """Extend the content of the block with new text of with
        the content of another text block. The new content is
        added at the end of the block.
        Returns: a (reference to) the modified block."""
        value: str
        match text:
            case str():
                value = text
            case TextBlock() as block:
                value = block.get_content()
        if self.is_empty():
            self.content = value
        else:
            self.content = self.content + "\n\n" + value

        return self

    def deep_copy(self) -> 'TextBlock':
        return self.model_copy(deep=True)

    @staticmethod
    def _from_tokens(stack: list[tuple['Token', str]]) -> 'TextBlock':
        # we assume that the first token is a content
        # and the last one is a blank line
        content = '\n'.join([y for (_, y) in stack[0:-1]])
        # we clear printed output of error blocks to allow re-scanning
        if content.startswith("** ERROR:"):
            return TextBlock(content="")

        return TextBlock(content=content)

    @staticmethod
    def from_text(text: str) -> 'TextBlock':
        """Instantiate a new text block from text."""
        return TextBlock(content=text)