#!/usr/bin/env python3
"""Metric-v4.3 frozen DISK-pilot helpers.

V4.3 keeps v4.2 geometry and balances dimension-scale consistency by semantic
dimension groups.  Repeating the same diameter DIMENSION therefore cannot
outvote one incorrect thickness DIMENSION.
"""

from __future__ import annotations

import math
from typing import Any

import numpy as np

try:
    from . import eval_geometric04 as CORE
    from . import eval_geometric042 as GEOMETRY
except ImportError:
    import eval_geometric04 as CORE
    import eval_geometric042 as GEOMETRY


canonicalize_entities = GEOMETRY.canonicalize_entities
extract_entities = GEOMETRY.extract_entities
legacy_dimension_entities = GEOMETRY.legacy_dimension_entities
representation_quality = GEOMETRY.representation_quality
score_disk_semantics = GEOMETRY.score_disk_semantics


def _semantic_family(family: str) -> str:
    if family in {"diameter", "radius"}:
        return "circular"
    if family in {"linear", "aligned"}:
        return "linear"
    return family


def _equivalent_value(first: dict[str, Any], second: dict[str, Any]) -> bool:
    if _semantic_family(str(first.get("family"))) != _semantic_family(str(second.get("family"))):
        return False
    first_value = first.get("display_value")
    second_value = second.get("display_value")
    if not isinstance(first_value, (int, float)) or not isinstance(second_value, (int, float)):
        return first_value is None and second_value is None
    if str(first.get("family")) == "radius":
        first_value = 2.0 * float(first_value)
    if str(second.get("family")) == "radius":
        second_value = 2.0 * float(second_value)
    tolerance = max(0.01, 0.001 * max(abs(float(first_value)), abs(float(second_value)), 1.0))
    return abs(float(first_value) - float(second_value)) <= tolerance


def _group_items(items: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
    groups: list[list[dict[str, Any]]] = []
    for item in items:
        for group in groups:
            if _equivalent_value(item, group[0]):
                group.append(item)
                break
        else:
            groups.append([item])
    return groups


def _consensus(log_ratios: list[float]) -> tuple[float | None, float]:
    if not log_ratios:
        return None, 0.0
    threshold = math.log1p(CORE.DIMENSION_SCALE_INLIER_REL)
    global_median = float(np.median(log_ratios))
    candidates: list[tuple[int, float, list[float]]] = []
    for candidate in log_ratios:
        inliers = [value for value in log_ratios if abs(value - candidate) <= threshold]
        centre = float(np.median(inliers))
        candidates.append((len(inliers), -abs(centre - global_median), inliers))
    _, _, inliers = max(candidates, key=lambda value: (value[0], value[1]))
    centre = float(np.median(inliers))
    score = float(
        np.mean(
            [
                math.exp(-abs(value - centre) / CORE.DIMENSION_SCALE_DECAY)
                for value in log_ratios
            ]
        )
    )
    return centre, score


def score_dimension_consistency(entities: dict[str, Any]) -> dict[str, Any]:
    """Return dimension consistency with one vote per semantic dimension."""

    raw = CORE.score_dimension_consistency(entities)
    items = list(raw.get("items", []))
    if not items:
        result = dict(raw)
        result.update({"raw_score": raw["score"], "n_groups": 0, "duplicate_dimensions": 0, "groups": []})
        return result
    groups = _group_items(items)
    group_details: list[dict[str, Any]] = []
    log_ratios: list[float] = []
    for group in groups:
        ratios = [
            float(item["scale_ratio"])
            for item in group
            if isinstance(item.get("scale_ratio"), (int, float))
            and float(item["scale_ratio"]) > 0
        ]
        group_ratio = float(np.median(ratios)) if ratios else None
        if group_ratio is not None:
            log_ratios.append(math.log(group_ratio))
        group_details.append(
            {
                "family": _semantic_family(str(group[0].get("family"))),
                "display_value": group[0].get("display_value"),
                "count": len(group),
                "scale_ratio": round(group_ratio, 8) if group_ratio is not None else None,
                "binding_quality": round(
                    float(np.median([float(item.get("binding_quality", 0.0)) for item in group])),
                    6,
                ),
                "valid": group_ratio is not None,
            }
        )
    centre, scale_consistency = _consensus(log_ratios)
    for group in group_details:
        ratio = group["scale_ratio"]
        group["scale_quality"] = (
            round(
                math.exp(-abs(math.log(float(ratio)) - centre) / CORE.DIMENSION_SCALE_DECAY),
                6,
            )
            if ratio is not None and centre is not None
            else 0.0
        )
    binding_quality = float(np.mean([group["binding_quality"] for group in group_details]))
    n_valid = len(log_ratios)
    n_invalid = len(groups) - n_valid
    completeness = n_valid / max(len(groups), 1)
    score = scale_consistency * binding_quality * completeness
    return {
        "score": round(float(score), 6),
        "raw_score": float(raw["score"]),
        "n_dimensions": len(items),
        "n_groups": len(groups),
        "duplicate_dimensions": len(items) - len(groups),
        "n_valid": n_valid,
        "n_invalid": n_invalid,
        "drawing_scale": round(math.exp(centre), 8) if centre is not None else None,
        "scale_consistency": round(float(scale_consistency), 6),
        "binding_quality": round(float(binding_quality), 6),
        "data_valid": bool(n_invalid == 0 and scale_consistency >= 0.8),
        "groups": group_details,
        "items": items,
    }


__all__ = [
    "canonicalize_entities",
    "extract_entities",
    "legacy_dimension_entities",
    "representation_quality",
    "score_dimension_consistency",
    "score_disk_semantics",
]