"""New offline reference/line fitting algorithm; never modifies frozen transfer gates.

Target annotations, pose, rulers, IDs and collection groups are not accepted by
the numerical fitter. The evaluation harness enforces source eligibility first.
"""
from dataclasses import asdict,dataclass

import cv2
import numpy as np

from .mask_template_transfer import PATCH_SIZE,correlate,patch_matrix,transform
from .pose_review_geometry import polygon_value


@dataclass(frozen=True)
class Settings:
    initial_ncc_min:float=.55
    ecc_min:float=.84
    boundary_ncc_min:float=.78
    normal_search_native_pixels:float=4.
    max_line_angle_degrees:float=5.
    support_fraction_min:float=.65
    contrast_min:float=18.
    fit_residual_p90_max:float=.8
    consensus_native_pixels_max:float=1.5
    minimum_independent_references:int=2
    maximum_references:int=3


VERSION='native_edge_line_reference_consensus_research_v1'
SETTINGS=Settings()


def patch(image,box):
    row=dict(bbox=box);matrix=patch_matrix(row);matrix[:,2]+=matrix[:,:2]@np.array([.5,.5])
    value=cv2.warpAffine(image,matrix,PATCH_SIZE,flags=cv2.INTER_LINEAR,borderMode=cv2.BORDER_REFLECT_101)
    lo,hi=np.percentile(value,[1,99]);value=np.clip((value.astype(float)-lo)*255/max(hi-lo,1),0,255).astype(np.uint8)
    return cv2.GaussianBlur(value,(3,3),.65)


def sample(image,points):
    points=np.asarray(points,np.float32)
    return cv2.remap(image.astype(np.float32),points[...,0]-.5,points[...,1]-.5,cv2.INTER_LINEAR,borderMode=cv2.BORDER_REPLICATE)


def shape_family(polygon,box):
    """Reference-only topology and face-width signature, never target-label features."""
    p=np.asarray(polygon,float);edges=np.roll(p,-1,axis=0)-p
    area=cv2.contourArea(p.astype(np.float32),oriented=True)
    turns=np.cross(edges,np.roll(edges,-1,axis=0))*np.sign(area)
    concave=int((turns<-.1).sum())
    ratio=box['width']/max(box['height'],1)
    # This coarse key cannot prove physical surface identity. It only rejects
    # obvious disagreements; unknown/ambiguous surfaces are rejected upstream.
    return (len(p),concave,'narrow' if ratio<2.5 else 'wide')


def coarse_alignment(source,target,source_box,target_box,polygon,settings=SETTINGS):
    a,b=patch(source,source_box),patch(target,target_box);initial=correlate(a,b)
    info=dict(initial_ncc=initial)
    if initial<settings.initial_ncc_min:return None,dict(info,rejection='initial_similarity_below_original_gate')
    matrix=np.eye(2,3,dtype=np.float32)
    try:
        ecc,matrix=cv2.findTransformECC(a,b,matrix,cv2.MOTION_AFFINE,
            (cv2.TERM_CRITERIA_EPS|cv2.TERM_CRITERIA_COUNT,100,1e-5),None,5)
    except cv2.error:return None,dict(info,rejection='affine_registration_failed')
    singular=np.linalg.svd(matrix[:,:2],compute_uv=False)
    if np.linalg.det(matrix[:,:2])<=0 or singular.min()<.7 or singular.max()>1.4 or np.max(abs(matrix[:,2]))>28:
        return None,dict(info,rejection='excessive_affine_deformation')
    p=transform(polygon,patch_matrix(dict(bbox=source_box)))
    aligned=cv2.warpAffine(b,matrix,PATCH_SIZE,flags=cv2.INTER_LINEAR|cv2.WARP_INVERSE_MAP)
    band=np.zeros(a.shape,np.uint8);cv2.polylines(band,[np.round(p).astype(np.int32)],True,255,7)
    boundary=correlate(a[band>0],aligned[band>0]);info.update(ecc=float(ecc),boundary_ncc=boundary,affine_patch_transform=matrix.tolist())
    if ecc<settings.ecc_min or boundary<settings.boundary_ncc_min:return None,dict(info,rejection='photometric_gates_not_met')
    candidate=transform(transform(p,matrix),cv2.invertAffineTransform(patch_matrix(dict(bbox=target_box))))
    return candidate,dict(info,rejection=None)


