"""Narration audio discovery and PPTX XML helpers."""

from __future__ import annotations

import base64
import json
import re
import subprocess
from collections.abc import Iterable
from pathlib import Path
from xml.etree import ElementTree as ET

from pptx_transitions import (
    AdvanceUpdate,
    EnterUpdate,
    MAX_OOXML_UNSIGNED_INT,
    P14_NS,
    PML_NS,
    apply_slide_motion_xml,
    parse_source_xml,
    read_slide_transition_xml,
    serialize_source_xml,
    validate_seconds,
)


DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
MARKUP_COMPATIBILITY_NS = (
    "http://schemas.openxmlformats.org/markup-compatibility/2006"
)

MEDIA_REL_TYPE = "http://schemas.microsoft.com/office/2007/relationships/media"
AUDIO_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio"
IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"

AUDIO_CONTENT_TYPES = {
    ".m4a": "audio/mp4",
    ".mp3": "audio/mpeg",
    ".wav": "audio/wav",
}

NARRATION_EXTENSIONS = tuple(AUDIO_CONTENT_TYPES.keys())
DEFAULT_NARRATION_START_FLOOR = 0.8

AUDIO_MARKER_SIZE_EMU = 457200  # 48 SVG px
AUDIO_MARKER_OFF_CANVAS_EMU = -AUDIO_MARKER_SIZE_EMU
AUDIO_MARKER_PNG_BYTES = base64.b64decode(
    "iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAABsUlEQVR4nO2aQZaDIAyG"
    "cd4cQRdzgHqxeiy9mB5gFvUO7Qon0gAhJEDf+G/a92rJ9ycEqNaYS3XVSQ94uz+esWu"
    "2ZRCLKzIQBdqnXDPsL+dA+8Qx88UJpAHPHTfJsRY4Jmo1yBUoCZ8Sj2SgNHxK3KiBWv"
    "DU+EEDteGtQhxeA63AW/l4WMuolNa5zx4DNaCd/XXuWfAY15sBTXguOJTL9501GlG50"
    "Ovc/xpjzDjtP+5nqj0gkXEL7763OhmQmj4S4FZY1iGnaAUkwQMxTlWouoz65CYBq4LV"
    "0cTU6VMgw8frOO3e6273x3Nbhq7JCmCCVYDTqDkDMOuUajdnIFWXgdq6DEgLNm5oGbV"
    "qzoBPcOmES+qxkW3L0FE2s1BWJDa5cdqjm5gxf7ddmqyAC4+dQq1EDYzTTpq3mTFO56"
    "KTAam7xpJGsOxDTtUpJGEEZhw7lRb5SWlNcJs8dJx+q4DkwwcEJLsiLh86hTRNGMM3g"
    "nFVXUYlGt1rQLsKqfLxBCvQiokQR3QK1TYRi0/qgVomKHHJTVzaBDUeC0rzBnBqoljL"
    "qFY1OOP+3yf1PpX+r8TH6wW14c3/7xdFRAAAAABJRU5ErkJggg=="
)


for _prefix, _uri in (
    ("p", PML_NS),
    ("a", DRAWINGML_NS),
    ("r", RELATIONSHIPS_NS),
    ("p14", P14_NS),
):
    try:
        ET.register_namespace(_prefix, _uri)
    except (AttributeError, ValueError):
        pass


def _qn(namespace: str, tag: str) -> str:
    return f"{{{namespace}}}{tag}"


def _normalize_title(title: str) -> str:
    text = re.sub(r"[^0-9A-Za-z\u4e00-\u9fff]+", "_", title.strip())
    return re.sub(r"_+", "_", text).strip("_").lower()


def _leading_number(text: str) -> int | None:
    match = re.match(r"^(\d{1,3})", text.strip())
    return int(match.group(1)) if match else None


