"""Flat native-frame seed workspace with original rectangles and no polygons."""
from __future__ import annotations

import argparse
from collections import Counter
import copy
import csv
from datetime import datetime
import hashlib
import io
import json
from pathlib import Path
import tempfile
import zipfile
from zoneinfo import ZoneInfo

import numpy as np
from PIL import Image

from pallet.fork_face_anylabeling import digest, encoded, protected_write, read_checked, safe_path
from pallet.fork_face_simplify import check_label_save, load_label_file


DEFAULT_SEED = Path('outputs/pallet_cluster_annotation_seed_v1')
DEFAULT_OUTPUT = Path('outputs/pallet_cluster_annotation_seed_rectangles_v1')
LABEL_SHA = '6ffd52de45420952576cf0cf30718ab637e0ad8375c241f1800ee7ccb2f59e92'


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


def read_jsonl(path):
    return [json.loads(line) for line in Path(path).read_text().splitlines() if line.strip()]


def rectangle_document(original, frame, selected):
    """Keep every reviewed detection rectangle, including other parent pallets."""
    document = copy.deepcopy(original)
    if (document['imageWidth'], document['imageHeight']) != (frame['width'], frame['height']):
        raise ValueError('Original label and native grid disagree')
    boxes = frame['boxes']
    if boxes[selected['box_index']] != selected['bbox']:
        raise ValueError('Selected original floating box changed')
    expected = [('pallet', [[b['x'], b['y']], [b['x']+b['width'], b['y']+b['height']]]) for b in boxes]
    expected += [('__ignore__', [[b['x'], b['y']], [b['x']+b['width'], b['y']+b['height']]])
                 for b in frame.get('ignore_regions', [])]
    actual = []
    for shape in document['shapes']:
        points = np.asarray(shape['points'], dtype=float)
        if (shape['shape_type'] != 'rectangle' or points.shape != (2, 2) or not np.isfinite(points).all()
                or points.min() < 0 or points[:, 0].max() > frame['width']
                or points[:, 1].max() > frame['height'] or (points[1] <= points[0]).any()):
            raise ValueError('Original label is not a valid native rectangle')
        actual.append((shape['label'], shape['points']))
    if actual != expected:
        raise ValueError('Original rectangle labels differ from formal floating boxes')
    image_name = Path(frame['image']).name
    document['imagePath'] = image_name
    document['imageData'] = None
    document.setdefault('text', '')
    document['flags'].update({'mask_human_reviewed': False, 'segmentation_training_eligible': False})
    document['pallet_annotation_task'] = {
        'version': 1, 'frame_id': frame['frame_id'], 'appearance_class': selected['appearance_class'],
        'selected_target_id': selected['target_id'], 'selected_box_index': selected['box_index'],
        'selected_bbox': selected['bbox'], 'original_split': frame['split'],
        'segmentation_status': 'not_started', 'polygon_annotations': 0,
        'mask_human_reviewed': False, 'segmentation_training_eligible': False,
        'rectangle_source': 'formal_human_reviewed_detection_annotations',
        'all_original_rectangles_preserved': True,
        'note': 'Detection review flags describe existing boxes. Segmentation has not been annotated.'}
    return document


