from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Callable


@dataclass(frozen=True)
class KreaConfiguredCastRequest:
    row: dict[str, Any]
    detail_level: str
    style_mode: str
    primary: str
    item: str
    scene: str
    expression: str
    composition: str
    source_composition: str
    camera: str
    camera_scene: str
    style: str


@dataclass(frozen=True)
class KreaConfiguredCastPrompt:
    prompt: str
    method: str = "metadata(configured_cast)"

    def as_tuple(self) -> tuple[str, str]:
        return self.prompt, self.method


@dataclass(frozen=True)
class KreaConfiguredCastDependencies:
    clean: Callable[[Any], str]
    prompt_field: Callable[[str, str], str]
    sanitize_hardcore_environment_anchors: Callable[[Any], str]
    sanitize_hardcore_axis_values: Callable[[Any], Any]
    sanitize_scene_text_for_cast: Callable[[Any, list[str]], str]
    normalize_hardcore_detail_density: Callable[[Any], str]
    row_action_family: Callable[[Any], str]
    hardcore_action_sentence: Callable[[str, str, str, Any, str, str], str]
    pov_action_phrase: Callable[[str, list[str], str, str, str, Any, str], str]
    pov_labels_from_value: Callable[[Any], list[str]]
    merge_labels: Callable[..., list[str]]
    cast_prose_omit: Callable[[str, list[str]], tuple[str, list[str]]]
    filter_pov_labeled_clauses: Callable[[Any, list[str]], str]
    natural_label_text: Callable[[Any, list[str]], str]
    pov_composition_text: Callable[[Any, list[str]], str]
    pov_camera_phrase: Callable[[list[str]], str]
    expression_phrase: Callable[[Any], str]
    composition_phrase: Callable[..., str]
    paragraph: Callable[[list[str]], str]


def format_configured_cast_result(
    request: KreaConfiguredCastRequest,
    deps: KreaConfiguredCastDependencies,
) -> KreaConfiguredCastPrompt:
    row = request.row
    subject = deps.clean(row.get("subject_phrase") or request.primary or "adult sexual scene")
    cast = deps.clean(row.get("cast_summary"))
    try:
        women_count = int(row.get("women_count") or 0)
        men_count = int(row.get("men_count") or 0)
    except (TypeError, ValueError):
        women_count = men_count = 0
    cast_descriptor_text = (
        deps.clean(row.get("cast_descriptor_text"))
        or deps.prompt_field(deps.clean(row.get("prompt")), "Characters")
        or deps.prompt_field(deps.clean(row.get("prompt")), "Cast descriptors")
    )
    pov_labels = deps.pov_labels_from_value(row.get("pov_character_labels"))
    camera = request.camera
    if pov_labels:
        camera = ""
    cast_prose, cast_labels = deps.cast_prose_omit(cast_descriptor_text, pov_labels)
    if not cast_labels and women_count == 1 and men_count == 1:
        cast_labels = ["Woman A", "Man A"]
    cast_labels = deps.merge_labels(cast_labels, pov_labels)
    expression = deps.filter_pov_labeled_clauses(request.expression, pov_labels)
    expression = deps.natural_label_text(expression, cast_labels)
    composition = deps.sanitize_hardcore_environment_anchors(request.composition)
    source_composition = deps.sanitize_hardcore_environment_anchors(request.source_composition)
    role_graph = deps.sanitize_scene_text_for_cast(
        deps.sanitize_hardcore_environment_anchors(row.get("source_role_graph") or row.get("role_graph")),
        cast_labels,
    )
    item = deps.sanitize_scene_text_for_cast(
        deps.sanitize_hardcore_environment_anchors(request.item),
        cast_labels,
    )
    role_graph = deps.natural_label_text(role_graph, cast_labels)
    item = deps.natural_label_text(item, cast_labels)
    axis_values = deps.sanitize_hardcore_axis_values(row.get("item_axis_values"))
    detail_density = deps.normalize_hardcore_detail_density(row.get("hardcore_detail_density"))
    action = deps.hardcore_action_sentence(
        role_graph,
        item,
        source_composition,
        axis_values,
        detail_density,
        deps.row_action_family(row),
    )
    action = deps.pov_action_phrase(
        action,
        pov_labels,
        role_graph,
        item,
        source_composition,
        axis_values,
        detail_density,
    )
    output_composition = deps.pov_composition_text(composition, pov_labels)
    parts = [
        action,
        deps.pov_camera_phrase(pov_labels),
        cast_prose,
        f"A consensual explicit adult scene with {subject}" if not action else "",
        f"The cast includes {cast}" if cast and not cast_prose and not (women_count == 1 and men_count == 1) else "",
        f"The setting is {request.scene}" if request.scene else "",
        request.camera_scene,
        deps.expression_phrase(expression),
        deps.composition_phrase(output_composition, action, "The image is framed as", detail_density),
        camera,
        request.style if request.detail_level != "concise" else "",
    ]
    return KreaConfiguredCastPrompt(deps.paragraph(parts))


def format_configured_cast(
    request: KreaConfiguredCastRequest,
    deps: KreaConfiguredCastDependencies,
) -> tuple[str, str]:
    return format_configured_cast_result(request, deps).as_tuple()