from __future__ import annotations

import hashlib
from collections import Counter
from dataclasses import dataclass
from io import BytesIO
from typing import Any

from pptx import Presentation as load_presentation
from pptx.enum.dml import MSO_FILL
from pptx.presentation import Presentation as PptxPresentation

from .pptx_functions import PptxEditor
from .reward_models import (
    ExtractedChart,
    ExtractedImage,
    ExtractedPresentation,
    ExtractedShape,
    ExtractedSlide,
    ExtractedTable,
    ExtractedTextBlock,
)


@dataclass(slots=True)
class OpenPptxResult:
    presentation: PptxPresentation
    inspection_mode: str
    source_path: str | None = None


def open_presentation(
    presentation: PptxEditor | PptxPresentation | str,
) -> OpenPptxResult:
    if isinstance(presentation, PptxEditor):
        return OpenPptxResult(
            presentation=presentation.prs,
            inspection_mode="pptx_editor",
        )
    if isinstance(presentation, PptxPresentation):
        return OpenPptxResult(
            presentation=presentation,
            inspection_mode="presentation_object",
        )
    if isinstance(presentation, str):
        return OpenPptxResult(
            presentation=load_presentation(presentation),
            inspection_mode="pptx_path",
            source_path=presentation,
        )
    raise TypeError(
        "presentation must be a PptxEditor, pptx.Presentation, or .pptx path"
    )


def _safe_rgb(color_format: Any) -> str | None:
    try:
        rgb = color_format.rgb
    except Exception:
        return None
    return str(rgb) if rgb is not None else None


def _emu_to_inches(value: int | None) -> float:
    if value is None:
        return 0.0
    return float(value) / 914400.0


def _has_image(shape: Any) -> bool:
    try:
        shape.image
    except Exception:
        return False
    return True


def _shape_fill_hex(shape: Any) -> str | None:
    try:
        fill = shape.fill
    except Exception:
        return None
    try:
        return _safe_rgb(fill.fore_color)
    except Exception:
        return None


def _shape_line_hex(shape: Any) -> str | None:
    try:
        line = shape.line
    except Exception:
        return None
    try:
        if line.fill.type != MSO_FILL.SOLID:
            return None
        return _safe_rgb(line.fill.fore_color)
    except Exception:
        return None


def _background_hex(slide: Any) -> str | None:
    try:
        return _safe_rgb(slide.background.fill.fore_color)
    except Exception:
        return None


def _infer_text_style(
    paragraph: Any,
) -> tuple[str | None, float | None, bool | None, bool | None, str | None]:
    candidates = []
    for run in getattr(paragraph, "runs", []):
        candidates.append(run.font)
    candidates.append(paragraph.font)

    font_name = None
    font_size = None
    bold = None
    italic = None
    color_hex = None

    for font in candidates:
        if font_name is None and getattr(font, "name", None) is not None:
            font_name = font.name
        if font_size is None and getattr(font, "size", None) is not None:
            font_size = float(font.size.pt)
        if bold is None and getattr(font, "bold", None) is not None:
            bold = bool(font.bold)
        if italic is None and getattr(font, "italic", None) is not None:
            italic = bool(font.italic)
        if color_hex is None:
            color_hex = _safe_rgb(getattr(font, "color", None))

    return font_name, font_size, bold, italic, color_hex


def _extract_text_block(shape: Any) -> ExtractedTextBlock:
    block = ExtractedTextBlock()
    for paragraph in shape.text_frame.paragraphs:
        font_name, font_size, bold, italic, color_hex = _infer_text_style(paragraph)
        block.paragraph_texts.append(paragraph.text)
        block.bullet_levels.append(getattr(paragraph, "level", None))
        block.font_names.append(font_name)
        block.font_sizes_pt.append(font_size)
        block.bold_flags.append(bold)
        block.italic_flags.append(italic)
        block.color_hexes.append(color_hex)
    return block


def _chart_type_name(chart: Any) -> str:
    chart_type = getattr(chart, "chart_type", None)
    if chart_type is None:
        return "unknown"
    return getattr(chart_type, "name", str(chart_type)).lower()


def _extract_chart(shape: Any) -> ExtractedChart:
    chart = shape.chart
    categories: list[str] = []
    series_payload: list[dict[str, Any]] = []
    axis_labels: dict[str, Any] = {}

    try:
        for category in chart.plots[0].categories:
            categories.append(str(getattr(category, "label", category)))
    except Exception:
        categories = []

    for series in chart.series:
        values: list[Any] = []
        try:
            values = list(series.values)
        except Exception:
            values = []
        series_payload.append(
            {
                "name": getattr(series, "name", None),
                "values": values,
            }
        )

    try:
        if chart.category_axis.has_title:
            axis_labels["category"] = chart.category_axis.axis_title.text_frame.text
    except Exception:
        pass
    try:
        if chart.value_axis.has_title:
            axis_labels["value"] = chart.value_axis.axis_title.text_frame.text
    except Exception:
        pass

    title = None
    try:
        if chart.has_title:
            title = chart.chart_title.text_frame.text
    except Exception:
        title = None

    series_colors = []
    for series in chart.series:
        try:
            series_colors.append(_safe_rgb(series.format.fill.fore_color))
        except Exception:
            series_colors.append(None)

    return ExtractedChart(
        chart_type=_chart_type_name(chart),
        title=title,
        categories=categories,
        series=series_payload,
        has_legend=bool(getattr(chart, "has_legend", False)),
        axis_labels=axis_labels,
        style_metrics={"series_colors": series_colors},
    )


