"""Diagnostic polygon topology/order and image-appearance comparisons.

Everything here is for audit ranking, not relabelling, fixed-K conversion,
training input, threshold calibration, or automatic qualification.
"""
from collections import Counter
import math

import cv2
import numpy as np


def modes(values):
    counts = Counter(values)
    maximum = max(counts.values(), default=0)
    return sorted(k for k, n in counts.items() if n == maximum), counts


def signed_area(points):
    p = np.asarray(points, float)
    return float(np.sum(p[:, 0]*np.roll(p[:, 1], -1)-p[:, 1]*np.roll(p[:, 0], -1))/2)


def normalize(points, box):
    return (np.asarray(points, float)-[box['x'], box['y']])/[box['width'], box['height']]


def best_index_alignment(points, reference):
    """Cyclic/reverse equivalence is measured, never applied to saved labels."""
    p, q = np.asarray(points, float), np.asarray(reference, float)
    if p.shape != q.shape:
        return None
    options = []
    for reverse in (False, True):
        ref = q[::-1] if reverse else q
        for shift in range(len(ref)):
            candidate = np.roll(ref, shift, axis=0)
            error = float(np.sqrt(np.mean(np.sum((p-candidate)**2, axis=1))))
            options.append((error, reverse, shift))
    error, reverse, shift = min(options)
    raw = float(np.sqrt(np.mean(np.sum((p-q)**2, axis=1))))
    return dict(raw_vertex_rms_normalized=raw, best_cyclic_reverse_rms_normalized=error,
        reversed_reference=reverse, cyclic_shift=shift,
        index_order_candidate=raw > .15 and raw-error > .10 and error < .12)


def polygon_features(points, box):
    p = np.asarray(points, float); q = normalize(p, box)
    area = signed_area(p); edges = np.roll(p, -1, axis=0)-p
    lengths = np.linalg.norm(edges, axis=1)
    incoming = p-np.roll(p, 1, axis=0); outgoing = np.roll(p, -1, axis=0)-p
    cross = incoming[:, 0]*outgoing[:, 1]-incoming[:, 1]*outgoing[:, 0]
    dot = np.sum(incoming*outgoing, axis=1)
    turn = np.degrees(np.arctan2(cross, dot))
    direction = 1 if area >= 0 else -1
    reflex = int(np.sum(turn*direction < -10))
    native_contour = p.astype(np.float32).reshape(-1, 1, 2)
    reduced = {str(epsilon): len(cv2.approxPolyDP(native_contour, epsilon, True)) for epsilon in (.5, 1.)}
    hull = cv2.convexHull(native_contour)
    hull_area = abs(float(cv2.contourArea(hull)))
    return dict(vertices=len(p), signed_area_native_pixels=area,
        image_coordinate_winding='clockwise' if area > 0 else 'counterclockwise',
        shortest_edge_native_pixels=float(lengths.min()), near_collinear_vertices_5deg=int(np.sum(np.abs(turn) < 5)),
        concave_turns_10deg=reflex, simplified_vertex_counts_diagnostic_only=reduced,
        area_over_original_bbox=abs(area)/(box['width']*box['height']),
        solidity=abs(area)/hull_area if hull_area else None,
        first_vertex_normalized=q[0].tolist(),
        bbox_aspect=box['width']/box['height'])


def robust_upper(values, floor=.15):
    values = np.asarray(values, float)
    median = float(np.median(values)); mad = float(np.median(np.abs(values-median)))
    # A minimum absolute excess avoids declaring pixel noise an outlier in a
    # near-duplicate component with zero MAD. Still only a diagnostic threshold.
    return median + max(floor, 3.5*1.4826*mad)


def medoid_index(distance, weights=None):
    d = np.asarray(distance, float)
    weights = np.ones(len(d), float) if weights is None else np.asarray(weights, float)
    return int(np.argmin(d@weights/max(float(weights.sum()), 1e-12)))


