from __future__ import annotations

import re
from typing import Any

try:
    from .krea_action_context import (
        axis_values_text,
        is_climax_text,
        is_foreplay_text,
        is_oral_text,
        is_outercourse_text,
        is_toy_assisted_double_text,
        is_vaginal_penetration_text,
        normalize_hardcore_detail_density,
    )
    from .krea_detail import detail_clauses, join_detail_clauses, limit_detail_for_density
    from .krea_action_positions import (
        action_position_phrase,
        arrangement_duplicates_role,
        hardcore_pose_anchor,
        hardcore_pose_arrangement,
        mentions_rear_entry,
    )
    from .krea_action_details import (
        dedupe_anchor_detail,
        dedupe_oral_detail,
        dedupe_outercourse_detail,
        dedupe_penetration_detail,
        dedupe_toy_double_detail,
        hardcore_item_detail,
        sanitize_foreplay_detail,
    )
except ImportError:  # Allows local smoke tests with `python -c`.
    from krea_action_context import (
        axis_values_text,
        is_climax_text,
        is_foreplay_text,
        is_oral_text,
        is_outercourse_text,
        is_toy_assisted_double_text,
        is_vaginal_penetration_text,
        normalize_hardcore_detail_density,
    )
    from krea_detail import detail_clauses, join_detail_clauses, limit_detail_for_density
    from krea_action_positions import (
        action_position_phrase,
        arrangement_duplicates_role,
        hardcore_pose_anchor,
        hardcore_pose_arrangement,
        mentions_rear_entry,
    )
    from krea_action_details import (
        dedupe_anchor_detail,
        dedupe_oral_detail,
        dedupe_outercourse_detail,
        dedupe_penetration_detail,
        dedupe_toy_double_detail,
        hardcore_item_detail,
        sanitize_foreplay_detail,
    )


def _clean(value: Any) -> str:
    text = "" if value is None else str(value)
    text = text.replace("\n", " ")
    text = re.sub(r"\s+", " ", text).strip()
    text = re.sub(r"\s+([,.;:])", r"\1", text)
    return text


def _lowercase_for_inline_join(text: str) -> str:
    text = _clean(text)
    return text[:1].lower() + text[1:] if text else text


def _with_indefinite_article(text: str) -> str:
    text = _clean(text)
    if not text or text.lower().startswith(("a ", "an ")):
        return text
    article = "an" if text[:1].lower() in "aeiou" else "a"
    return f"{article} {text}"


def _normalize_climax_view_clause(clause: str, role_graph: str) -> str:
    lower = clause.lower()
    if "view" not in lower and "frame" not in lower:
        return clause
    angle_match = re.search(
        r"\b(front-facing|close-up|wide full-body|wide|overhead|mirror-reflected|low-angle|side-profile|bed-level)\b",
        lower,
    )
    if not angle_match:
        return clause
    angle = angle_match.group(1)
    if angle == "wide":
        angle = "wide full-body"
    position = action_position_phrase(role_graph)
    if position:
        return f"{angle} aftermath view with the {position} readable"
    return f"{angle} aftermath view"


def _climax_clause_duplicates_role(clause: str, role_graph: str) -> bool:
    clause_lower = clause.lower()
    role_lower = role_graph.lower()
    role_has_ejaculation = any(token in role_lower for token in ("ejaculates semen", "visible semen", "semen lands"))
    if role_has_ejaculation and re.search(
        r"\b(?:cum clearly visible|explicit semen aftermath visible|hardcore ejaculation detail visible|"
        r"post-ejaculation fluids anatomically clear|sexual fluids and body contact visible|"
        r"visible external ejaculation|hardcore ejaculation scene|visible orgasm aftermath)\b",
        clause_lower,
    ):
        return True
    duplicate_pairs = (
        (("lower back", "ass"), ("lower back", "ass")),
        (("ass",), ("ass",)),
        (("pussy", "thigh"), ("pussy", "thigh")),
        (("face", "lips"), ("face", "lips")),
        (("tongue", "chin"), ("face", "lips", "mouth", "tongue")),
        (("breast",), ("breast", "chest")),
        (("belly",), ("belly", "torso")),
        (("body",), ("body",)),
    )
    if any(token in clause_lower for token in ("cum", "semen", "fluid")):
        for clause_tokens, role_tokens in duplicate_pairs:
            if any(token in clause_lower for token in clause_tokens) and any(token in role_lower for token in role_tokens):
                return True
    return False