def _extract_table(shape: Any) -> ExtractedTable:
    table = shape.table
    cells: list[list[str]] = []
    for row in table.rows:
        cells.append([cell.text for cell in row.cells])
    return ExtractedTable(
        rows=len(table.rows),
        cols=len(table.columns),
        cells=cells,
        header_present=len(table.rows) > 1,
        style_metrics={},
    )


def _extract_image(shape: Any) -> ExtractedImage:
    image = shape.image
    width_px = None
    height_px = None
    try:
        width_px, height_px = image.size
    except Exception:
        pass

    content_hash = None
    try:
        content_hash = hashlib.sha256(image.blob).hexdigest()
    except Exception:
        content_hash = None

    return ExtractedImage(
        width_px=width_px,
        height_px=height_px,
        content_hash=content_hash,
        metadata={"ext": getattr(image, "ext", None)},
    )


def _shape_kind(shape: Any, slide_height_in: float) -> tuple[str, str | None]:
    if getattr(shape, "has_chart", False):
        return "chart", "chart"
    if getattr(shape, "has_table", False):
        return "table", "table"
    if _has_image(shape):
        return "image", "image"
    width = float(shape.width.inches)
    height = float(shape.height.inches)
    top = float(shape.top.inches)
    left = float(shape.left.inches)
    if top <= 0.3 and left <= 0.2 and width >= 10 and height <= 0.6:
        return "accent_bar", "accent_bar"
    if getattr(shape, "has_text_frame", False):
        return "text", None
    return "unknown", None


def _extract_shape(
    slide: Any,
    slide_index: int,
    shape: Any,
    z_index: int,
    *,
    slide_height_in: float,
) -> ExtractedShape:
    shape_kind, inferred_role = _shape_kind(shape, slide_height_in)
    raw_text = (
        shape.text_frame.text if getattr(shape, "has_text_frame", False) else None
    )
    text_blocks = []
    chart = None
    table = None
    image = None

    if getattr(shape, "has_text_frame", False):
        text_blocks.append(_extract_text_block(shape))
    if getattr(shape, "has_chart", False):
        chart = _extract_chart(shape)
    if getattr(shape, "has_table", False):
        table = _extract_table(shape)
    if _has_image(shape):
        image = _extract_image(shape)

    return ExtractedShape(
        shape_id=shape.shape_id,
        shape_kind=shape_kind,
        semantic_role=inferred_role,
        name=None,
        x=float(shape.left.inches),
        y=float(shape.top.inches),
        w=float(shape.width.inches),
        h=float(shape.height.inches),
        z_index=z_index,
        fill_color_hex=_shape_fill_hex(shape),
        line_color_hex=_shape_line_hex(shape),
        raw_text=raw_text,
        text_blocks=text_blocks,
        chart=chart,
        table=table,
        image=image,
        metadata={
            "native_name": getattr(shape, "name", None),
            "shape_type": str(getattr(shape, "shape_type", "unknown")),
            "slide_index": slide_index,
        },
    )


def _title_from_shapes(shapes: list[ExtractedShape]) -> str | None:
    text_shapes = [
        shape for shape in shapes if shape.shape_kind == "text" and shape.raw_text
    ]
    if not text_shapes:
        return None

    def score(shape: ExtractedShape) -> tuple[float, float, float]:
        font_sizes = [
            size
            for block in shape.text_blocks
            for size in block.font_sizes_pt
            if size is not None
        ]
        max_font = max(font_sizes, default=0.0)
        return (-shape.y, max_font, -len(shape.raw_text or ""))

    best_shape = sorted(text_shapes, key=score, reverse=True)[0]
    return best_shape.raw_text


def _shape_texts(shapes: list[ExtractedShape]) -> list[str]:
    texts = []
    for shape in shapes:
        if shape.raw_text:
            texts.append(shape.raw_text.strip())
        elif shape.table is not None:
            texts.extend(cell for row in shape.table.cells for cell in row if cell)
        elif shape.chart is not None:
            if shape.chart.title:
                texts.append(shape.chart.title)
            texts.extend(shape.chart.categories)
            for series in shape.chart.series:
                if series.get("name"):
                    texts.append(str(series["name"]))
                texts.extend(str(value) for value in series.get("values", []))
    return [text for text in texts if text]