def find_narration_files(audio_dir: Path, svg_files: list[Path]) -> dict[str, Path]:
    """Return `{svg_stem: audio_path}` matched by exact stem, normalized stem, or index."""
    if not audio_dir.exists() or not audio_dir.is_dir():
        return {}

    audio_files = [
        path for path in sorted(audio_dir.iterdir())
        if path.is_file() and path.suffix.lower() in NARRATION_EXTENSIONS
    ]
    exact: dict[str, list[Path]] = {}
    normalized: dict[str, list[Path]] = {}
    numbered: dict[int, list[Path]] = {}
    for path in audio_files:
        exact.setdefault(path.stem, []).append(path)
        normalized.setdefault(_normalize_title(path.stem), []).append(path)
        number = _leading_number(path.stem)
        if number is not None:
            numbered.setdefault(number, []).append(path)

    matched: dict[str, Path] = {}
    claimed_by: dict[Path, str] = {}
    for index, svg in enumerate(svg_files, 1):
        stem = svg.stem
        candidates = exact.get(stem)
        if not candidates:
            candidates = normalized.get(_normalize_title(stem))
        if not candidates:
            candidates = numbered.get(index)
        if not candidates:
            continue
        if len(candidates) > 1:
            names = ", ".join(path.name for path in candidates)
            raise ValueError(
                f"multiple narration audio files match slide {stem!r}: "
                f"{names}; keep exactly one supported file for this slide"
            )
        candidate = candidates[0]
        previous_stem = claimed_by.get(candidate)
        if previous_stem is not None:
            raise ValueError(
                f"narration audio file {candidate.name!r} matches multiple slides: "
                f"{previous_stem!r}, {stem!r}; provide one distinct audio file "
                "per slide"
            )
        matched[stem] = candidate
        claimed_by[candidate] = stem
    return matched


def probe_audio_duration(audio_path: Path) -> float | None:
    """Return duration in seconds using ffprobe when available."""
    try:
        result = subprocess.run(
            [
                "ffprobe", "-v", "error",
                "-show_entries", "format=duration",
                "-of", "json",
                str(audio_path),
            ],
            check=True,
            capture_output=True,
            text=True,
            encoding="utf-8",
        )
        data = json.loads(result.stdout or "{}")
        duration = float(data.get("format", {}).get("duration", 0))
        return duration if duration > 0 else None
    except Exception:
        return None


def next_shape_id(slide_xml: str) -> int:
    """Return the next slide-local non-visual shape id."""
    root = parse_source_xml(slide_xml)
    if root.tag != _qn(PML_NS, "sld"):
        raise ValueError("narration source XML root must be p:sld")
    ids = _numeric_ids(
        root.iter(_qn(PML_NS, "cNvPr")),
        "shape",
        minimum=1,
    )
    next_id = max(ids, default=1) + 1
    if next_id > MAX_OOXML_UNSIGNED_INT:
        raise ValueError("narration source has no available shape identifiers")
    return next_id