def context(args):
    seed = args.seed_source.resolve()
    selection_path = seed/'delivery/selection.jsonl'
    seed_manifest_path = seed/'delivery/manifest.json'
    registry_path = seed/'delivery/verified_assets.json'
    seed_receipt = read_json(seed/'delivery_manifest.json')
    if digest(registry_path) != seed_receipt['validation']['verified_assets_sha256']:
        raise ValueError('Seed source asset registry changed')
    registry = read_json(registry_path)['files']
    for name in ['selection.jsonl', 'manifest.json', 'source/anylabeling_label_file.py']:
        read_checked(seed/'delivery', name, registry)
    seed_manifest = read_json(seed_manifest_path)
    formal_manifest_path = (args.formal_manifest.resolve() if args.formal_manifest else
        Path(seed_manifest['binding']['clustering']).parent.parent/'run_manifest.json')
    formal = read_json(formal_manifest_path)
    dataset = args.dataset.resolve() if args.dataset else Path(formal['binding']['dataset']).resolve()
    output = args.output.resolve()
    for source in (seed, dataset):
        if output.is_relative_to(source) or source.is_relative_to(output):
            raise ValueError('Output must be separate from frozen sources')
    protected = formal['protected_files']
    read_checked(dataset, 'annotations/frames.jsonl', protected)
    frames = read_jsonl(dataset/'annotations/frames.jsonl')
    frames_by_id = {f['frame_id']: f for f in frames}
    if len(frames) != len(frames_by_id): raise ValueError('Duplicate formal frame identity')
    selected = read_jsonl(selection_path)
    if not selected or len({r['frame_id'] for r in selected}) != len(selected) or len({r['target_id'] for r in selected}) != len(selected):
        raise ValueError('Duplicate or empty seed selection')
    names = [Path(frames_by_id[r['frame_id']]['image']).name for r in selected]
    if len(names) != len(set(names)): raise ValueError('Flat native filenames would collide')
    label_source = seed/'delivery/source/anylabeling_label_file.py'
    label_class = load_label_file(label_source, LABEL_SHA)
    controls = [selection_path, seed_manifest_path, registry_path, seed/'delivery_manifest.json', formal_manifest_path]
    source_files = {str(p): digest(p) for p in controls}
    source_files[str(label_source)] = LABEL_SHA
    archive = seed/seed_receipt['archive_name']
    if digest(archive) != seed_receipt['archive_sha256']: raise ValueError('Frozen seed ZIP changed')
    source_files[str(archive)] = seed_receipt['archive_sha256']
    binding = {'kind': 'flat_rectangle_annotation_seed', 'version': 1, 'dataset': str(dataset),
               'seed_source': str(seed), 'source_files': source_files, 'targets': len(selected),
               'label_format': 'AnyLabeling rectangles', 'all_frame_boxes_preserved': True,
               'polygon_annotations': 0, 'source_code_sha256': digest(__file__)}
    binding['task_hash'] = hashlib.sha256(encoded(binding)).hexdigest()
    args.output.mkdir(parents=True, exist_ok=True)
    protected_write(args.output/'run_manifest.json', encoded(binding))
    return dict(args=args, seed=seed, seed_hashes=registry, dataset=dataset, selected=selected, frames=frames_by_id,
                protected=protected, binding=binding, label_class=label_class,
                delivery=args.output/'delivery', output=args.output)


def read_source(ctx, row):
    frame = ctx['frames'][row['frame_id']]
    if row['split'] != frame['split'] or row['group_id'] != frame['group_id']:
        raise ValueError('Selected frame split/group differs from formal source')
    image_path = frame['image']
    annotation_path = str(Path(image_path).with_suffix('.json'))
    image = (safe_path(ctx['dataset'], image_path)).read_bytes()
    # The formal release records labels in its protected set and PNGs in its checksums.
    original = json.loads(read_checked(ctx['dataset'], annotation_path, ctx['protected']))
    seed_image = row['appearance_class']+'/images/'+Path(image_path).name
    frozen_image = read_checked(ctx['seed']/'delivery', seed_image, ctx['seed_hashes'])
    if image != frozen_image: raise ValueError('Native formal PNG differs from frozen selected image')
    with Image.open(io.BytesIO(image)) as decoded:
        decoded.load()
        if decoded.size != (frame['width'], frame['height']): raise ValueError('Native PNG dimensions changed')
    document = rectangle_document(original, frame, row)
    return frame, image, original, document


def csv_bytes(rows):
    stream = io.StringIO(newline='')
    columns = ['appearance_class', 'target_id', 'frame_id', 'box_index', 'bbox', 'original_split',
               'group_id', 'image', 'annotation', 'original_pallet_rectangles']
    writer = csv.DictWriter(stream, fieldnames=columns, extrasaction='ignore'); writer.writeheader()
    for row in rows:
        writer.writerow({k: json.dumps(v, ensure_ascii=False) if isinstance(v, dict) else v
                         for k, v in row.items() if k in columns})
    return b'\xef\xbb\xbf'+stream.getvalue().encode()