def climax_role_graph(role_graph: str, hard_item: str, axis_values: Any = None) -> str:
    role_graph = _clean(role_graph).rstrip(".")
    text = " ".join(part.lower() for part in (role_graph, _clean(hard_item), axis_values_text(axis_values)) if part)
    if "the woman" not in text or "the man" not in text:
        return role_graph
    if "lying between two partners" in text or "lies between" in text:
        return "the woman lies between two partners, the man under her hips and another partner over her torso as visible semen lands on her body"
    if "held between front-and-back partners" in text:
        return "the woman is held between the man behind her and another partner in front of her as visible semen lands across her body"
    if "kneeling between standing partners" in text:
        return "the woman kneels between standing partners gathered around her face and torso for visible ejaculation"
    if "side-lying with thighs parted" in text:
        return "the woman lies on her side with thighs parted while the man kneels beside her hips and ejaculates semen across her thighs and pussy"
    if "sitting on the edge of the bed" in text:
        return "the woman sits on the edge of the bed with knees spread while the man stands close between her legs and ejaculates semen across her body"
    if "lying at the bed edge with thighs open" in text:
        return "the woman lies at the bed edge with thighs open while the man kneels between her legs and ejaculates semen across her pussy and thighs"
    if "reclining with thighs open" in text or "lying on the back with legs spread" in text:
        return "the woman lies on her back with thighs open while the man kneels between her legs and ejaculates semen across her pussy and thighs"
    if "on all fours with hips raised" in text:
        return "the woman is on all fours with hips raised while the man is positioned behind her and ejaculates semen across her ass, thighs, and lower back"
    if "face-down ass-up" in text or "lies face-down" in text or "face down" in text:
        return "the woman lies face-down with ass raised while the man is positioned behind her and ejaculates semen across her lower back and ass"
    if "bent over with ass raised" in text or "bent over" in text:
        return "the woman bends forward with hips raised while the man stands behind her with visible semen across her lower back, ass, and thighs"
    if "kneeling with mouth open" in text:
        return "the woman kneels in front of the man at hip height as he ejaculates semen onto her face, lips, and chest"
    if "kneeling in front of a standing partner" in text:
        return "the woman kneels in front of the man at hip height while he stands over her for visible ejaculation"
    if "standing with cum on the body" in text:
        return "the woman stands braced in front of the man while he stands close at hip level and ejaculates semen across her body"
    if "squatting on top of a partner" in text:
        return "the woman squats over the man's hips while the man lies on his back under her and ejaculates semen onto her body"
    if "reverse cowgirl over a partner's hips" in text:
        return "the woman straddles the man's hips facing away while the man lies on his back under her and ejaculates semen onto her body"
    if "straddles" in text or "straddling a partner" in text or "straddling a partner's hips" in text or "shared climax after penetration" in text:
        return "the woman straddles the man's hips while the man lies on his back under her and ejaculates semen onto her body"
    if "seated in a partner's lap facing them" in text:
        return "the woman sits in the man's lap facing him, legs wrapped around his hips as he ejaculates semen across her body"
    if "lower back" in text or "cum dripping from ass" in text or "cum on lower back" in text or mentions_rear_entry(text):
        return "the woman bends forward with hips raised while the man stands behind her with visible semen across her lower back, ass, and thighs"
    if "cum on face" in text or "cum on tongue" in text or "cum on lips" in text or "cum on tongue and chin" in text:
        return "the woman kneels in front of the man at hip height as he ejaculates semen onto her face, lips, and chest"
    if (
        "cum dripping from pussy" in text
        or "arousal dripping from pussy" in text
        or "open thighs" in text
    ):
        return "the woman lies on her back with thighs open while the man kneels between her legs and ejaculates semen across her pussy and thighs"
    if role_graph:
        return role_graph
    return "the woman lies on her back with thighs open while the man kneels between her legs and ejaculates semen across her body"