def _create_audio_pic_element(
    shape_id: int,
    shape_name: str,
    audio_rid: str,
    media_rid: str,
    poster_rid: str,
) -> ET.Element:
    pic = ET.Element(_qn(PML_NS, "pic"))
    nv_pic_pr = ET.SubElement(pic, _qn(PML_NS, "nvPicPr"))
    c_nv_pr = ET.SubElement(
        nv_pic_pr,
        _qn(PML_NS, "cNvPr"),
        {"id": str(shape_id), "name": shape_name},
    )
    ET.SubElement(
        c_nv_pr,
        _qn(DRAWINGML_NS, "hlinkClick"),
        {
            _qn(RELATIONSHIPS_NS, "id"): "",
            "action": "ppaction://media",
        },
    )
    c_nv_pic_pr = ET.SubElement(nv_pic_pr, _qn(PML_NS, "cNvPicPr"))
    ET.SubElement(
        c_nv_pic_pr,
        _qn(DRAWINGML_NS, "picLocks"),
        {"noChangeAspect": "1"},
    )
    nv_pr = ET.SubElement(nv_pic_pr, _qn(PML_NS, "nvPr"))
    ET.SubElement(
        nv_pr,
        _qn(DRAWINGML_NS, "audioFile"),
        {_qn(RELATIONSHIPS_NS, "link"): audio_rid},
    )
    ext_list = ET.SubElement(nv_pr, _qn(PML_NS, "extLst"))
    extension = ET.SubElement(
        ext_list,
        _qn(PML_NS, "ext"),
        {"uri": "{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}"},
    )
    ET.SubElement(
        extension,
        _qn(P14_NS, "media"),
        {_qn(RELATIONSHIPS_NS, "embed"): media_rid},
    )

    blip_fill = ET.SubElement(pic, _qn(PML_NS, "blipFill"))
    ET.SubElement(
        blip_fill,
        _qn(DRAWINGML_NS, "blip"),
        {_qn(RELATIONSHIPS_NS, "embed"): poster_rid},
    )
    stretch = ET.SubElement(blip_fill, _qn(DRAWINGML_NS, "stretch"))
    ET.SubElement(stretch, _qn(DRAWINGML_NS, "fillRect"))

    shape_properties = ET.SubElement(pic, _qn(PML_NS, "spPr"))
    transform = ET.SubElement(shape_properties, _qn(DRAWINGML_NS, "xfrm"))
    ET.SubElement(
        transform,
        _qn(DRAWINGML_NS, "off"),
        {
            "x": str(AUDIO_MARKER_OFF_CANVAS_EMU),
            "y": str(AUDIO_MARKER_OFF_CANVAS_EMU),
        },
    )
    ET.SubElement(
        transform,
        _qn(DRAWINGML_NS, "ext"),
        {
            "cx": str(AUDIO_MARKER_SIZE_EMU),
            "cy": str(AUDIO_MARKER_SIZE_EMU),
        },
    )
    geometry = ET.SubElement(
        shape_properties,
        _qn(DRAWINGML_NS, "prstGeom"),
        {"prst": "rect"},
    )
    ET.SubElement(geometry, _qn(DRAWINGML_NS, "avLst"))
    return pic


def create_audio_pic_xml(
    shape_id: int,
    shape_name: str,
    audio_rid: str,
    media_rid: str,
    poster_rid: str,
) -> str:
    """Create an off-canvas audio picture shape carrying narration media."""
    element = _create_audio_pic_element(
        shape_id,
        shape_name,
        audio_rid,
        media_rid,
        poster_rid,
    )
    return ET.tostring(element, encoding="unicode")


def _numeric_ids(
    elements: Iterable[ET.Element],
    label: str,
    *,
    minimum: int = 0,
    maximum: int = MAX_OOXML_UNSIGNED_INT,
) -> list[int]:
    ids: list[int] = []
    seen: set[int] = set()
    for element in elements:
        raw_id = element.get("id")
        try:
            numeric_id = int(raw_id)
        except (TypeError, ValueError) as exc:
            raise ValueError(f"narration source has invalid {label} id: {raw_id!r}") from exc
        if numeric_id < minimum:
            raise ValueError(
                f"narration source has {label} id below {minimum}: {numeric_id}"
            )
        if numeric_id > maximum:
            raise ValueError(
                f"narration source has {label} id above {maximum}: {numeric_id}"
            )
        if numeric_id in seen:
            raise ValueError(f"narration source has duplicate {label} id: {numeric_id}")
        ids.append(numeric_id)
        seen.add(numeric_id)
    return ids


def narration_lead_in_seconds(
    transition_duration: float,
    *,
    start_floor: float = DEFAULT_NARRATION_START_FLOOR,
) -> float:
    """Return silence after a slide transition before narration starts."""
    transition_seconds = validate_seconds(
        transition_duration,
        "narration transition duration",
        allow_zero=True,
    )
    floor_seconds = validate_seconds(
        start_floor,
        "narration start floor",
        allow_zero=True,
    )
    return max(0.0, floor_seconds - transition_seconds)


def _create_audio_timing_element(
    shape_id: int,
    ctn_id: int,
    start_delay_ms: int,
) -> ET.Element:
    audio = ET.Element(_qn(PML_NS, "audio"))
    media_node = ET.SubElement(
        audio,
        _qn(PML_NS, "cMediaNode"),
        {"vol": "80000"},
    )
    time_node = ET.SubElement(
        media_node,
        _qn(PML_NS, "cTn"),
        {"id": str(ctn_id), "fill": "hold", "display": "0"},
    )
    start_conditions = ET.SubElement(time_node, _qn(PML_NS, "stCondLst"))
    ET.SubElement(
        start_conditions,
        _qn(PML_NS, "cond"),
        {"delay": str(start_delay_ms)},
    )
    target = ET.SubElement(media_node, _qn(PML_NS, "tgtEl"))
    ET.SubElement(target, _qn(PML_NS, "spTgt"), {"spid": str(shape_id)})
    return audio