def feature_diagnostics(features, classes, groups, strata):
    """Use only cached image descriptors; all group labels are audit metadata."""
    x = np.asarray(features, float); classes = np.asarray(classes)
    if x.ndim != 2 or len(x) != len(classes) or not np.isfinite(x).all():
        raise ValueError('Finite aligned image descriptor matrix required')
    result = [{} for _ in range(len(x))]; representatives = {}; class_medoids = {}
    for cls in sorted(set(classes)):
        indices = np.flatnonzero(classes == cls)
        local = x[indices]
        d = np.linalg.norm(local[:, None, :]-local[None, :, :], axis=2)
        group_counts = Counter(groups[i] for i in indices)
        image_medoid = medoid_index(d)
        balanced_medoid = medoid_index(d, [1/group_counts[groups[i]] for i in indices])
        reference = int(indices[image_medoid]); class_medoids[int(cls)] = reference
        distances = d[:, image_medoid]
        threshold = robust_upper(distances, .20)
        refs = []; used_groups = set()
        for local_i in np.argsort(distances, kind='stable'):
            i = int(indices[local_i])
            if not refs or groups[i] not in used_groups:
                refs.append(i); used_groups.add(groups[i])
            if len(refs) >= 3:
                break
        representatives[int(cls)] = dict(image_weighted_medoid=reference,
            group_balanced_medoid=int(indices[balanced_medoid]), representative_indices=refs,
            groups=len(group_counts), dominant_group_fraction=max(group_counts.values())/len(indices),
            cached_descriptor_outlier_threshold=threshold)
        for local_i, raw_i in enumerate(indices):
            i = int(raw_i)
            same = [int(j) for j in indices if strata[j] == strata[i]]
            local_threshold, local_distance, local_outlier = None, None, None
            if len(same) >= 8:
                sx = x[same]; sd = np.linalg.norm(sx[:, None, :]-sx[None, :, :], axis=2)
                sm = medoid_index(sd); values = sd[:, sm]
                local_threshold = robust_upper(values, .20); local_distance = float(values[same.index(i)])
                local_outlier = local_distance > local_threshold
            cross = [j for j in indices if groups[j] != groups[i]]
            nearest_other_group = min(cross, key=lambda j: (float(np.linalg.norm(x[i]-x[j])), int(j))) if cross else None
            result[i] = dict(within_class_distance_to_medoid=float(distances[local_i]),
                within_class_outlier=bool(distances[local_i] > threshold),
                within_same_policy_surface_size_count=len(same), within_stratum_distance=local_distance,
                within_stratum_threshold=local_threshold, within_stratum_outlier=local_outlier,
                nearest_same_class_different_group=int(nearest_other_group) if nearest_other_group is not None else None,
                nearest_same_class_different_group_distance=float(np.linalg.norm(x[i]-x[nearest_other_group])) if nearest_other_group is not None else None,
                diagnostic_view_or_sensor_confound=bool(distances[local_i] > threshold and local_outlier is False))
    for i in range(len(x)):
        cls = int(classes[i]); own = class_medoids[cls]
        alternatives = [(float(np.linalg.norm(x[i]-x[j])), other, j) for other, j in class_medoids.items() if other != cls]
        if not alternatives:
            result[i].update(alternative_medoid_class=None, alternative_medoid_index=None, alternative_relative_advantage=None,
                alternative_medoid_candidate=False)
            continue
        distance, other, j = min(alternatives)
        own_distance = float(np.linalg.norm(x[i]-x[own]))
        advantage = (own_distance-distance)/own_distance if own_distance > 1e-9 else None
        result[i].update(alternative_medoid_class=other, alternative_medoid_index=j,
            alternative_medoid_distance=distance, alternative_relative_advantage=advantage,
            alternative_medoid_candidate=bool(advantage is not None and advantage >= .15 and own_distance >= .30))
    return result, representatives
