"""Pure versioned live-tactics decision and probability policy."""
from __future__ import annotations

from dataclasses import dataclass

from ..state import TacticalInstructionState, TeamTacticalContext

POLICY_KEY = "ftg.match.live_tactics.v1"
POLICY_VERSION = "1.0.0"

ATTACK_FACTORS = {
    "BALANCED": (1.000, 1.000),
    "POSSESSION": (0.985, 1.055),
    "DIRECT": (1.060, 0.945),
    "COUNTER_ATTACK": (1.035, 0.960),
    "WIDE_PLAY": (1.030, 0.985),
    "HIGH_TEMPO": (1.080, 1.020),
}
DEFENCE_FACTORS = {
    "BALANCED": (1.000, 1.000),
    "HIGH_PRESS": (1.055, 1.025),
    "MID_BLOCK": (1.035, 1.005),
    "LOW_BLOCK": (1.080, 0.950),
    "MAN_MARKING": (1.045, 0.985),
    "ZONAL_COMPACT": (1.055, 1.000),
}
MATCHUP = {
    ("COUNTER_ATTACK", "HIGH_PRESS"): 0.055,
    ("WIDE_PLAY", "ZONAL_COMPACT"): 0.035,
    ("HIGH_TEMPO", "LOW_BLOCK"): 0.025,
    ("POSSESSION", "HIGH_PRESS"): 0.020,
    ("POSSESSION", "LOW_BLOCK"): -0.035,
    ("DIRECT", "LOW_BLOCK"): -0.020,
    ("DIRECT", "HIGH_PRESS"): 0.020,
}
DEFENSIVE_MATCHUP = {
    ("HIGH_PRESS", "POSSESSION"): 0.040,
    ("LOW_BLOCK", "DIRECT"): 0.035,
    ("MID_BLOCK", "HIGH_TEMPO"): 0.020,
    ("MAN_MARKING", "DIRECT"): 0.020,
    ("ZONAL_COMPACT", "WIDE_PLAY"): -0.025,
}


@dataclass(frozen=True, slots=True)
class TacticalTransition:
    source: str
    trigger_type: str
    attacking_strategy: str
    defensive_strategy: str
    applied_key: str


def _triggered(rule: TacticalInstructionState, *, minute, score_diff, own_reds, opponent_reds):
    if minute < rule.minute_from:
        return False
    return {
        "MINUTE": True,
        "TRAILING": score_diff < 0,
        "LEADING": score_diff > 0,
        "DRAWING": score_diff == 0,
        "SELF_RED_CARD": own_reds > 0,
        "OPPONENT_RED_CARD": opponent_reds > 0,
    }[rule.trigger_type]


def next_transition(
    context: TeamTacticalContext,
    *, minute: int, score_diff: int, own_reds: int, opponent_reds: int,
    current_attack: str, current_defence: str, applied_keys: set[str],
) -> TacticalTransition | None:
    # User-authored rules always outrank automatic coach adaptation.
    for rule in sorted(context.instructions, key=lambda r: (r.priority, r.minute_from)):
        key = f"USER:{rule.priority}"
        if key in applied_keys or not _triggered(
            rule, minute=minute, score_diff=score_diff,
            own_reds=own_reds, opponent_reds=opponent_reds,
        ):
            continue
        return TacticalTransition(
            source="USER_RULE", trigger_type=rule.trigger_type,
            attacking_strategy=rule.attacking_strategy,
            defensive_strategy=rule.defensive_strategy,
            applied_key=key,
        )

    if context.adaptation_mode == "STATIC":
        return None

    candidates = []
    if own_reds > 0:
        candidates.append(("SELF_RED_CARD", "COUNTER_ATTACK", "LOW_BLOCK", 1))
    if opponent_reds > 0 and minute >= 30:
        candidates.append(("OPPONENT_RED_CARD", "HIGH_TEMPO", "HIGH_PRESS", 2))

    quality = context.coaching_quality
    if context.adaptation_mode == "RESPONSIVE":
        trailing_minute = 31 if quality >= 80 else 46 if quality >= 50 else 61
        leading_minute = 46 if quality >= 80 else 61 if quality >= 50 else 76
        drawing_minute = 61 if quality >= 80 else 76
        if score_diff < 0 and minute >= trailing_minute:
            candidates.append(("TRAILING", "HIGH_TEMPO", "HIGH_PRESS", 3))
        elif score_diff > 0 and minute >= leading_minute:
            candidates.append(("LEADING", "POSSESSION", "LOW_BLOCK", 4))
        elif score_diff == 0 and minute >= drawing_minute:
            candidates.append(("DRAWING", "DIRECT", "HIGH_PRESS", 5))
    else:  # BALANCED
        trailing_minute = 46 if quality >= 80 else 61 if quality >= 45 else 76
        leading_minute = 61 if quality >= 80 else 76
        if score_diff < 0 and minute >= trailing_minute:
            candidates.append(("TRAILING", "DIRECT", "HIGH_PRESS", 3))
        elif score_diff > 0 and minute >= leading_minute:
            candidates.append(("LEADING", "POSSESSION", "MID_BLOCK", 4))

    for trigger, attack, defence, rank in sorted(candidates, key=lambda x: x[3]):
        key = f"AUTO:{trigger}"
        if key in applied_keys:
            continue
        if attack == current_attack and defence == current_defence:
            applied_keys.add(key)
            continue
        return TacticalTransition(
            source="AUTO_ADAPTATION", trigger_type=trigger,
            attacking_strategy=attack, defensive_strategy=defence,
            applied_key=key,
        )
    return None


