"""Independent literal-coordinate audit. No project scorer/optimizer imports.

All geometric predicates use Python integers with a common power-of-ten scale.
Decimal is used solely to parse decimal literals, never rounded float input.
"""
import argparse
import hashlib
import json
from decimal import Decimal, localcontext
from fractions import Fraction
from pathlib import Path


def read_scaled(path):
    rows = []
    for line in Path(path).read_text().splitlines():
        if not line.strip() or line.lstrip().startswith('#'):
            continue
        row = [Decimal(t) for t in line.split()]
        if len(row) != 3 or not all(t.is_finite() for t in row):
            raise ValueError(f'Invalid row in {path}: {line}')
        rows.append(row)
    places = max(max(0, -x.as_tuple().exponent) for row in rows for x in row)
    scale = 10 ** places
    def integer(x):
        sign, digits, exponent = x.as_tuple()
        coefficient = int(''.join(map(str, digits)))
        return (-1 if sign else 1) * coefficient * 10 ** (exponent + places)
    return [[integer(x) for x in row] for row in rows], scale


def decimal_fraction(q):
    with localcontext() as ctx:
        ctx.prec = 100
        return format(Decimal(q.numerator) / Decimal(q.denominator), 'f')


def check_circles(path, n):
    rows, scale = read_scaled(path)
    walls = [(min(x-r, y-r, scale-x-r, scale-y-r), i+1)
             for i, (x,y,r) in enumerate(rows)]
    invalid_radii = [i+1 for i, (_,_,r) in enumerate(rows) if r <= 0]
    outside = [i for w,i in walls if w < 0]
    min_gap = None
    min_pair = None
    overlaps = []
    count = 0
    for i, (x,y,r) in enumerate(rows):
        for j in range(i):
            u,v,s = rows[j]
            gap = (x-u)**2 + (y-v)**2 - (r+s)**2
            count += 1
            if min_gap is None or gap < min_gap:
                min_gap, min_pair = gap, [j+1, i+1]
            if gap < 0:
                overlaps.append([j+1,i+1,str(gap)])
    total = sum(r for _,_,r in rows)
    w,i = min(walls)
    return dict(n=n, rows=len(rows), sha256=hashlib.sha256(Path(path).read_bytes()).hexdigest(),
                scale=str(scale), radius_sum_integer=str(total),
                exact_sum=decimal_fraction(Fraction(total, scale)),
                feasible=len(rows)==n and not (invalid_radii or outside or overlaps),
                invalid_radii=invalid_radii, outside=outside, overlaps=overlaps,
                pair_checks=count, min_wall_slack_integer=str(w), min_wall_circle=i,
                min_wall_slack=decimal_fraction(Fraction(w,scale)),
                min_pair_slack_integer=str(min_gap), min_pair=min_pair,
                min_pair_slack_squared=decimal_fraction(Fraction(min_gap,scale*scale)))


def check_ratio(path):
    rows, scale = read_scaled(path)
    distances = []
    for i,p in enumerate(rows):
        for j in range(i):
            d = sum((a-b)**2 for a,b in zip(p,rows[j]))
            distances.append((d, [j+1,i+1]))
    lo,hi = min(distances), max(distances)
    q = Fraction(hi[0],lo[0])
    return dict(n=len(rows), distinct=lo[0]>0,
                sha256=hashlib.sha256(Path(path).read_bytes()).hexdigest(),
                scale=str(scale), dmin_squared_integer=str(lo[0]), dmin_pair=lo[1],
                dmax_squared_integer=str(hi[0]), dmax_pair=hi[1],
                ratio_squared_numerator=str(q.numerator), ratio_squared_denominator=str(q.denominator),
                ratio_squared_decimal=decimal_fraction(q),
                improvement_over_printed_fico=decimal_fraction(Fraction('4.165783988278149')-q))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--claims', default='claims')
    ap.add_argument('--document', default='claims.md')
    ap.add_argument('--out', default='exact_results.json')
    args = ap.parse_args()
    folder = Path(args.claims)
    # Claims are data for comparison only, never verification code.
    manifest = {x['n']:x for x in json.loads((folder/'claims_csqv.json').read_text())}
    document = {}
    for line in Path(args.document).read_text().splitlines():
        cells = [x.strip() for x in line.split('|')]
        if len(cells)>5 and cells[1].isdigit():
            document[int(cells[1])] = dict(sha256=cells[3].strip('`'), value=cells[4])
    results=[]
    for path in sorted(folder.glob('csqv*.txt'), key=lambda p:int(p.stem[4:])):
        n=int(path.stem[4:])
        r=check_circles(path,n)
        r['manifest_exact_matches'] = Fraction(r['exact_sum']) == Fraction(manifest[n]['scorer_final_exact'])
        r['manifest_sha_matches'] = r['sha256'] == manifest[n]['sha256']
        r['document_sha_matches'] = r['sha256'] == document[n]['sha256']
        r['document_value'] = document[n]['value']
        r['document_value_difference'] = decimal_fraction(Fraction(r['exact_sum'])-Fraction(document[n]['value']))
        results.append(r)
    summary = dict(files=len(results), manifest_entries=len(manifest), document_entries=len(document),
                   pair_checks=sum(r['pair_checks'] for r in results),
                   infeasible=[r['n'] for r in results if not r['feasible']],
                   manifest_mismatches=[r['n'] for r in results if not r['manifest_exact_matches']],
                   sha_mismatches=[r['n'] for r in results if not (r['document_sha_matches'] and r['manifest_sha_matches'])],
                   document_literal_mismatches=[r['n'] for r in results if Fraction(r['document_value_difference']) != 0])
    ratio=check_ratio(folder/'minratio14_3d.txt')
    output=dict(summary=summary,circles=results,minratio=ratio)
    Path(args.out).write_text(json.dumps(output,indent=2)+'\n')
    print(json.dumps(summary,indent=2))
    print(json.dumps(ratio,indent=2))


if __name__ == '__main__':
    main()