def _dedupe_climax_detail(detail: str, role_graph: str, density: str = "balanced") -> str:
    detail = _clean(detail)
    lower = role_graph.lower()
    patterns: list[str] = []
    if "lies on her back" in lower:
        patterns.extend((r"lying on the back with legs spread and hips lifted", r"reclining with thighs open", r"lying on the back with legs spread"))
        detail = re.sub(r"\bcum on lower back and ass\b", "cum across thighs and pussy", detail, flags=re.IGNORECASE)
        detail = re.sub(r"\bcum (?:on|dripping from) ass\b", "cum across thighs and pussy", detail, flags=re.IGNORECASE)
    if "straddles" in lower:
        patterns.extend(
            (
                r"straddling a partner's hips in cowgirl position",
                r"reverse cowgirl over a partner's hips",
                r"straddling a partner",
                r"squatting on top of a partner",
            )
        )
    if "squats over" in lower:
        patterns.append(r"squatting on top of a partner")
    if "sits in the man's lap" in lower:
        patterns.append(r"seated in a partner's lap facing them")
    if "bends forward" in lower:
        patterns.append(r"bent over with ass raised")
    if "on all fours" in lower:
        patterns.append(r"on all fours with hips raised")
    if "face-down" in lower:
        patterns.append(r"face-down ass-up on the mattress")
    if "lies on her side" in lower:
        patterns.append(r"side-lying with thighs parted")
    if "sits on the edge" in lower:
        patterns.append(r"sitting on the edge of the bed")
    if "bed edge" in lower:
        patterns.append(r"lying at the bed edge with thighs open")
    if "kneels in front" in lower:
        patterns.extend((r"kneeling with mouth open", r"kneeling in front of a standing partner"))
    if "stands braced" in lower:
        patterns.append(r"standing with cum on the body")
    for pattern in patterns:
        detail = re.sub(rf"\b{pattern}\b,?\s*", "", detail, flags=re.IGNORECASE)
    if not any(token in lower for token in ("face", "mouth", "lips", "tongue")):
        detail = re.sub(r"\bsaliva and cum mixed on the mouth\b", "visible semen on skin", detail, flags=re.IGNORECASE)
        detail = re.sub(r"\bcum on tongue and chin\b", "visible semen on skin", detail, flags=re.IGNORECASE)
        detail = re.sub(r"\bcum on face and lips\b", "visible semen on skin", detail, flags=re.IGNORECASE)
    detail = re.sub(r",\s*,", ",", detail)
    detail = re.sub(r"\bwith\s*,\s*", "with ", detail, flags=re.IGNORECASE)
    detail = re.sub(r"^with\s+", "", detail, flags=re.IGNORECASE)
    detail = re.sub(r"^and\s+", "", detail, flags=re.IGNORECASE)
    clauses: list[str] = []
    for clause in detail_clauses(detail):
        normalized = _normalize_climax_view_clause(clause, role_graph)
        if _climax_clause_duplicates_role(normalized, role_graph):
            continue
        if density != "dense" and normalized.lower() in ("orgasm during penetration", "post-orgasm visible release"):
            continue
        clauses.append(normalized)
    return limit_detail_for_density(join_detail_clauses(clauses), density, True)


