"""Sub-tier labels: the base tiers and the variant tiers (k = 5, never-co-occurring cliques of 3 and 4
classes, small anchor), parsing of ``--tiers``, report order and per-anchor quotas.
"""
from __future__ import annotations

import zlib
from typing import Dict, List, Optional, Sequence, Tuple

import numpy as np

V1_LABELS: Tuple[str, ...] = (
    "tier1_natural_bg", "tier1_atypical_bg",
    "tier2_1typical", "tier2_1atypical",
    "tier3_2typical", "tier3_2atypical",
    "tier4_3typical", "tier4_3atypical",
    "tier5_4typical", "tier5_4atypical",
    "tier_never",
)

VARIANTS: Tuple[str, ...] = ("k5", "never_clique", "small_anchor")

VARIANT_TIERS: List[Tuple[str, str, int, str, str, str]] = [
    ("tier6_5typical", "typical", 5, "anchor_native", "k5", "tier6_5typical"),
    ("tier6_5atypical", "atypical", 5, "partner_native", "k5", "tier6_5atypical"),
    ("tier_never_k3", "never_clique", 3, "partner_native", "never_clique", "tier_never"),
    ("tier_never_k4", "never_clique", 4, "partner_native", "never_clique", "tier_never"),
    ("tier2_1typical__small_anchor", "typical", 1, "anchor_native", "small_anchor", "tier2_1typical"),
    ("tier2_1atypical__small_anchor", "atypical", 1, "partner_native", "small_anchor", "tier2_1atypical"),
]
VARIANT_OF_LABEL: Dict[str, str] = {t[0]: t[4] for t in VARIANT_TIERS}
NEVER_CLIQUE_LABELS: Tuple[str, ...] = tuple(t[0] for t in VARIANT_TIERS if t[1] == "never_clique")
SOLVER_ONLY_LABELS: Tuple[str, ...] = tuple(t[0] for t in VARIANT_TIERS if t[4] in ("k5", "never_clique"))

TIER_GROUPS: Dict[str, Tuple[str, ...]] = {
    "tier1": ("tier1_natural_bg", "tier1_atypical_bg"),
    "tier2": ("tier2_1typical", "tier2_1atypical"),
    "tier3": ("tier3_2typical", "tier3_2atypical"),
    "tier4": ("tier4_3typical", "tier4_3atypical"),
    "tier5": ("tier5_4typical", "tier5_4atypical"),
    "tier6": ("tier6_5typical", "tier6_5atypical"),
    "never": ("tier_never",),
    "never_k3": ("tier_never_k3",),
    "never_k4": ("tier_never_k4",),
    "tier2__small_anchor": ("tier2_1typical__small_anchor", "tier2_1atypical__small_anchor"),
}


def tag_label(base_label: str, variant: str) -> str:
    return f"{base_label}__{variant}"


def strip_variant(label: str) -> str:
    """``tier2_1typical__small_anchor`` -> ``tier2_1typical``; labels without a suffix pass through."""
    return label.split("__", 1)[0]


def variant_of_label(label: str) -> Optional[str]:

    parts = label.split("__", 1)
    if len(parts) == 2 and parts[1]:
        return parts[1]
    return VARIANT_OF_LABEL.get(label)


def variant_of_scene(scene: Dict) -> Optional[str]:
    """``scene["variant"]`` when the spec carries it, else derived from its sub_tier label."""
    v = scene.get("variant")
    if v:
        return str(v)
    return variant_of_label(str(scene.get("sub_tier", "")))


def prompt_base_label(label: str) -> str:

    base = strip_variant(label)
    if base in NEVER_CLIQUE_LABELS:
        return "tier_never"
    return base


def pair_label_of(label: str) -> Optional[str]:
    """The other half of a typical/atypical pair, with the same variant suffix; None for a
    never tier. ``tier1_natural_bg`` pairs with ``tier1_atypical_bg``."""
    base, sep, suffix = label.partition("__")
    tail = f"{sep}{suffix}" if sep else ""
    if base.startswith("tier_never"):
        return None
    if base == "tier1_natural_bg":
        return "tier1_atypical_bg" + tail
    if base == "tier1_atypical_bg":
        return "tier1_natural_bg" + tail
    if base.endswith("atypical"):
        return base[: -len("atypical")] + "typical" + tail
    if base.endswith("typical"):
        return base[: -len("typical")] + "atypical" + tail
    return None