def export(ctx):
    files, records = {}, []
    def write(name, data):
        if '/' in name: raise ValueError('Delivery must be a flat directory')
        protected_write(ctx['delivery']/name, data)
        files[name] = hashlib.sha256(data).hexdigest()
    for number, selected in enumerate(ctx['selected'], 1):
        frame, image, original, document = read_source(ctx, selected)
        image_name = Path(frame['image']).name
        annotation_name = str(Path(image_name).with_suffix('.json'))
        write(image_name, image); write(annotation_name, encoded(document))
        records.append({'appearance_class': selected['appearance_class'], 'target_id': selected['target_id'],
                        'frame_id': selected['frame_id'], 'box_index': selected['box_index'], 'bbox': selected['bbox'],
                        'original_split': frame['split'], 'group_id': frame['group_id'],
                        'image': image_name, 'annotation': annotation_name,
                        'image_sha256': hashlib.sha256(image).hexdigest(), 'original_shapes': original['shapes'],
                        'original_pallet_rectangles': len(frame['boxes'])})
        if number % 100 == 0 or number == len(ctx['selected']):
            print(json.dumps({'stage': 'export', 'completed': number, 'total': len(ctx['selected'])}), flush=True)
    summary = {'frames': len(records), 'selected_targets': len(records),
               'per_class': dict(Counter(r['appearance_class'] for r in records)),
               'original_pallet_rectangles': sum(r['original_pallet_rectangles'] for r in records),
               'polygon_annotations': 0, 'flat_directory': True,
               'source_splits': dict(Counter(r['original_split'] for r in records)),
               'mask_human_reviewed': False, 'segmentation_training_eligible': False}
    public = [{k: v for k, v in r.items() if k != 'original_shapes'} for r in records]
    write('targets.jsonl', b''.join(encoded(r) for r in public))
    write('targets.csv', csv_bytes(records))
    write('manifest.json', encoded({'binding': ctx['binding'], 'summary': summary}))
    write('labels.txt', b'pallet\npallet_fork_face\n')
    instructions = f'''# 无多边形、原矩形框的平铺标注包

本包沿用A00–A43每类10个托盘的抽样，共{len(records)}张不同原尺寸帧。所有PNG与同名JSON位于当前目录，没有A类或train/val/test子目录。

仅提供正式检测数据中的原矩形框，类别为pallet，共{summary['original_pallet_rectangles']}个；同帧其他托盘的框一并保留。多边形标注数为0，未复制旧多边形建议或掩膜。矩形浮点坐标、原生图像、原180°校正保持不变。

在AnyLabeling直接打开当前目录。A类和选中的父托盘在targets.csv/JSONL以及每帧JSON的pallet_annotation_task中记录；selected_box_index从0开始，指向原托盘框顺序。人工可从原图重新绘制pallet_fork_face多边形，各可见面分别编号。

原human_reviewed标志仅说明既有检测矩形框已检查，不表示分割已完成。全部mask_human_reviewed与segmentation_training_eligible为false；矩形不能直接当作分割真值。保留矩形作定位参考，人工完成后从新增的多边形单独生成分割标签。仅标注入选托盘时，同帧未标注托盘仍须在后续训练中忽略。

保存修正副本并记录实际复核状态，交回完整图像/JSON与来源清单。原始ZIP保持冻结；重复导出保护已修改JSON。来源train/val/test只记录正式检测划分，本包不改变正式数据。旧多边形种子包保留为历史版本。
'''
    write('README_zh.md', instructions.encode())
    protected_write(ctx['output']/'export_assets.json', encoded({'task_hash': ctx['binding']['task_hash'], 'files': files}))
    return summary


def check_assets(ctx):
    registry = read_json(ctx['output']/'export_assets.json')
    if registry['task_hash'] != ctx['binding']['task_hash']: raise ValueError('Export task changed')
    allowed = set(registry['files']) | {'validation.json', 'checksums.sha256'}
    actual = {p.name for p in ctx['delivery'].iterdir() if p.is_file()}
    if actual - allowed or any(p.is_dir() for p in ctx['delivery'].iterdir()):
        raise ValueError('Unexpected files/groups; human edits are protected')
    for name, expected in registry['files'].items():
        if digest(ctx['delivery']/name) != expected:
            raise ValueError(f'Existing file changed; human edits are protected: {name}')
    return registry['files']


def check_sources(ctx):
    for path, expected in ctx['binding']['source_files'].items():
        if digest(path) != expected: raise ValueError(f'Frozen source changed: {path}')
    for path, expected in ctx['protected'].items():
        if digest(safe_path(ctx['dataset'], path)) != expected:
            raise ValueError(f'Formal annotation or metadata changed: {path}')


def verify(ctx):
    check_assets(ctx)
    boxes = 0
    with tempfile.TemporaryDirectory(prefix='flat-rectangles-save-') as temporary:
        for row in ctx['selected']:
            frame, image, original, expected = read_source(ctx, row)
            name = str(Path(frame['image']).with_suffix('.json').name)
            actual = read_json(ctx['delivery']/name)
            if actual != expected or actual['shapes'] != original['shapes']:
                raise ValueError('Original rectangle labels changed')
            if (ctx['delivery']/actual['imagePath']).read_bytes() != image:
                raise ValueError('Native image bytes changed')
            boxes += len(frame['boxes'])
            check_label_save(ctx['delivery']/name, Path(temporary)/'saved.json', ctx['label_class'])
    check_sources(ctx)
    validation = {'state': 'passed', 'task_hash': ctx['binding']['task_hash'],
                  'native_frames': len(ctx['selected']), 'original_pallet_rectangles': boxes,
                  'polygon_annotations': 0, 'flat_image_json_pairs': True, 'original_shapes_identical': True,
                  'original_native_images_identical': True, 'official_load_save_documents': len(ctx['selected']),
                  'protected_formal_files_unchanged': len(ctx['protected']), 'old_seed_package_unchanged': True,
                  'gui_application_tested': False}
    protected_write(ctx['delivery']/'validation.json', encoded(validation))
    protected_write(ctx['output']/'validation.json', encoded(validation))
    return validation


