"""Correct an unpublished YAML; preserve the passed semantic audit by byte identity."""
from datetime import datetime
import json
from pathlib import Path
import zipfile
from zoneinfo import ZoneInfo

from ultralytics.data.utils import check_det_dataset

from pallet.clean_intensity_review import reserve, safe_copy, safe_json
from pallet.data.protocol import file_digest, write_json
from pallet.formal_dataset import verify_archive, verify_frozen_payload, stamp


ROOT = Path(__file__).resolve().parents[1]
OUTPUT = ROOT/'outputs/pallet_dataset_formal_v1'
BUNDLE = OUTPUT/'dataset'


def read(path):
    return json.loads(Path(path).read_text())


def main():
    if (OUTPUT/'delivery_manifest.json').exists():
        raise ValueError('Repair applies only to the unpublished candidate')
    prior = OUTPUT/'pre_release_candidates/yaml_relative_path_dot'
    prior.mkdir(parents=True, exist_ok=True)
    if not (prior/'manifest.json').exists():
        for name in ('manifest.json', 'checksums.sha256', 'dataset.yaml', 'audit.json'):
            safe_copy(BUNDLE/name, prior/name)
        safe_copy(OUTPUT/'import_manifest.json', prior/'import_manifest.json')
        safe_copy(BUNDLE/'provenance/build_source/formal_dataset.py', prior/'formal_dataset.py')
    old = read(prior/'manifest.json'); imported = read(prior/'import_manifest.json')
    audit = read(prior/'audit.json')
    if audit['state'] != 'passed' or audit['frames'] != old['summary']['frames']:
        raise ValueError('Missing the completed all-frame semantic audit')
    builder = (ROOT/'pallet/formal_dataset.py').resolve()
    for path, digest in old['input_binding'].items():
        if path != str(builder) and file_digest(path) != digest:
            raise ValueError(f'Bound release input changed: {path}')
    allowed = {'dataset.yaml', 'provenance/build_source/formal_dataset.py',
               'provenance/build_source/test_formal_dataset.py',
               'provenance/build_source/verification_record.json', 'provenance/yaml_path_correction.json'}
    actual = {str(p.relative_to(BUNDLE)) for p in BUNDLE.rglob('*') if p.is_file()}-{'manifest.json', 'checksums.sha256'}
    if actual-allowed != set(old['files'])-allowed:
        raise ValueError('Unexpected change to previously audited file membership')
    stamp(OUTPUT, 'verifying_unchanged_human_and_sensor_payload')
    for ordinal, (name, digest) in enumerate(old['files'].items(), 1):
        if name not in allowed and file_digest(BUNDLE/name) != digest:
            raise ValueError(f'Preserving edited human/sensor payload: {name}')
        if ordinal % 8192 == 0:
            stamp(OUTPUT, 'verifying_unchanged_human_and_sensor_payload', files_done=ordinal, files_total=len(old['files']))
    archive = OUTPUT/'pallet_dataset_formal_v1.zip'
    if archive.exists() and not (prior/archive.name).exists():
        archive.rename(prior/archive.name)
    write_json(OUTPUT/'yaml_path_fix_record.json', {
        'issue': 'path: . resolves image directories against caller cwd rather than YAML directory',
        'old_yaml_sha256': file_digest(prior/'dataset.yaml'), 'old_manifest_sha256': file_digest(prior/'manifest.json'),
        'old_candidate_archive': str(prior/archive.name), 'unpublished_candidate_preserved': True,
        'human_annotations_images_sensor_files_unchanged': True, 'all_prior_payload_hashes_verified': True})
    (BUNDLE/'dataset.yaml').write_text('train: images/train\nval: images/val\ntest: images/test\nnames:\n  0: pallet\n')
    parsed = check_det_dataset(str(BUNDLE/'dataset.yaml'), autodownload=False)
    for split in ('train', 'val', 'test'):
        if Path(parsed[split]) != (BUNDLE/'images'/split).resolve():
            raise ValueError('YOLO YAML consumer still resolves the wrong directory')
    for source, target in [(builder, BUNDLE/'provenance/build_source/formal_dataset.py'),
            (ROOT/'tests/test_formal_dataset.py', BUNDLE/'provenance/build_source/test_formal_dataset.py')]:
        target.write_bytes(source.read_bytes())
    write_json(BUNDLE/'provenance/build_source/verification_record.json', {
        'initial_semantic_regression_passed': 31, 'post_consumer_adapter_and_yaml_fix_regression_passed': 38,
        'builder_sha256': file_digest(builder), 'data_semantic_audit': audit,
        'numpy_and_image_decoding_not_repeated_because_payload_hashes_are_identical': True})
    write_json(BUNDLE/'provenance/yaml_path_correction.json', {
        'issue': 'YOLO path: . used caller cwd', 'correction': 'omit path; resolve against YAML file parent',
        'consumer': 'ultralytics.data.utils.check_det_dataset', 'consumer_result': 'passed',
        'labels_images_float_data_unchanged': True, 'prior_full_semantic_audit_state': 'passed',
        'independent_blind_reference': False})
    imported['input_binding'][str(builder)] = file_digest(builder)
    write_json(OUTPUT/'import_manifest.json', imported)
    manifest = {**old, 'input_binding': imported['input_binding'],
        'files': {name: file_digest(BUNDLE/name) if name in allowed else old['files'][name]
                  for name in sorted(actual|{'provenance/yaml_path_correction.json'})}}
    write_json(BUNDLE/'manifest.json', manifest)
    checksums = {**manifest['files'], 'manifest.json': file_digest(BUNDLE/'manifest.json')}
    (BUNDLE/'checksums.sha256').write_text(''.join(f'{checksums[name]}  {name}\n' for name in sorted(checksums)))
    stamp(OUTPUT, 'repackaging_after_yaml_consumer_fix')
    if not archive.exists():
        temporary = archive.with_suffix('.zip.partial')
        with zipfile.ZipFile(temporary, 'w', compression=zipfile.ZIP_DEFLATED, compresslevel=1, allowZip64=True) as z:
            for ordinal, p in enumerate(sorted(BUNDLE.rglob('*')), 1):
                if not p.is_file():
                    continue
                reserve(); z.write(p, str(p.relative_to(BUNDLE)))
                if ordinal % 4096 == 0:
                    stamp(OUTPUT, 'repackaging_after_yaml_consumer_fix', paths_visited=ordinal, zip_bytes=temporary.stat().st_size)
        temporary.replace(archive)
    stamp(OUTPUT, 'auditing_corrected_archive')
    archive_audit = verify_archive(archive, BUNDLE)
    payload_audit = verify_frozen_payload(BUNDLE)
    delivery = {'state': 'complete', 'completed_at': datetime.now(ZoneInfo('Asia/Shanghai')).isoformat(),
        'dataset': str(BUNDLE), 'archive': str(archive), 'summary': old['summary'],
        'dataset_audit': audit, 'archive_audit': archive_audit, 'final_frozen_payload_audit': payload_audit,
        'yaml_consumer_audit': {'state': 'passed', 'consumer': 'ultralytics.data.utils.check_det_dataset'},
        'dataset_manifest_sha256': file_digest(BUNDLE/'manifest.json'),
        'annotations_sha256': file_digest(BUNDLE/'annotations/frames.jsonl'),
        'normalization_fitted': False, 'models_trained_this_task': 0, 'final_test_scored': False}
    safe_json(OUTPUT/'delivery_manifest.json', delivery)
    stamp(OUTPUT, 'complete', **delivery)


if __name__ == '__main__':
    main()