def _direct_child(parent: ET.Element, tag: str, label: str) -> ET.Element:
    children = [child for child in parent if child.tag == tag]
    if len(children) != 1:
        raise ValueError(
            f"narration source must contain exactly one direct {label}; found {len(children)}"
        )
    return children[0]


def _existing_timing_root(timing: ET.Element) -> ET.Element:
    children = list(timing)
    for tag, label in (
        (_qn(PML_NS, "tnLst"), "p:tnLst"),
        (_qn(PML_NS, "bldLst"), "p:bldLst"),
        (_qn(PML_NS, "extLst"), "p:extLst"),
    ):
        if sum(child.tag == tag for child in children) > 1:
            raise ValueError(f"narration source timing has multiple {label} elements")
    node_list = _direct_child(timing, _qn(PML_NS, "tnLst"), "p:timing/p:tnLst")
    node_index = children.index(node_list)
    for tag, label in (
        (_qn(PML_NS, "bldLst"), "p:bldLst"),
        (_qn(PML_NS, "extLst"), "p:extLst"),
    ):
        sibling = next((child for child in children if child.tag == tag), None)
        if sibling is not None and node_index > children.index(sibling):
            raise ValueError(f"narration source p:tnLst must precede {label}")
    timing_roots = [
        element
        for element in node_list.iter(_qn(PML_NS, "cTn"))
        if element.get("nodeType") == "tmRoot"
    ]
    if len(timing_roots) != 1:
        raise ValueError(
            "narration source timing must contain exactly one tmRoot; "
            f"found {len(timing_roots)}"
        )
    return timing_roots[0]


def _new_timing(audio_timing: ET.Element, root_id: int) -> ET.Element:
    timing = ET.Element(_qn(PML_NS, "timing"))
    node_list = ET.SubElement(timing, _qn(PML_NS, "tnLst"))
    parallel = ET.SubElement(node_list, _qn(PML_NS, "par"))
    timing_root = ET.SubElement(
        parallel,
        _qn(PML_NS, "cTn"),
        {
            "id": str(root_id),
            "dur": "indefinite",
            "restart": "never",
            "nodeType": "tmRoot",
        },
    )
    child_nodes = ET.SubElement(timing_root, _qn(PML_NS, "childTnLst"))
    child_nodes.append(audio_timing)
    return timing


def _root_extension_index(slide: ET.Element) -> int | None:
    extension_lists = [
        index
        for index, child in enumerate(slide)
        if child.tag == _qn(PML_NS, "extLst")
    ]
    if len(extension_lists) > 1:
        raise ValueError("narration source has multiple root p:extLst elements")
    if extension_lists and extension_lists[0] != len(slide) - 1:
        raise ValueError("narration source root p:extLst is not the last slide child")
    return extension_lists[0] if extension_lists else None


def _validate_root_timing_position(slide: ET.Element, timing: ET.Element) -> None:
    children = list(slide)
    timing_index = children.index(timing)
    for tag, label in (
        (_qn(PML_NS, "cSld"), "p:cSld"),
        (_qn(PML_NS, "clrMapOvr"), "p:clrMapOvr"),
    ):
        siblings = [index for index, child in enumerate(children) if child.tag == tag]
        if len(siblings) > 1:
            raise ValueError(f"narration source has multiple root {label} elements")
        if siblings and siblings[0] > timing_index:
            raise ValueError(f"narration source root p:timing must follow {label}")
    extension_index = _root_extension_index(slide)
    if extension_index is not None and timing_index > extension_index:
        raise ValueError("narration source root p:timing must precede p:extLst")


def _insert_root_timing(slide: ET.Element, timing: ET.Element) -> None:
    extension_index = _root_extension_index(slide)
    insert_at = extension_index if extension_index is not None else len(slide)
    slide.insert(insert_at, timing)


