"""User-authorized modal class counts and model-boundary corner conversion.

Counts are an annotation convention, not an inferred semantic ontology. No human
target polygon, pose, IDs, groups, template coordinates or GT enters the fitter.
"""
from collections import Counter,defaultdict

import cv2
import numpy as np
from scipy.ndimage import binary_erosion,distance_transform_edt

from .pose_review_geometry import polygon_value,raster_mask

VERSION='class_modal_count_model_boundary_corners_native_frame_v2'
SETTINGS=dict(minimum_model_iou=.90,maximum_hd95_floor_pixels=2.,maximum_hd95_box_height_fraction=.10,
    minimum_corner_turn_degrees=18.,minimum_edge_length_pixels=1.5,minimum_corner_deviation_pixels=.55,
    minimum_convex_mask_fraction_for_four_points=.94,maximum_line_intersection_move_pixels=2.5,
    maximum_candidate_approximation_box_height_fraction=.16)


def modal_counts(records):
    by_class=defaultdict(Counter);seen=set()
    for r in records:
        if r['target_key'] in seen:raise ValueError('Each saved human image counts once, never once per event')
        seen.add(r['target_key']);cls=r['class_id'];p=r['polygon']
        if type(cls) is not int or cls not in range(1,23) or not 3<=len(p)<=128:raise ValueError('Invalid human reference')
        by_class[cls][len(p)]+=1
    if set(by_class)!=set(range(1,23)):raise ValueError('All22 classes required')
    result={}
    for cls,counts in sorted(by_class.items()):
        maximum=max(counts.values());modes=sorted(k for k,v in counts.items() if v==maximum)
        if len(modes)!=1:raise ValueError(f'Class{cls} tied modes {modes}: do not silently break a tie')
        total=sum(counts.values());k=modes[0]
        result[str(cls)]=dict(standard_count=k,distribution={str(n):v for n,v in sorted(counts.items())},
            modal_support=maximum,total_saved=total,modal_fraction=maximum/total,
            strict_majority=maximum>total/2,tied=False,user_authorized_modal_convention=True,
            semantic_slot_mapping_confirmed=False,minority_original_polygons_modified=False)
    return result


def clockwise_top_left(points):
    """Image-coordinate clockwise, topmost of the near-left endpoint pair first."""
    p=np.asarray(points,np.float64)
    if cv2.contourArea(p.astype(np.float32),oriented=True)<0:p=p[::-1]
    # Start is geometric only, never falsely named a known physical corner.
    width=max(float(np.ptp(p[:,0])),1.)
    left=np.flatnonzero(p[:,0]<=p[:,0].min()+.05*width)
    start=min(left,key=lambda i:(p[i,1],p[i,0]))
    return np.roll(p,-int(start),axis=0)


def corner_geometry(points):
    p=np.asarray(points,float);before=p-np.roll(p,1,axis=0);after=np.roll(p,-1,axis=0)-p
    lengths=np.linalg.norm(after,axis=1);turn=np.degrees(np.arctan2(np.cross(before,after),(before*after).sum(axis=1)))
    chord=np.roll(p,-1,axis=0)-np.roll(p,1,axis=0)
    deviation=np.abs(np.cross(chord,p-np.roll(p,1,axis=0)))/np.maximum(np.linalg.norm(chord,axis=1),1e-12)
    return dict(minimum_edge_length=float(lengths.min()),minimum_abs_turn_degrees=float(np.abs(turn).min()),
        minimum_corner_deviation=float(deviation.min()),concave_corners=int((turn<-18).sum()),
        edge_lengths=lengths.tolist(),signed_turn_degrees=turn.tolist())


def mask_fidelity(polygon,mask,origin=None,native_size=None):
    if origin is None:rendered=raster_mask(polygon,mask.shape[1],mask.shape[0])
    else:
        x,y=origin
        rendered=raster_mask(polygon,*native_size)[y:y+mask.shape[0],x:x+mask.shape[1]]
    union=int((rendered|mask).sum())
    if not rendered.any() or not mask.any():return dict(iou=0.,hd95=None)
    a=mask^binary_erosion(mask);b=rendered^binary_erosion(rendered)
    distances=np.r_[distance_transform_edt(~a)[b],distance_transform_edt(~b)[a]]
    return dict(iou=float((rendered&mask).sum()/max(1,union)),hd95=float(np.quantile(distances,.95)))


def reduced_corners(points,count):
    """Remove least boundary-supported detail; never insert/resample fake points."""
    p=np.asarray(points,np.float64).copy()
    while len(p)>count:
        a=np.roll(p,1,axis=0);b=np.roll(p,-1,axis=0);chord=b-a
        deviation=np.abs(np.cross(chord,p-a))/np.maximum(np.linalg.norm(chord,axis=1),1e-12)
        # Effective triangle area discourages long-edge detail from disappearing.
        effective=deviation*np.minimum(np.linalg.norm(p-a,axis=1),np.linalg.norm(b-p,axis=1))
        p=np.delete(p,int(np.argmin(effective)),axis=0)
    return p