def _font_metrics(shapes: list[ExtractedShape]) -> dict[str, Any]:
    font_sizes = [
        size
        for shape in shapes
        for block in shape.text_blocks
        for size in block.font_sizes_pt
        if size is not None
    ]
    font_names = [
        name
        for shape in shapes
        for block in shape.text_blocks
        for name in block.font_names
        if name
    ]
    return {
        "font_sizes_pt": font_sizes,
        "min_font_size_pt": min(font_sizes) if font_sizes else None,
        "max_font_size_pt": max(font_sizes) if font_sizes else None,
        "unique_font_families": sorted(set(font_names)),
        "unique_font_family_count": len(set(font_names)),
    }


def _layout_metrics(
    shapes: list[ExtractedShape],
    *,
    slide_width: float,
    slide_height: float,
) -> dict[str, Any]:
    slide_area = slide_width * slide_height if slide_width and slide_height else 0.0
    occupied_area = sum(shape.w * shape.h for shape in shapes)
    return {
        "shape_count": len(shapes),
        "occupied_area_ratio": (occupied_area / slide_area) if slide_area else 0.0,
        "text_shape_count": sum(1 for shape in shapes if shape.shape_kind == "text"),
        "chart_count": sum(1 for shape in shapes if shape.shape_kind == "chart"),
        "table_count": sum(1 for shape in shapes if shape.shape_kind == "table"),
        "image_count": sum(1 for shape in shapes if shape.shape_kind == "image"),
    }


def _color_metrics(slide: Any, shapes: list[ExtractedShape]) -> dict[str, Any]:
    palette = [
        color
        for color in [
            _background_hex(slide),
            *[shape.fill_color_hex for shape in shapes],
            *[
                color_hex
                for shape in shapes
                for block in shape.text_blocks
                for color_hex in block.color_hexes
                if color_hex is not None
            ],
        ]
        if color
    ]
    return {
        "palette": sorted(set(palette)),
        "palette_counts": dict(Counter(palette)),
    }


def presentation_digest(presentation: PptxPresentation) -> str:
    payload = BytesIO()
    presentation.save(payload)
    return hashlib.sha256(payload.getvalue()).hexdigest()


class PptxExtractionService:
    def inspect_presentation(
        self,
        presentation: PptxEditor | PptxPresentation | str,
    ) -> ExtractedPresentation:
        opened = open_presentation(presentation)
        slides = []
        slide_width = _emu_to_inches(opened.presentation.slide_width)
        slide_height = _emu_to_inches(opened.presentation.slide_height)
        for slide_index, slide in enumerate(opened.presentation.slides, start=1):
            slides.append(
                self.inspect_slide(
                    slide_index,
                    presentation=opened.presentation,
                )
            )

        return ExtractedPresentation(
            slide_count=len(slides),
            slide_ids=[slide.slide_id for slide in slides],
            slides=slides,
            metadata={
                "inspection_mode": opened.inspection_mode,
                "source_path": opened.source_path,
                "presentation_digest": presentation_digest(opened.presentation),
                "slide_width_in": slide_width,
                "slide_height_in": slide_height,
            },
        )

    def inspect_slide(
        self,
        slide_index: int,
        *,
        presentation: PptxEditor | PptxPresentation,
    ) -> ExtractedSlide:
        opened = open_presentation(presentation)
        if slide_index < 1 or slide_index > len(opened.presentation.slides):
            raise IndexError(f"Slide index {slide_index} out of range")

        slide = opened.presentation.slides[slide_index - 1]
        slide_width = _emu_to_inches(opened.presentation.slide_width)
        slide_height = _emu_to_inches(opened.presentation.slide_height)
        shapes = [
            _extract_shape(
                slide,
                slide_index,
                shape,
                z_index,
                slide_height_in=slide_height,
            )
            for z_index, shape in enumerate(slide.shapes)
        ]

        font_metrics = _font_metrics(shapes)
        title_text = None
        try:
            title_shape = slide.shapes.title
            if title_shape is not None and getattr(
                title_shape, "has_text_frame", False
            ):
                title_text = title_shape.text_frame.text or None
        except Exception:
            title_text = None
        if not title_text:
            title_text = _title_from_shapes(shapes)

        return ExtractedSlide(
            slide_index=slide_index,
            slide_id=slide.slide_id,
            layout_name=getattr(slide.slide_layout, "name", None),
            background_color_hex=_background_hex(slide),
            title_text=title_text,
            all_text="\n".join(_shape_texts(shapes)).strip(),
            shapes=shapes,
            text_metrics={
                **font_metrics,
                "word_count": len(" ".join(_shape_texts(shapes)).split()),
            },
            layout_metrics=_layout_metrics(
                shapes,
                slide_width=slide_width,
                slide_height=slide_height,
            ),
            color_metrics=_color_metrics(slide, shapes),
            metadata={
                "inspection_mode": opened.inspection_mode,
                "slide_width_in": slide_width,
                "slide_height_in": slide_height,
            },
        )


__all__ = [
    "OpenPptxResult",
    "PptxExtractionService",
    "open_presentation",
    "presentation_digest",
]