def _animation_timing_branches(
    slide: ET.Element,
) -> tuple[ET.Element | None, list[ET.Element]]:
    """Return the root timing anchor and every active/fallback timing branch."""
    direct = [
        child for child in slide
        if child.tag == _qn(PML_NS, "timing")
    ]
    alternates: list[tuple[ET.Element, list[ET.Element]]] = []
    for child in slide:
        if child.tag != _qn(MARKUP_COMPATIBILITY_NS, "AlternateContent"):
            continue
        timings = [
            timing
            for branch in list(child)
            for timing in list(branch)
            if timing.tag == _qn(PML_NS, "timing")
        ]
        if timings:
            alternates.append((child, timings))
    if direct and alternates:
        raise ValueError(
            "narration source contains both direct and AlternateContent timing"
        )
    if len(direct) > 1 or len(alternates) > 1:
        raise ValueError("narration source has multiple root animation timings")
    if direct:
        return direct[0], direct
    if alternates:
        anchor, timings = alternates[0]
        if len(timings) != 2:
            raise ValueError(
                "narration source animation AlternateContent must contain "
                "one Choice and one Fallback timing"
            )
        return anchor, timings
    nested = list(slide.iter(_qn(PML_NS, "timing")))
    if nested:
        raise ValueError(
            "narration source contains unsupported non-root p:timing"
        )
    return None, []


def inject_narration(
    slide_xml: str,
    *,
    shape_id: int,
    shape_name: str,
    audio_rid: str,
    media_rid: str,
    poster_rid: str,
    start_delay: float = 0.0,
) -> str:
    """Inject a hidden narration shape and delayed slide-entry autoplay timing."""
    if isinstance(shape_id, bool) or not isinstance(shape_id, int) or shape_id <= 0:
        raise ValueError("narration shape_id must be a positive integer")
    if shape_id > MAX_OOXML_UNSIGNED_INT:
        raise ValueError(
            "narration shape_id exceeds the OOXML unsigned-integer limit: "
            f"{shape_id}"
        )
    start_delay_seconds = validate_seconds(
        start_delay,
        "narration start delay",
        allow_zero=True,
    )
    start_delay_ms = round(start_delay_seconds * 1000)
    if start_delay_ms > MAX_OOXML_UNSIGNED_INT:
        raise ValueError(
            "narration start delay exceeds the OOXML unsigned-integer limit: "
            f"{start_delay_ms} ms"
        )

    root = parse_source_xml(slide_xml)
    if root.tag != _qn(PML_NS, "sld"):
        raise ValueError("narration source XML root must be p:sld")
    common_slide_data = _direct_child(root, _qn(PML_NS, "cSld"), "p:sld/p:cSld")
    shape_tree = _direct_child(
        common_slide_data,
        _qn(PML_NS, "spTree"),
        "p:cSld/p:spTree",
    )

    shape_ids = _numeric_ids(
        root.iter(_qn(PML_NS, "cNvPr")),
        "shape",
        minimum=1,
    )
    if shape_id in shape_ids:
        raise ValueError(f"narration shape id already exists on slide: {shape_id}")
    timing_anchor, timing_branches = _animation_timing_branches(root)
    timing_id_sets = [
        _numeric_ids(timing.iter(_qn(PML_NS, "cTn")), "timing node")
        for timing in timing_branches
    ]
    timing_ids = [
        timing_id
        for timing_set in timing_id_sets
        for timing_id in timing_set
    ]
    next_timing_id = max(timing_ids, default=0) + 1
    if next_timing_id > MAX_OOXML_UNSIGNED_INT:
        raise ValueError("narration source has no available timing node identifiers")

    if not timing_branches and next_timing_id + 1 > MAX_OOXML_UNSIGNED_INT:
        raise ValueError(
            "narration source has no identifiers available for a new timing root"
        )

    audio_picture = _create_audio_pic_element(
        shape_id,
        shape_name,
        audio_rid,
        media_rid,
        poster_rid,
    )
    shape_tree.append(audio_picture)

    if timing_branches:
        if timing_anchor is None:
            raise AssertionError("timing branches lost their root anchor")
        _validate_root_timing_position(root, timing_anchor)
        for timing in timing_branches:
            timing_root = _existing_timing_root(timing)
            child_nodes = _direct_child(
                timing_root,
                _qn(PML_NS, "childTnLst"),
                "tmRoot/p:childTnLst",
            )
            child_nodes.append(
                _create_audio_timing_element(
                    shape_id,
                    next_timing_id,
                    start_delay_ms,
                )
            )
    else:
        audio_timing = _create_audio_timing_element(
            shape_id,
            next_timing_id + 1,
            start_delay_ms,
        )
        _insert_root_timing(root, _new_timing(audio_timing, next_timing_id))

    return serialize_source_xml(root, slide_xml).decode("utf-8")