def package(ctx):
    assets = dict(check_assets(ctx))
    validation = read_json(ctx['output']/'validation.json')
    if validation['task_hash'] != ctx['binding']['task_hash'] or encoded(validation) != (ctx['delivery']/'validation.json').read_bytes():
        raise ValueError('Validation receipt changed')
    check_sources(ctx)
    receipt_path = ctx['output']/'delivery_manifest.json'
    if receipt_path.exists():
        receipt = read_json(receipt_path)
        if digest(ctx['output']/receipt['archive_name']) != receipt['archive_sha256']:
            raise ValueError('Published ZIP changed')
        return receipt
    assets['validation.json'] = digest(ctx['delivery']/'validation.json')
    protected_write(ctx['delivery']/'checksums.sha256', ''.join(f'{sha}  {name}\n' for name, sha in sorted(assets.items())).encode())
    assets['checksums.sha256'] = digest(ctx['delivery']/'checksums.sha256')
    archive = ctx['output']/'pallet_cluster_annotation_seed_rectangles_v1.zip'
    temporary = archive.with_suffix('.partial')
    with zipfile.ZipFile(temporary, 'w', compression=zipfile.ZIP_DEFLATED, compresslevel=4) as z:
        for name, expected in sorted(assets.items()):
            data = (ctx['delivery']/name).read_bytes()
            if hashlib.sha256(data).hexdigest() != expected: raise ValueError('Workspace changed while packaging')
            info = zipfile.ZipInfo(name, (2026, 1, 1, 0, 0, 0)); info.external_attr = 0o644 << 16
            z.writestr(info, data, compress_type=zipfile.ZIP_DEFLATED, compresslevel=4)
    with zipfile.ZipFile(temporary) as z:
        if z.testzip() is not None or len(z.namelist()) != len(assets) or any('/' in p for p in z.namelist()):
            raise ValueError('ZIP CRC/flat layout/count failed')
        for name, expected in assets.items():
            if hashlib.sha256(z.read(name)).hexdigest() != expected: raise ValueError('ZIP member hash failed')
        with tempfile.TemporaryDirectory(prefix='flat-rectangle-unzip-') as directory:
            z.extractall(directory)
            for row in ctx['selected']:
                name = Path(ctx['frames'][row['frame_id']]['image']).with_suffix('.json').name
                check_label_save(Path(directory)/name, Path(directory)/'save-test.json', ctx['label_class'])
    temporary.replace(archive)
    receipt = {'state': 'complete', 'task_hash': ctx['binding']['task_hash'], 'archive_name': archive.name,
               'archive_bytes': archive.stat().st_size, 'archive_sha256': digest(archive), 'zip_members': len(assets),
               'crc_passed': True, 'all_member_sha256_passed': True, 'flat_archive': True,
               'portable_load_save_documents': len(ctx['selected']), 'validation': validation,
               'summary': read_json(ctx['delivery']/'manifest.json')['summary'],
               'finished_at': datetime.now(ZoneInfo('Asia/Shanghai')).isoformat()}
    protected_write(archive.with_suffix('.zip.sha256'), f'{receipt["archive_sha256"]}  {archive.name}\n'.encode())
    protected_write(receipt_path, encoded(receipt))
    print(json.dumps({k: receipt[k] for k in ('state', 'archive_name', 'archive_bytes')}, ensure_ascii=False), flush=True)
    return receipt


def main(argv=None):
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--seed-source', type=Path, default=DEFAULT_SEED)
    parser.add_argument('--dataset', type=Path)
    parser.add_argument('--formal-manifest', type=Path)
    parser.add_argument('--output', type=Path, default=DEFAULT_OUTPUT)
    parser.add_argument('--stage', choices=['export', 'verify', 'package', 'all'], default='all')
    args = parser.parse_args(argv)
    ctx = context(args)
    for stage in (['export', 'verify', 'package'] if args.stage == 'all' else [args.stage]):
        {'export': export, 'verify': verify, 'package': package}[stage](ctx)


if __name__ == '__main__':
    main()
