"""Convert TEI XML files to Markdown format."""

import re
import xml.etree.ElementTree as ET
from pathlib import Path


class TEIToMarkdownConverter:
    ns: dict[str, str] = {"tei": "http://www.tei-c.org/ns/1.0"}
    # Replace XML entities with proper characters
    replacements: dict[str, str] = {
        "æ": "æ",
        "ø": "ø",
        "å": "å",
        "Æ": "Æ",
        "Ø": "Ø",
        "Å": "Å",
        "ö": "ö",
        "ü": "ü",
        "ä": "ä",
        "©": "©",
    }

    def clean_text(self, text: str) -> str:
        """Clean and normalize text content"""
        for entity, char in self.replacements.items():
            text = text.replace(entity, char)

        # Normalize whitespace
        text = re.sub(r"\s+", " ", text.strip())
        return text

    def extract_metadata(self, root: ET.Element) -> dict[str, str]:
        """Extract metadata from TEI header"""
        metadata = {}

        # Title
        title_elem = root.find(".//tei:titleStmt/tei:title", self.ns)
        if title_elem is not None and title_elem.text:
            metadata["title"] = self.clean_text(title_elem.text)

        # Author
        author_elem = root.find(".//tei:titleStmt/tei:author", self.ns)
        if author_elem is not None and author_elem.text:
            metadata["author"] = self.clean_text(author_elem.text)

        # Date
        date_elem = root.find(".//tei:publicationStmt/tei:date", self.ns)
        if date_elem is not None and date_elem.get("when"):
            metadata["date"] = date_elem.get("when")

        # Publisher
        pub_elem = root.find(".//tei:publicationStmt/tei:publisher", self.ns)
        if pub_elem is not None and pub_elem.text:
            metadata["publisher"] = self.clean_text(pub_elem.text)

        return metadata

    def process_element(self, elem: ET.Element, level: int = 0) -> list[str]:
        """Process XML elements recursively and convert to Markdown"""
        result = []

        # Handle different element types
        tag = elem.tag.split("}")[-1] if "}" in elem.tag else elem.tag

        # Headers
        if tag == "head":
            rend = elem.get("rend", "")
            if rend == "2":
                header_level = "## "
            elif rend == "3":
                header_level = "### "
            else:
                header_level = "# "

            text = self.get_element_text(elem)
            if text:
                result.append(f"{header_level}{text}\n")

        # Paragraphs
        elif tag == "p":
            text = self.get_element_text(elem)
            if text:
                result.append(f"{text}\n")

        # Emphasized text
        elif tag == "hi":
            rend = elem.get("rend", "")
            text = self.get_element_text(elem)
            if text:
                if rend == "spaced":
                    result.append(f"**{text}**")
                elif rend == "initial":
                    result.append(f"**{text}**")
                else:
                    result.append(f"*{text}*")

        # Places
        elif tag == "placeName":
            text = self.get_element_text(elem)
            if text:
                result.append(text)

        # Segments
        elif tag == "seg":
            text = self.get_element_text(elem)
            if text:
                result.append(text)

        # Divisions
        elif tag == "div":
            for child in elem:
                result.extend(self.process_element(child, level + 1))

        # Default case - process children
        else:
            if elem.text:
                result.append(self.clean_text(elem.text))

            for child in elem:
                result.extend(self.process_element(child, level + 1))
                if child.tail:
                    result.append(self.clean_text(child.tail))

        return result

    def get_element_text(self, elem: ET.Element) -> str:
        """Get all text content from an element and its children"""
        parts = []

        if elem.text:
            parts.append(elem.text)

        for child in elem:
            # Handle special formatting
            child_tag = child.tag.split("}")[-1] if "}" in child.tag else child.tag

            if child_tag == "hi":
                rend = child.get("rend", "")
                child_text = self.get_element_text(child)
                if child_text:
                    if rend == "spaced":
                        parts.append(f"**{child_text}**")
                    elif rend == "initial":
                        parts.append(f"**{child_text}**")
                    else:
                        parts.append(f"*{child_text}*")
            elif child_tag == "seg":
                child_text = self.get_element_text(child)
                if child_text:
                    parts.append(child_text)
            else:
                parts.append(self.get_element_text(child))

            if child.tail:
                parts.append(child.tail)

        return self.clean_text("".join(parts))

    def convert_text(self, xml_text: str) -> str:
        """Convert TEI XML text to Markdown"""
        root = ET.fromstring(xml_text)
        metadata = self.extract_metadata(root)

        # Start building Markdown content
        markdown_lines = []

        # Add metadata header
        if metadata:
            markdown_lines.append("---\n")
            for key, value in metadata.items():
                markdown_lines.append(f"{key}: {value}\n")
            markdown_lines.append("---\n")

        # Process the text body
        body = root.find(".//tei:body", self.ns)
        if body is not None:
            for elem in body:
                markdown_lines.extend(self.process_element(elem))

        markdown_content = "".join(markdown_lines)
        return markdown_content


def main():
    """Main function to run the converter"""
    converter = TEIToMarkdownConverter()
    source_data = Path(__file__).parent.parent / "source-data"

    for path in source_data.glob("*.xml"):
        with path.open("r") as file:
            text = file.read()

        output_path = path.with_suffix(".md")
        markdown_result = converter.convert_text(text)

        with output_path.open("w") as file:
            file.write(markdown_result)


if __name__ == "__main__":
    main()