def read_narration_start_delay_xml(slide_xml: str) -> int:
    """Return the latest embedded narration picture's autoplay delay in ms."""
    root = parse_source_xml(slide_xml)
    if root.tag != _qn(PML_NS, "sld"):
        raise ValueError("narration source XML root must be p:sld")

    audio_shape_properties: list[ET.Element] = []
    for picture in root.iter(_qn(PML_NS, "pic")):
        if not any(
            element.tag == _qn(DRAWINGML_NS, "audioFile")
            for element in picture.iter()
        ):
            continue
        properties = list(picture.iter(_qn(PML_NS, "cNvPr")))
        if len(properties) != 1:
            raise ValueError(
                "narration audio picture must contain exactly one p:cNvPr"
            )
        audio_shape_properties.extend(properties)
    if not audio_shape_properties:
        raise ValueError("narration source has no embedded audio picture")

    narration_shape_id = max(
        _numeric_ids(
            audio_shape_properties,
            "narration audio shape",
            minimum=1,
        )
    )
    delays: list[int] = []
    for audio in root.iter(_qn(PML_NS, "audio")):
        media_node = audio.find(_qn(PML_NS, "cMediaNode"))
        if media_node is None:
            continue
        target = media_node.find(
            f"{_qn(PML_NS, 'tgtEl')}/{_qn(PML_NS, 'spTgt')}"
        )
        if target is None or target.get("spid") != str(narration_shape_id):
            continue
        time_node = _direct_child(
            media_node,
            _qn(PML_NS, "cTn"),
            "p:audio/p:cMediaNode/p:cTn",
        )
        start_conditions = _direct_child(
            time_node,
            _qn(PML_NS, "stCondLst"),
            "p:cTn/p:stCondLst",
        )
        condition = _direct_child(
            start_conditions,
            _qn(PML_NS, "cond"),
            "p:stCondLst/p:cond",
        )
        raw_delay = condition.get("delay")
        try:
            delay = int(raw_delay)
        except (TypeError, ValueError) as exc:
            raise ValueError(
                f"narration timing has invalid start delay: {raw_delay!r}"
            ) from exc
        if delay < 0 or delay > MAX_OOXML_UNSIGNED_INT:
            raise ValueError(
                "narration timing start delay is outside the OOXML "
                f"unsigned-integer range: {delay}"
            )
        delays.append(delay)

    if not delays:
        raise ValueError("narration source has no autoplay timing for its audio picture")
    if len(set(delays)) != 1:
        raise ValueError(
            "narration source timing branches disagree on autoplay delay: "
            f"{sorted(set(delays))}"
        )
    return delays[0]


def apply_recorded_timing(
    slide_xml: str,
    *,
    advance_after: float,
    transition_duration: float,
    transition_effect: str | None = "fade",
) -> str:
    """Set slide auto-advance timing so exported video follows narration length."""
    summary = read_slide_transition_xml(slide_xml)
    if summary.logical_count:
        enter = EnterUpdate(policy="preserve")
    elif transition_effect is None or transition_effect == "none":
        enter = EnterUpdate(policy="none")
    else:
        enter = EnterUpdate(
            policy="replace",
            effect=transition_effect,
            duration=transition_duration,
        )
    updated, _uses_timings = apply_slide_motion_xml(
        slide_xml,
        enter=enter,
        advance=AdvanceUpdate(mode="narration", after=advance_after),
    )
    return updated