import hashlib
import json
import os
from pathlib import Path
import time

from inspect_intake import ROOT, WEIGHT, REV, MODEL, gate, state, write

os.umask(0o077)
env_root = Path('/data/contextra/model-artifacts/tool-envs/medium-193-20260909/venv/lib/python3.12/site-packages')
local_files = [env_root / 'rfdetr' / p for p in ('config.py', 'detr.py', 'models/weights.py', 'export/main.py')]
package_metadata = env_root / 'rfdetr-1.9.3.dist-info/METADATA'
assert 'Version: 1.9.3\n' in package_metadata.read_text()
sources = json.loads((ROOT / 'remote-sources.json').read_text())
training = json.loads((ROOT / 'training_config.json').read_text())
static = json.loads((ROOT / 'checkpoint-static.json').read_text())
assert static['observed_classes'] == training['class_names'] == ['smoke_visible', 'flame_visible']
assert 'publication template' in (ROOT / 'RIGHTS_AND_ATTRIBUTION.md').read_text()
manifest = {
    'schema_version': 1, 'kind': 'input', 'asset_key': 'fire-smoke-medium-v110-strict-v1',
    'model_class': 'RFDETRMedium',
    'artifact': dict(filename=WEIGHT.name, size_bytes=WEIGHT.stat().st_size,
                     sha256=gate.sha(WEIGHT), md5=hashlib.md5(WEIGHT.read_bytes(), usedforsecurity=False).hexdigest()),
    'source': dict(url='https://huggingface.co/' + MODEL + '/resolve/' + REV + '/' + WEIGHT.name,
                   repository_revision=REV, rfdetr_version='1.10.0', documents=sources),
    'verification': dict(file_identity='PASS_REMOTE_LFS', checkpoint_static='PASS_NON_EXECUTING_METADATA_ONLY',
                         weight_load='NOT_RUN_RIGHTS_HOLD', export='NOT_RUN_RIGHTS_HOLD',
                         fp16_plan='NOT_RUN', runtime='NOT_RUN', quality='WAIT_USER_VIDEO',
                         source_connection='NOT_IMPLEMENTED_RIGHTS_AND_EXPORT_CONTRACT_WAIT',
                         tooling_registration='NOT_REGISTERED_CANDIDATE_ONLY'),
    'contract': dict(authority='PINNED_PUBLISHER_CONFIG_AND_STATIC_PICKLE_METADATA_NOT_LOADED_MODEL',
                     class_mapping={0: 'smoke_visible', 1: 'flame_visible'},
                     resolution=[576, 576], patch_size=16, num_queries_reference=300, num_select_reference=300,
                     outputs_expected=None, output_verification='WAIT_ACTUAL_EXPORT',
                     preprocessing=dict(color='RGB_PUBLISHER_WRAPPER', layout='NCHW_REFERENCE_ONLY',
                                        normalization='WAIT_LOADED_MODEL_AND_EXPORT', resize='576_REFERENCE_ONLY'),
                     nms='NO_ADDITIONAL_NMS_AUTHORIZED; verify model postprocess before implementation',
                     local_exporter=dict(version='1.9.3', public_loader_present=True,
                                         compatibility='STATIC_PARTIAL_NOT_MODEL_LOAD_PASS',
                                         source_hashes={str(p.relative_to(env_root)): gate.sha(p) for p in local_files}),
                     rights=dict(status='HOLD_UNCLEAR_RESEARCH_AND_COMMERCIAL_PERMISSION',
                                 reason='Publisher rights file remains an incomplete publication template; model card license is other/composite-research-release.',
                                 resume='Obtain completed terms or publisher clarification covering internal model execution/export and intended deployment.')),
}
target = WEIGHT.parent / 'manifest.candidate.yaml'
if target.exists():
    assert gate.yaml.safe_load(target.read_text()) == manifest
else:
    with target.open('x') as stream:
        gate.yaml.safe_dump(manifest, stream, allow_unicode=True, sort_keys=False)
loaded = gate.yaml.safe_load(target.read_text())
assert loaded == manifest
schema = json.loads((gate.REPO / 'model_tooling/input_manifest.schema.json').read_text())
assert manifest['asset_key'] not in schema['properties']['asset_key']['enum']
assert manifest['artifact']['sha256'] == static['sha256']
before = json.loads((ROOT / 'state.before.private.json').read_text())
after = state()
assert sorted(before['mounts'], key=lambda m: m['Destination']) == sorted(after['mounts'], key=lambda m: m['Destination'])
for key in ('container_id', 'image', 'restart', 'streams_stopped', 'hashes', 'others'):
    assert before[key] == after[key], key
write('state.after.private.json', after)
write('summary.json', dict(file_identity='PASS', static_checkpoint='PASS_METADATA_ONLY',
       rights='HOLD_INCOMPLETE_PUBLISHER_TERMS', compatibility='STATIC_PARTIAL',
       manifest=str(target), manifest_sha256=gate.sha(target), existing_tool_registration=False,
       metadata_validation='PASS_CANDIDATE_ROUNDTRIP_AND_REMOTE_IDENTITY_NOT_TOOLING_SCHEMA_PASS',
       service_unchanged=True, analytics='healthy', stream='stopped', model_load=0,
       onnx_export=0, plan_build=0, image_build=0, runtime_start=0, production_source_changes=0))
ledger = json.loads((ROOT / 'ledger.json').read_text())
ledger.update(phase='COMPLETE_WITH_FIRE_RIGHTS_HOLD', completed_utc=time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
              manifest=str(target), rights_hold=True, helper_notes=['python alias unavailable; used installed python3', 'Docker inspect mount order varies; sorted full records equal; no service mutation or model experiment failure'])
(ROOT / 'ledger.json').write_text(json.dumps(ledger, indent=2))
for path in ROOT.iterdir():
    if path.is_file():
        path.chmod(0o600)
print(json.dumps(json.loads((ROOT / 'summary.json').read_text()), indent=2))