def segment_multiplier(
    context: TeamTacticalContext,
    *, attack_strategy: str, defence_strategy: str,
    opponent_attack_strategy: str, opponent_defence_strategy: str,
    own_reds: int, opponent_reds: int,
) -> dict[str, float]:
    coaching_scale = 0.70 + min(100.0, max(0.0, context.coaching_quality)) / 200.0
    raw_attack, raw_control = ATTACK_FACTORS[attack_strategy]
    raw_defence, raw_def_control = DEFENCE_FACTORS[defence_strategy]
    attack = 1.0 + (raw_attack - 1.0) * coaching_scale
    control = 1.0 + (raw_control - 1.0) * coaching_scale
    defence = 1.0 + (raw_defence - 1.0) * coaching_scale
    defensive_control = 1.0 + (raw_def_control - 1.0) * coaching_scale

    matchup = MATCHUP.get((attack_strategy, opponent_defence_strategy), 0.0)
    insight_scale = 0.55 + (context.analysis_quality / 100.0) * 0.90
    matchup_factor = 1.0 + matchup * insight_scale

    leadership_mitigation = min(0.08, context.head_coach_leadership * 0.0008)
    own_red_factor = (0.78 + leadership_mitigation) ** own_reds
    opponent_red_factor = 1.18 ** opponent_reds

    xg_factor = attack * (0.65 + 0.35 * control) * matchup_factor
    xg_factor *= own_red_factor * opponent_red_factor
    # Own defensive plan is useful to the team's transition stability, while
    # the opponent's defensive plan directly suppresses expected goals.
    stability = 0.88 + 0.12 * defensive_control
    xg_factor *= stability

    return {
        "xg_factor": max(0.45, min(1.75, xg_factor)),
        "attack_factor": attack,
        "control_factor": control,
        "defence_factor": defence,
        "matchup_factor": matchup_factor,
        "own_red_factor": own_red_factor,
        "opponent_red_factor": opponent_red_factor,
        "analysis_quality": float(context.analysis_quality),
        "coaching_quality": round(context.coaching_quality, 3),
    }


def opponent_defence_suppression(
    opponent_context: TeamTacticalContext,
    *, opponent_defence_strategy: str, attacking_strategy: str,
) -> float:
    raw_defence, _ = DEFENCE_FACTORS[opponent_defence_strategy]
    scale = 0.70 + min(100.0, max(0.0, opponent_context.coaching_quality)) / 200.0
    base = 1.0 + (raw_defence - 1.0) * scale
    matchup = DEFENSIVE_MATCHUP.get((opponent_defence_strategy, attacking_strategy), 0.0)
    insight_scale = 0.55 + (opponent_context.analysis_quality / 100.0) * 0.90
    return max(0.80, min(1.30, base * (1.0 + matchup * insight_scale)))