def hardcore_action_sentence(
    role_graph: str,
    hard_item: str,
    composition: str = "",
    axis_values: Any = None,
    detail_density: str = "balanced",
) -> str:
    detail_density = normalize_hardcore_detail_density(detail_density)
    role_graph = _clean(role_graph).rstrip(".")
    hard_item = _clean(hard_item).rstrip(".")
    role_graph = re.sub(
        r"\bthe man penetrates the woman while a toy adds a second point of contact\b",
        "the man's penis thrusts into the woman while a toy is positioned at the second penetration point",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe man thrusts his penis into the woman while a toy adds a second penetration point\b",
        "the man's penis thrusts into the woman while a toy is positioned at the second penetration point",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe man thrusts his penis into the woman\b",
        "the man's penis thrusts into the woman",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe man penetrates the woman anally\b",
        "the man's penis thrusts into the woman's ass",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe man thrusts his penis into the woman's ass\b",
        "the man's penis thrusts into the woman's ass",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe man penetrates the woman\b",
        "the man's penis thrusts into the woman",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe woman and the man are in mutual oral contact with mouth-to-genital contact visible\b",
        "the woman has the man's penis in her mouth while the man uses his mouth on her pussy",
        role_graph,
        flags=re.IGNORECASE,
    )
    role_graph = re.sub(
        r"\bthe woman gives oral to the man\b",
        "the woman takes the man's penis in her mouth",
        role_graph,
        flags=re.IGNORECASE,
    )
    is_climax = is_climax_text(role_graph, hard_item, composition, axis_values_text(axis_values))
    if is_climax:
        role_graph = climax_role_graph(role_graph, hard_item, axis_values)
    detail = hardcore_item_detail(hard_item)
    anchor = hardcore_pose_anchor(role_graph, hard_item, composition, axis_values)
    is_outercourse = is_outercourse_text(role_graph, hard_item, composition, axis_values_text(axis_values))
    is_oral = is_oral_text(role_graph, hard_item, composition, axis_values_text(axis_values))
    is_penetrative = is_vaginal_penetration_text(role_graph, hard_item, composition, axis_values_text(axis_values))
    if is_toy_assisted_double_text(role_graph, hard_item, composition, axis_values_text(axis_values)):
        role_graph = re.sub(
            r"\s+while a toy adds (?:the|a) second penetration point\b",
            " while a toy is positioned at the second penetration point",
            role_graph,
            flags=re.IGNORECASE,
        )
    if is_climax:
        anchor = ""
        detail = _dedupe_climax_detail(detail, role_graph, detail_density)
    elif is_foreplay_text(role_graph, hard_item, composition, axis_values_text(axis_values)):
        anchor = ""
        detail = sanitize_foreplay_detail(detail, role_graph, composition)
        detail = limit_detail_for_density(detail, detail_density, False)
    elif is_outercourse:
        anchor = ""
        detail = dedupe_outercourse_detail(detail, role_graph, hard_item, axis_values)
        detail = limit_detail_for_density(detail, detail_density, False)
    elif is_oral and role_graph:
        anchor = ""
        detail = dedupe_oral_detail(detail, role_graph, hard_item, axis_values)
        detail = limit_detail_for_density(detail, detail_density, False)
    elif is_penetrative and role_graph:
        anchor = ""
        detail = dedupe_penetration_detail(detail, role_graph, hard_item, axis_values)
        detail = limit_detail_for_density(detail, detail_density, False)
    else:
        detail = dedupe_anchor_detail(detail, anchor) if anchor else detail
        if is_toy_assisted_double_text(role_graph, hard_item, composition, axis_values_text(axis_values)):
            detail = dedupe_toy_double_detail(detail)
        detail = limit_detail_for_density(detail, detail_density, False)
    arrangement = hardcore_pose_arrangement(anchor, role_graph, hard_item, composition, axis_values)
    anchor_phrase = _with_indefinite_article(anchor) if anchor else ""
    if arrangement and anchor_phrase and not arrangement_duplicates_role(arrangement, role_graph):
        anchor_phrase = f"{anchor_phrase} {arrangement}"
    if role_graph and anchor_phrase:
        sentence = f"In {anchor_phrase}, {_lowercase_for_inline_join(role_graph)}"
    elif role_graph:
        sentence = role_graph
    elif detail and anchor_phrase:
        sentence = f"In {anchor_phrase}, {detail}"
        detail = ""
    else:
        sentence = detail or hard_item
        detail = ""
    if detail:
        sentence = f"{sentence}; {detail}"
    return sentence