"""Measure a future unedited native Photopea export against the pre-frozen contract.

Prepared only: do not run until Root has authorization for the native Photopea pilot.
No service, native product, image modification, inference, or external request occurs here.
"""
import argparse
import hashlib
import json
from pathlib import Path
from PIL import Image

root = Path(__file__).resolve().parent
def sha(path):
    with Path(path).open('rb') as handle:
        return hashlib.file_digest(handle, 'sha256').hexdigest()
def fraction(numerator, denominator):
    return None if not denominator else numerator / denominator
def binary(path):
    with Image.open(path) as image:
        assert image.mode == 'L' and image.size == (512, 512)
        values = image.tobytes()
        assert set(values).issubset({0, 255})
        return values

parser = argparse.ArgumentParser()
parser.add_argument('case', choices=('photopea-primary', 'photopea-boundary'))
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--contract-sha256', required=True)
parser.add_argument('--save-report', type=Path, required=True)
args = parser.parse_args()
contract_path = root / 'frozen-photopea-contract-v2.json'
assert sha(contract_path) == args.contract_sha256, 'The complete original frozen contract must match.'
contract = json.loads(contract_path.read_bytes())
assert sha(__file__) == contract['measurementScript']['sha256'], 'Measurement code changed after freeze.'
case = next(c for c in contract['cases'] if c['id'] == args.case)
native_output = args.output.resolve()
required_output = (root / case['nativeExport']['retainedPath']).resolve()
assert native_output == required_output, 'Retain the first unedited Photopea export at the fixed result path.'
assert native_output.is_file(), 'No native export exists. Missing output is not an invented image or score.'
assert not args.save_report.exists(), 'Preserve an existing measurement instead of silently re-scoring.'
for row in contract['assets']:
    assert sha(root / row['candidatePath']) == row['sha256'], 'A frozen original fixture/reference changed.'
with Image.open(root / case['inputPath']) as image:
    assert image.mode == 'RGB' and image.size == (512, 512)
    source_rgb = image.tobytes()
result = {
    'caseId': args.case, 'contractSha256': args.contract_sha256,
    'outputPath': str(native_output), 'outputBytes': native_output.stat().st_size,
    'outputSha256': sha(native_output), 'sourceInputSha256': sha(root / case['inputPath']),
    'scope': 'Finite fixed-image metrics only. Native UI provenance and authorization must be verified separately.',
    'nativeProvenanceCondition': 'unverified_by_pixel_script',
}
try:
    with Image.open(native_output) as exported:
        exported.load()
        result.update(format=exported.format, storedMode=exported.mode, width=exported.width, height=exported.height,
                      storedAlphaPresent=('A' in exported.getbands() or 'transparency' in exported.info))
        rgba = exported.convert('RGBA').tobytes()
except Exception as error:
    result.update(decodeError=type(error).__name__, pixelMetrics=None,
                  measurementStatus='native_file_not_decodable_no_pixel_score')
else:
    valid = result['format'] == 'PNG' and (result['width'], result['height']) == (512, 512) and result['storedAlphaPresent']
    result['formatAndDimensionsValid'] = valid
    if not valid:
        result.update(pixelMetrics=None, measurementStatus='invalid_native_format_no_resample_or_pixel_score')
    else:
        limits = contract['metricDefinitions']
        alpha = rgba[3::4]
        result.update(minimumAlpha=min(alpha), maximumAlpha=max(alpha))
        reference = binary(root / case['references']['full'])
        foreground = limits['foregroundThreshold']
        intersection = sum(1 for i, truth in enumerate(reference) if truth == 255 and alpha[i] >= foreground)
        union = sum(1 for i, truth in enumerate(reference) if truth == 255 or alpha[i] >= foreground)
        iou = fraction(intersection, union)
        result.update(foregroundIntersectionPixels=intersection, foregroundUnionPixels=union, silhouetteIoU=iou)
        regions = []
        groups = []
        for region in case['regionChecks']:
            mask = binary(root / region['maskPath'])
            indices = [i for i, value in enumerate(mask) if value == 255]
            count = len(indices)
            passing = sum(1 for i in indices if (alpha[i] >= region['alphaThreshold'] if region['kind'] == 'foreground' else alpha[i] <= region['alphaThreshold']))
            regions.append(dict(regionId=region['id'], pixels=count, meetingAlphaPixels=passing,
                                alphaFraction=fraction(passing, count), requiredFraction=region['minimumFraction']))
            if region['kind'] == 'foreground':
                for palette_group in region['sourceColorGroups']:
                    rgb = tuple(palette_group['rgb'])
                    group = [i for i in indices if tuple(source_rgb[3*i:3*i+3]) == rgb]
                    assert len(group) == palette_group['pixelCount'] and group, 'Frozen source color-group denominator changed.'
                    opaque = [i for i in group if alpha[i] >= limits['foregroundCoreThreshold']]
                    color_matching = sum(1 for i in opaque if max(abs(rgba[4*i+c] - source_rgb[3*i+c]) for c in range(3)) <= limits['visibleRgbMaxChannelDelta'])
                    groups.append(dict(regionId=region['id'], sourceRgb=list(rgb), sourcePixels=len(group),
                                       opaqueRetainedPixels=len(opaque), opaqueRetentionFraction=fraction(len(opaque), len(group)),
                                       requiredOpaqueFraction=region['minimumFraction'],
                                       rgbMatchingOpaquePixels=color_matching, rgbMatchingOpaqueFraction=fraction(color_matching, len(opaque)),
                                       requiredRgbFraction=limits['visibleRgbMinimumMatchingFraction']))
        result.update(regionMetrics=regions, sourceColorGroupMetrics=groups,
                      measurementStatus='pixel_measurements_completed_native_provenance_still_separate',
                      pixelsOutsideVisibleReferenceCoresRgbScored=False,
                      limitation='No whole-image hidden-RGB condition and no native UI/account/privacy/build claim is inferred from exported pixels.')
args.save_report.parent.mkdir(parents=True, exist_ok=True)
args.save_report.write_text(json.dumps(result, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
print(json.dumps({'caseId': args.case, 'measurementStatus': result['measurementStatus'], 'report': str(args.save_report), 'sha256': sha(args.save_report)}))