def fit_edge(image,a,b,source_image,source_a,source_b,settings=SETTINGS):
    """Fit one supported signed intensity transition near an affine edge."""
    a,b,sa,sb=map(lambda x:np.asarray(x,float),(a,b,source_a,source_b))
    vector=b-a;length=float(np.linalg.norm(vector))
    if length<3:return None,dict(rejection='edge_too_short_for_independent_support')
    tangent=vector/length;normal=np.array([-tangent[1],tangent[0]])
    sv=sb-sa;sl=np.linalg.norm(sv)
    if sl<3:return None,dict(rejection='source_edge_too_short')
    sn=np.array([-sv[1],sv[0]])/sl
    fractions=np.linspace(.15,.85,max(12,min(96,int(length))))
    origin=a+fractions[:,None]*vector;so=sa+fractions[:,None]*sv
    # Per-edge source polarity protects aperture edges from reversed material /
    # background transitions. Weak source evidence is an abstention, not a guess.
    source_delta=sample(source_image,(so+sn).reshape(1,-1,2)).ravel()-sample(source_image,(so-sn).reshape(1,-1,2)).ravel()
    polarity=float(np.sign(np.median(source_delta)))
    if polarity==0 or np.median(abs(source_delta))<settings.contrast_min/2:return None,dict(rejection='weak_source_boundary_polarity')
    offsets=np.arange(-settings.normal_search_native_pixels,settings.normal_search_native_pixels+.01,.25)
    coords=origin[:,None,:]+offsets[None,:,None]*normal
    if (coords[...,0].min()<1 or coords[...,1].min()<1 or coords[...,0].max()>image.shape[1]-1 or coords[...,1].max()>image.shape[0]-1):
        return None,dict(rejection='boundary_search_touches_image_edge')
    positive=sample(image,coords+normal);negative=sample(image,coords-normal)
    contrast=(positive-negative)*polarity
    score=contrast-.75*abs(offsets)[None,:];indices=np.argmax(score,axis=1)
    strength=contrast[np.arange(len(indices)),indices];selected=offsets[indices]
    keep=(strength>=settings.contrast_min)&(abs(selected)<settings.normal_search_native_pixels-.25)
    support=float(keep.mean())
    if support<settings.support_fraction_min:return None,dict(rejection='insufficient_boundary_support',support_fraction=support)
    points=origin[keep]+selected[keep,None]*normal
    line=cv2.fitLine(points.astype(np.float32),cv2.DIST_HUBER,0,.001,.001).ravel();direction=line[:2].astype(float);center=line[2:].astype(float)
    if np.dot(direction,tangent)<0:direction=-direction
    angle=float(np.degrees(np.arccos(np.clip(np.dot(direction,tangent),-1,1))))
    residual=abs(np.cross(direction,points-center));p90=float(np.quantile(residual,.9))
    if angle>settings.max_line_angle_degrees or p90>settings.fit_residual_p90_max:
        return None,dict(rejection='ambiguous_or_nonstraight_boundary',angle_degrees=angle,residual_p90=p90,support_fraction=support)
    return (center,direction),dict(rejection=None,support_fraction=support,angle_degrees=angle,residual_p90=p90,
        median_contrast=float(np.median(strength[keep])),normal_offset_median=float(np.median(selected[keep])),support_points=points.tolist())


def intersect_lines(left,right,fallback):
    a,v=left;b,w=right;matrix=np.column_stack((v,-w))
    if abs(np.linalg.det(matrix))<.08:return None
    return a+np.linalg.solve(matrix,b-a)[0]*v


def refine_polygon(source,target,polygon,initial,target_box,settings=SETTINGS):
    p=np.asarray(polygon,float);q=np.asarray(initial,float);lines=[];diagnostics=[]
    for i in range(len(p)):
        line,record=fit_edge(target,q[i],q[(i+1)%len(q)],source,p[i],p[(i+1)%len(p)],settings)
        diagnostics.append(record)
        if line is None:return None,dict(rejection='native_edge_support_failed',failed_edge=i,edges=diagnostics)
        lines.append(line)
    result=[]
    for i in range(len(lines)):
        point=intersect_lines(lines[i-1],lines[i],q[i])
        if point is None:return None,dict(rejection='adjacent_edges_not_distinct',edges=diagnostics)
        result.append(point)
    result=np.asarray(result)
    if np.linalg.norm(result-q,axis=1).max()>max(3.,target_box['height']*.16):return None,dict(rejection='excessive_vertex_refinement',edges=diagnostics)
    try:result=polygon_value(result.tolist(),target.shape[1],target.shape[0])
    except ValueError:return None,dict(rejection='invalid_fitted_polygon',edges=diagnostics)
    ratio=abs(cv2.contourArea(np.asarray(result,np.float32)))/max(abs(cv2.contourArea(q.astype(np.float32))),1)
    if not .72<ratio<1.35:return None,dict(rejection='unstable_polygon_area',edges=diagnostics)
    return result,dict(rejection=None,edges=diagnostics,refinement_area_ratio=ratio,vertex_count_inherited=True,vertex_order_inherited=True)


def consensus(candidates,settings=SETTINGS):
    """No best-of-GT selection, vertex averaging, or unsupported single-source pass."""
    if len(candidates)<settings.minimum_independent_references:return None,dict(rejection='insufficient_independent_supported_references')
    for candidate in candidates:
        support=[other for other in candidates if other is not candidate and other['independent_component']!=candidate['independent_component'] and
            other['family']==candidate['family'] and np.max(np.linalg.norm(np.asarray(other['polygon'])-candidate['polygon'],axis=1))<=settings.consensus_native_pixels_max]
        if len(support)>=settings.minimum_independent_references-1:
            return candidate,dict(rejection=None,support_reference_keys=[c['reference_key'] for c in support],agreement_limit_native_pixels=settings.consensus_native_pixels_max)
    return None,dict(rejection='multi_reference_geometry_disagreement')