def fitted_intersections(points,dense):
    """Refit each retained boundary arc and intersect adjacent supported lines."""
    p=np.asarray(points,float);d=np.asarray(dense,float)
    indices=[int(np.argmin(np.linalg.norm(d-v,axis=1))) for v in p];lines=[]
    for i,a in enumerate(indices):
        b=indices[(i+1)%len(indices)]
        arc=d[a:b+1] if b>a else np.r_[d[a:],d[:b+1]]
        if len(arc)<2:return None
        line=cv2.fitLine(arc.astype(np.float32),cv2.DIST_HUBER,0,.001,.001).ravel()
        lines.append((line[2:].astype(float),line[:2].astype(float)))
    result=[]
    for i,point in enumerate(p):
        a,v=lines[i-1];b,w=lines[i];matrix=np.column_stack((v,-w))
        if abs(np.linalg.det(matrix))<.2:return None
        intersection=a+np.linalg.solve(matrix,b-a)[0]*v
        if np.linalg.norm(intersection-point)>SETTINGS['maximum_line_intersection_move_pixels']:return None
        result.append(intersection)
    return np.asarray(result)


def convert(mask,dense_polygon,count,bbox_height,origin=None,native_size=None):
    """One requested K; withhold if model geometry cannot support distinct corners."""
    mask=np.asarray(mask,bool);dense=clockwise_top_left(dense_polygon)
    if type(count) is not int or not 3<=count<=128:raise ValueError('Explicit authorized class count required')
    if not mask.any():return None,dict(reason='empty_model_mask')
    contours,hierarchy=cv2.findContours(mask.astype(np.uint8),cv2.RETR_CCOMP,cv2.CHAIN_APPROX_SIMPLE)
    if cv2.connectedComponents(mask.astype(np.uint8),8)[0]!=2:return None,dict(reason='disconnected_model_mask')
    if hierarchy is None or (hierarchy[0,:,3]>=0).any():return None,dict(reason='closed_hole_cannot_be_encoded_by_single_ring')
    if len(dense)<count:return None,dict(reason='model_boundary_has_fewer_supported_vertices_than_class_K')
    if count==4:
        hull=cv2.convexHull(np.argwhere(mask)[:,::-1].astype(np.float32))
        hull_area=float(cv2.contourArea(hull))+1
        solidity=min(1.,int(mask.sum())/max(1,hull_area))
        if solidity<SETTINGS['minimum_convex_mask_fraction_for_four_points']:
            return None,dict(reason='class_four_points_would_erase_model_openings',model_solidity=solidity)
    candidates=[];seen=set();upper=max(2.,bbox_height*SETTINGS['maximum_candidate_approximation_box_height_fraction'])
    for epsilon in np.linspace(.25,upper,96):
        p=cv2.approxPolyDP(dense.astype(np.float32),float(epsilon),True).reshape(-1,2).astype(float)
        if len(p)==count:
            token=p.tobytes()
            if token not in seen:candidates.append(p);seen.add(token)
    # A direct K reduction is only a candidate: distinct-corner, native-fidelity
    # and no-collinear guards below must pass; K alone never certifies geometry.
    candidates.append(reduced_corners(dense,count))
    evaluated=[];rejections=Counter()
    for candidate in candidates:
        for method,p in [('retained_model_corners',candidate),('model_arc_line_intersections',fitted_intersections(candidate,dense))]:
            if p is None:continue
            p=clockwise_top_left(p)
            try:polygon_value(p.tolist(),mask.shape[1],mask.shape[0])
            except ValueError:rejections['invalid_or_outside_native_polygon']+=1;continue
            g=corner_geometry(p)
            if (g['minimum_edge_length']<SETTINGS['minimum_edge_length_pixels'] or
                    g['minimum_abs_turn_degrees']<SETTINGS['minimum_corner_turn_degrees'] or
                    g['minimum_corner_deviation']<SETTINGS['minimum_corner_deviation_pixels']):
                rejections['unsupported_short_or_nearly_collinear_corner']+=1;continue
            # Validate exactly the serialized native-image coordinates. Moving
            # an ROI float back and forth can flip a pixel on a slanted edge;
            # local diagnostic masks must not stand in for exported full masks.
            final=np.round(p+(np.asarray(origin) if origin is not None else 0),6)
            try:polygon_value(final.tolist(),*(native_size if origin is not None else (mask.shape[1],mask.shape[0])))
            except ValueError:rejections['invalid_final_native_coordinates']+=1;continue
            fidelity=mask_fidelity(final.tolist(),mask,origin,native_size);hd_limit=max(SETTINGS['maximum_hd95_floor_pixels'],SETTINGS['maximum_hd95_box_height_fraction']*bbox_height)
            if fidelity['iou']<SETTINGS['minimum_model_iou'] or fidelity['hd95']>hd_limit:
                rejections['class_K_would_change_model_geometry_too_much']+=1;continue
            evaluated.append((fidelity['iou'],-fidelity['hd95'],method,final,corner_geometry(final),fidelity))
    if not evaluated:return None,dict(reason='no_supported_exact_K_polygon',candidate_rejections=dict(rejections),requested_count=count)
    best=max(evaluated,key=lambda v:(v[0],v[1]));_,_,method,p,g,fidelity=best
    return p.tolist(),dict(reason=None,requested_count=count,actual_count=len(p),algorithm=VERSION,method=method,
        model_mask_fidelity_not_human_accuracy=fidelity,corner_support=g,
        inserted_or_collinear_padding_points=0,clockwise=True,start_rule='upper_of_near_left_endpoint_pair',
        fidelity_raster_frame='serialized_final_full_native_image' if origin is not None else 'native_mask_frame',coordinate_decimal_places=6,
        semantic_corner_correspondence_confirmed=False,quality_certified=False)
