from os import PathLike
from pathlib import Path
from typing import Any, Dict, Optional

from pptx.util import Inches

from ..utils.pptx_functions import PptxEditor


_SHAPE_ID_UNSET = object()


def create_presentation(path: Optional[str | PathLike[str]] = None) -> PptxEditor:
    if path is None:
        return PptxEditor()
    return PptxEditor(str(path))


def save_presentation(editor: PptxEditor, path: str | PathLike[str]) -> Dict[str, Any]:
    output_path = Path(path)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    editor.prs.save(output_path)
    return {
        "path": str(output_path.resolve()),
        "slide_count": len(editor.prs.slides),
    }


def register_theme(
    editor: PptxEditor, theme: Dict[str, Any], name: str = "default"
) -> str:
    return editor.register_theme(name, theme)


def update_theme(
    editor: PptxEditor, updates: Dict[str, Any], name: str = "default"
) -> None:
    editor.update_theme(name, updates)


def _remove_bindings(
    editor: PptxEditor,
    *,
    slide_id: Optional[int] = None,
    shape_id: Any = _SHAPE_ID_UNSET,
    apply_method: Optional[str] = None,
    theme_name: Optional[str] = None,
) -> None:
    theme_names = (
        [theme_name] if theme_name is not None else list(editor._theme_bindings)
    )

    for current_theme_name in theme_names:
        remaining = []
        for binding in editor._theme_bindings.get(current_theme_name, []):
            if slide_id is not None and binding.slide_id != slide_id:
                remaining.append(binding)
                continue
            if shape_id is not _SHAPE_ID_UNSET and binding.shape_id != shape_id:
                remaining.append(binding)
                continue
            if apply_method is not None and binding.apply_method != apply_method:
                remaining.append(binding)
                continue
        editor._theme_bindings[current_theme_name] = remaining


def _get_required(spec: Dict[str, Any], key: str) -> Any:
    if key not in spec:
        raise ValueError(f"Shape spec missing required field '{key}'")
    return spec[key]


def _get_optional_geometry(spec: Dict[str, Any]) -> Dict[str, float]:
    geometry = {}
    for source_key, target_key in (
        ("x", "left"),
        ("y", "top"),
        ("w", "width"),
        ("h", "height"),
    ):
        if source_key in spec:
            geometry[target_key] = spec[source_key]
    return geometry


def _apply_geometry_updates(
    editor: PptxEditor, slide_id: int, shape_id: int, spec: Dict[str, Any]
) -> None:
    geometry = _get_optional_geometry(spec)
    if not geometry:
        return

    shape = editor._get_shape_by_id(slide_id, shape_id)
    if "left" in geometry:
        shape.left = Inches(geometry["left"])
    if "top" in geometry:
        shape.top = Inches(geometry["top"])
    if "width" in geometry:
        shape.width = Inches(geometry["width"])
    if "height" in geometry:
        shape.height = Inches(geometry["height"])


def _record_named_shape(
    result: Dict[str, Any], spec: Dict[str, Any], shape_id: int
) -> None:
    name = spec.get("name")
    if name is None:
        return
    if name in result["named_shapes"]:
        raise ValueError(f"Duplicate shape name '{name}' in one tool call")
    result["named_shapes"][name] = shape_id