def order_tiers(labels: Sequence[str]) -> List[str]:

    seen = set(labels)
    head = [t for t in V1_LABELS if t in seen]
    tail = sorted(t for t in seen if t not in V1_LABELS)
    return head + tail


def pair_tiers(labels: Sequence[str]) -> Tuple[List[Tuple[str, str]], List[str]]:
    """Split tier labels into (typical, atypical) pairs and singles. A never tier is a single;
    a pair half whose twin is absent is kept whole as a single too."""
    present = set(labels)
    pairs: List[Tuple[str, str]] = []
    singles: List[str] = []
    done = set()
    for t in order_tiers(labels):
        if t in done:
            continue
        other = pair_label_of(t)
        if other is not None and other in present and other not in done:
            typ, atyp = (t, other) if "atypical" not in strip_variant(t) else (other, t)
            pairs.append((typ, atyp))
            done.update((t, other))
        else:
            singles.append(t)
            done.add(t)
    return pairs, singles


def parse_tiers_arg(text: str) -> Dict[str, int]:
    """``"tier6=50,never_k3=100,tier2__small_anchor=50"`` -> ordered {sub_tier label: count}.

    A pair label gives ``count`` to BOTH halves (as ``--per-tier`` does for T2 to T5; unlike
    ``--per-tier``, ``tier1=N`` also gives N to each background arm rather than N/2). Unknown
    labels, repeated labels and non-integer counts raise ValueError."""
    counts: Dict[str, int] = {}
    seen_groups = set()
    for item in text.split(","):
        item = item.strip()
        if not item:
            continue
        if "=" not in item:
            raise ValueError(f"--tiers item {item!r} is not label=count")
        group, _, num = item.partition("=")
        group = group.strip()
        if group not in TIER_GROUPS:
            raise ValueError(f"--tiers: unknown label {group!r}; choose from {sorted(TIER_GROUPS)}")
        if group in seen_groups:
            raise ValueError(f"--tiers: label {group!r} given twice")
        seen_groups.add(group)
        try:
            n = int(num.strip())
        except ValueError:
            raise ValueError(f"--tiers: count for {group!r} must be an integer, got {num!r}")
        if n < 0:
            raise ValueError(f"--tiers: count for {group!r} must be >= 0")
        for label in TIER_GROUPS[group]:
            counts[label] = n
    if not counts:
        raise ValueError("--tiers is empty")
    return counts


def stable_hash(text: str) -> int:
    """Process-independent 32-bit hash (Python's ``hash`` of a str is salted per process)."""
    return zlib.crc32(text.encode("utf-8")) & 0xFFFFFFFF


def allocate_per_anchor(n_images: int, anchor_idxs: Sequence[int], seed: int,
                        tier_label: str, quota_cap: int = 0,
                        caps: Optional[Dict[int, int]] = None) -> Dict[int, int]:

    anchors = sorted(int(a) for a in anchor_idxs)
    if not anchors or n_images <= 0:
        return {}
    rng = np.random.default_rng([int(seed), stable_hash(tier_label)])
    cap_of = {a: (int(caps.get(a, 0)) if caps is not None else int(n_images)) for a in anchors}
    if quota_cap > 0:
        cap_of = {a: min(c, int(quota_cap)) for a, c in cap_of.items()}
    total_cap = sum(cap_of.values())
    n_target = min(int(n_images), total_cap)
    base = n_target // len(anchors)
    alloc = {a: min(base, cap_of[a]) for a in anchors}
    left = n_target - sum(alloc.values())
    order = [anchors[int(i)] for i in rng.permutation(len(anchors))]
    while left > 0:
        progressed = False
        for a in order:
            if left <= 0:
                break
            if alloc[a] < cap_of[a]:
                alloc[a] += 1
                left -= 1
                progressed = True
        if not progressed:
            break
    return {a: c for a, c in alloc.items() if c > 0}