def _create_accent_bar(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    return editor.add_accent_bar_by_id(
        slide_id,
        _get_required(spec, "color_hex"),
        height=spec.get("height", 0.35),
        theme_name=theme_name,
        bind_theme=True,
    )


def _create_text(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_id = editor.add_textbox_by_id(
        slide_id,
        _get_required(spec, "x"),
        _get_required(spec, "y"),
        _get_required(spec, "w"),
        _get_required(spec, "h"),
    )
    editor.insert_text_by_id(slide_id, shape_id, _get_required(spec, "text"))
    if spec.get("style"):
        editor.style_text_by_id(
            slide_id,
            shape_id,
            theme_name=theme_name,
            bind_theme=True,
            **spec["style"],
        )
    return shape_id


def _create_chart(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    return editor.add_chart_by_id(
        slide_id,
        _get_required(spec, "chart_type"),
        _get_required(spec, "chart_data"),
        _get_required(spec, "x"),
        _get_required(spec, "y"),
        _get_required(spec, "w"),
        _get_required(spec, "h"),
        style=spec.get("style"),
        theme_name=theme_name,
        bind_theme=True,
    )


def _create_table(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    table_data = _get_required(spec, "table_data")
    rows = len(table_data)
    cols = max((len(row) for row in table_data), default=0)
    if rows == 0 or cols == 0:
        raise ValueError("table_data must include at least one row and one column")

    return editor.add_table_by_id(
        slide_id,
        rows,
        cols,
        table_data,
        _get_required(spec, "x"),
        _get_required(spec, "y"),
        _get_required(spec, "w"),
        _get_required(spec, "h"),
        style=spec.get("style"),
        theme_name=theme_name,
        bind_theme=True,
    )


def _create_image(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    del theme_name
    return editor.add_image_by_id(
        slide_id,
        _get_required(spec, "image_path"),
        _get_required(spec, "x"),
        _get_required(spec, "y"),
        cx=spec.get("w"),
        cy=spec.get("h"),
    )


def _update_text(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_id = _get_required(spec, "shape_id")
    _apply_geometry_updates(editor, slide_id, shape_id, spec)
    if "text" in spec:
        editor.insert_text_by_id(slide_id, shape_id, spec["text"])
    if "style" in spec:
        _remove_bindings(
            editor,
            slide_id=slide_id,
            shape_id=shape_id,
            apply_method="style_text_by_id",
        )
        editor.style_text_by_id(
            slide_id,
            shape_id,
            theme_name=theme_name,
            bind_theme=True,
            **spec["style"],
        )
    return shape_id


def _update_chart(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_id = _get_required(spec, "shape_id")
    _apply_geometry_updates(editor, slide_id, shape_id, spec)
    if "style" in spec:
        _remove_bindings(
            editor,
            slide_id=slide_id,
            shape_id=shape_id,
            apply_method="style_chart_by_id",
        )
        editor.style_chart_by_id(
            slide_id,
            shape_id,
            theme_name=theme_name,
            bind_theme=True,
            **spec["style"],
        )
    return shape_id


def _update_table(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_id = _get_required(spec, "shape_id")
    _apply_geometry_updates(editor, slide_id, shape_id, spec)
    if "style" in spec:
        _remove_bindings(
            editor,
            slide_id=slide_id,
            shape_id=shape_id,
            apply_method="style_table_by_id",
        )
        editor.style_table_by_id(
            slide_id,
            shape_id,
            theme_name=theme_name,
            bind_theme=True,
            **spec["style"],
        )
    return shape_id


def _update_accent_bar(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_id = _get_required(spec, "shape_id")
    _apply_geometry_updates(editor, slide_id, shape_id, spec)
    if "height" in spec:
        shape = editor._get_shape_by_id(slide_id, shape_id)
        shape.height = Inches(spec["height"])
    if "color_hex" in spec:
        _remove_bindings(
            editor,
            slide_id=slide_id,
            shape_id=shape_id,
            apply_method="style_shape_fill_by_id",
        )
        editor.style_shape_fill_by_id(
            slide_id,
            shape_id,
            fill_color_hex=spec["color_hex"],
            theme_name=theme_name,
            bind_theme=True,
        )
    return shape_id


def _update_image(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    del theme_name
    shape_id = _get_required(spec, "shape_id")
    if "image_path" in spec:
        raise ValueError(
            "Updating image content is not supported; delete and re-add the image"
        )
    _apply_geometry_updates(editor, slide_id, shape_id, spec)
    return shape_id


_CREATE_DISPATCH = {
    "accent_bar": _create_accent_bar,
    "text": _create_text,
    "chart": _create_chart,
    "table": _create_table,
    "image": _create_image,
}

_UPDATE_DISPATCH = {
    "accent_bar": _update_accent_bar,
    "text": _update_text,
    "chart": _update_chart,
    "table": _update_table,
    "image": _update_image,
}


def _create_shape_from_spec(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_type = _get_required(spec, "type")
    if shape_type not in _CREATE_DISPATCH:
        raise ValueError(f"Unsupported shape type '{shape_type}'")
    return _CREATE_DISPATCH[shape_type](editor, slide_id, spec, theme_name)


def _update_shape_from_spec(
    editor: PptxEditor, slide_id: int, spec: Dict[str, Any], theme_name: str
) -> int:
    shape_type = _get_required(spec, "type")
    if shape_type not in _UPDATE_DISPATCH:
        raise ValueError(f"Unsupported shape type '{shape_type}'")
    return _UPDATE_DISPATCH[shape_type](editor, slide_id, spec, theme_name)


def _delete_shape(editor: PptxEditor, slide_id: int, shape_id: int) -> None:
    shape = editor._get_shape_by_id(slide_id, shape_id)
    shape._element.getparent().remove(shape._element)
    _remove_bindings(editor, slide_id=slide_id, shape_id=shape_id)


def delete_slide(editor: PptxEditor, slide_id: int) -> Dict[str, Any]:
    slide_index = editor.get_slide_index(slide_id)
    editor.delete_slide_by_id(slide_id)
    _remove_bindings(editor, slide_id=slide_id)
    return {
        "slide_id": slide_id,
        "deleted_slide_index": slide_index + 1,
        "remaining_slide_count": len(editor.prs.slides),
    }


def create_slide(
    editor: PptxEditor,
    *,
    theme_name: str = "default",
    background_color: Optional[str] = None,
    shapes: Optional[list[Dict[str, Any]]] = None,
) -> Dict[str, Any]:
    slide_index = editor.add_slide()
    slide_id = editor.get_slide_id(slide_index)
    result = {"slide_id": slide_id, "shape_ids": [], "named_shapes": {}}

    if background_color is not None:
        editor.set_slide_background_by_id(
            slide_id,
            background_color,
            theme_name=theme_name,
            bind_theme=True,
        )

    for spec in shapes or []:
        shape_id = _create_shape_from_spec(editor, slide_id, spec, theme_name)
        result["shape_ids"].append(shape_id)
        _record_named_shape(result, spec, shape_id)

    return result


def update_slide(
    editor: PptxEditor,
    slide_id: int,
    *,
    theme_name: str = "default",
    background_color: Optional[str] = None,
    delete_shape_ids: Optional[list[int]] = None,
    add_shapes: Optional[list[Dict[str, Any]]] = None,
    update_shapes: Optional[list[Dict[str, Any]]] = None,
) -> Dict[str, Any]:
    editor._get_slide_by_id(slide_id)
    delete_shape_ids = delete_shape_ids or []
    add_shapes = add_shapes or []
    update_shapes = update_shapes or []

    delete_set = set(delete_shape_ids)
    if len(delete_set) != len(delete_shape_ids):
        raise ValueError("delete_shape_ids contains duplicates")

    update_shape_ids = []
    for spec in update_shapes:
        shape_id = _get_required(spec, "shape_id")
        if shape_id in delete_set:
            raise ValueError(
                f"Shape id {shape_id} cannot be both updated and deleted in one call"
            )
        update_shape_ids.append(shape_id)

    if len(set(update_shape_ids)) != len(update_shape_ids):
        raise ValueError("update_shapes contains duplicate shape_id values")

    result = {
        "slide_id": slide_id,
        "deleted_shape_ids": [],
        "updated_shape_ids": [],
        "created_shape_ids": [],
        "named_shapes": {},
    }

    if background_color is not None:
        _remove_bindings(
            editor,
            slide_id=slide_id,
            shape_id=None,
            apply_method="set_slide_background_by_id",
        )
        editor.set_slide_background_by_id(
            slide_id,
            background_color,
            theme_name=theme_name,
            bind_theme=True,
        )

    for spec in update_shapes:
        shape_id = _update_shape_from_spec(editor, slide_id, spec, theme_name)
        result["updated_shape_ids"].append(shape_id)
        _record_named_shape(result, spec, shape_id)

    for spec in add_shapes:
        shape_id = _create_shape_from_spec(editor, slide_id, spec, theme_name)
        result["created_shape_ids"].append(shape_id)
        _record_named_shape(result, spec, shape_id)

    for shape_id in delete_shape_ids:
        _delete_shape(editor, slide_id, shape_id)
        result["deleted_shape_ids"].append(shape_id)

    return result


__all__ = [
    "create_presentation",
    "save_presentation",
    "register_theme",
    "update_theme",
    "create_slide",
    "delete_slide",
    "update_slide",
]