"""Merge independently reviewed source-training labels into a frozen snapshot."""
from __future__ import annotations

import argparse
from copy import deepcopy
from dataclasses import asdict
import json
from pathlib import Path

from pallet.annotation.workflow import is_resolved, load_jsonl, save_jsonl
from pallet.data.protocol import file_digest, load_protocol, write_json


def select_unresolved_source_train(primary_path, supplemental_path, protocol,
                                   audit_groups, output, *, target_domain=None):
    """Bind independently reviewed additions without altering audit frames."""
    primary=load_jsonl(primary_path)
    supplemental=load_jsonl(supplemental_path)
    records,assignments,_=load_protocol(protocol)
    audit_groups=set(audit_groups)
    target_groups={row.group_id for row in records
                   if target_domain is not None and getattr(row,'domain',None)==target_domain}
    if not audit_groups or any(assignments.get(group)!='train' for group in audit_groups):
        raise ValueError('frozen source-training audit groups are required')
    selected=[]
    for row in records:
        if assignments[row.group_id]!='train' or row.group_id in audit_groups | target_groups:
            continue
        existing=primary.frames[row.frame_id]
        candidate=supplemental.frames.get(row.frame_id)
        if candidate is None or not is_resolved(candidate,require_blind=True):
            continue
        if (existing.group_id!=row.group_id or candidate.group_id!=row.group_id
                or existing.source_anchor_hash!=row.source_sha256
                or candidate.source_anchor_hash!=row.source_sha256
                or candidate.split!='train'):
            raise ValueError(f'supplemental source identity differs: {row.frame_id}')
        if any(provenance.source.lower() in {'detector','fewshot','sam3','model','segmentation'}
               for provenance in candidate.provenance):
            raise ValueError(f'supplemental label has model provenance: {row.frame_id}')
        if not is_resolved(existing):
            selected.append(row.frame_id)
    output=Path(output)
    selection={'train':selected,'val':[],'test':[]}
    manifest={'primary_sha256':file_digest(primary_path),
              'supplemental_sha256':file_digest(supplemental_path),
              'protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
              'audit_groups':sorted(audit_groups),'target_domain':target_domain,
              'selected_frames':len(selected)}
    if output.exists() and json.loads(output.read_text())!=selection:
        raise ValueError('existing supplemental selection differs')
    if output.with_suffix('.manifest.json').exists() and json.loads(
            output.with_suffix('.manifest.json').read_text())!=manifest:
        raise ValueError('existing supplemental selection binding differs')
    write_json(output,selection)
    write_json(output.with_suffix('.manifest.json'),manifest)
    return manifest


def merge_source_train(primary_path, supplemental_path, protocol, selection_path, output,
                       *, target_domain=None):
    output = Path(output)
    if output.exists() or output.with_suffix(".manifest.json").exists():
        raise ValueError("merged snapshot already exists; use a new versioned output path")
    primary = load_jsonl(primary_path)
    supplemental = load_jsonl(supplemental_path)
    records, assignments, _ = load_protocol(protocol)
    by_id = {row.frame_id: row for row in records}
    target_groups={row.group_id for row in records
                   if target_domain is not None and getattr(row,'domain',None)==target_domain}
    selection = json.loads(Path(selection_path).read_text())
    selected = selection["train"]
    if (not isinstance(selected,list) or len(selected)!=len(set(selected))
            or selection.get('val') or selection.get('test')):
        raise ValueError('supplemental selection must contain unique source training only')
    binding_path=Path(selection_path).with_suffix('.manifest.json')
    if binding_path.exists():
        binding=json.loads(binding_path.read_text())
        if (binding.get('primary_sha256')!=file_digest(primary_path)
                or binding.get('supplemental_sha256')!=file_digest(supplemental_path)
                or binding.get('protocol_sha256')!=file_digest(Path(protocol)/'protocol.json')
                or binding.get('target_domain')!=target_domain):
            raise ValueError('supplemental selection differs from its bound inputs')
    inserted = unchanged = pending = 0
    for fid in selected:
        row = by_id[fid]
        if assignments[row.group_id] != "train" or row.group_id in target_groups:
            raise ValueError(f"supplemental selection contains non-source training frame: {fid}")
        candidate = supplemental.frames.get(fid)
        if candidate is None or not is_resolved(candidate, require_blind=True):
            raise ValueError(f'supplemental frame is unresolved: {fid}')
        if any(provenance.source.lower() in {"detector", "fewshot", "sam3", "model", "segmentation"}
               for provenance in candidate.provenance):
            raise ValueError(f"supplemental independent source label has model provenance: {fid}")
        original = primary.frames[fid]
        if (candidate.split != "train" or candidate.group_id != row.group_id
                or candidate.source_anchor_hash != row.source_sha256
                or original.group_id != row.group_id
                or original.source_anchor_hash != row.source_sha256):
            raise ValueError(f"supplemental source identity differs: {fid}")
        if is_resolved(original):
            if asdict(original) != asdict(candidate):
                raise ValueError(f"existing resolved source label conflicts: {fid}")
            unchanged += 1
        else:
            primary.frames[fid] = deepcopy(candidate)
            inserted += 1
    if inserted == 0:
        raise ValueError("supplemental snapshot has no new resolved source labels")
    save_jsonl(primary, output)
    manifest = {"primary_sha256": file_digest(primary_path),
                "supplemental_sha256": file_digest(supplemental_path),
                "protocol_sha256": file_digest(Path(protocol) / "protocol.json"),
                "selection_sha256": file_digest(selection_path),
                "output_sha256": file_digest(output),
                "inserted": inserted, "already_identical": unchanged,
                "pending": pending,
                "target_domain": target_domain,
                "scope": "source training only; validation and test frames unchanged"}
    write_json(output.with_suffix(".manifest.json"), manifest)
    return manifest


def merge_adjudicated_conflicts(primary_path, adjudicated_path, protocol,
                                 selection_path, output):
    """Apply a frozen blind re-review to only the selected source-training frames."""
    output = Path(output)
    if output.exists() or output.with_suffix('.manifest.json').exists():
        raise ValueError('conflict merge output already exists')
    selection_path = Path(selection_path)
    binding = json.loads(selection_path.with_suffix('.manifest.json').read_text())
    selection = json.loads(selection_path.read_text())
    selected = selection.get('train', [])
    if (binding.get('purpose') != 'independent visual adjudication; no snapshot overwrites'
            or binding.get('protocol_sha256') != file_digest(Path(protocol)/'protocol.json')
            or binding.get('frames') != len(selected)
            or not selected or len(set(selected)) != len(selected)
            or selection.get('val') or selection.get('test')):
        raise ValueError('invalid frozen conflict selection')
    primary = load_jsonl(primary_path)
    adjudicated = load_jsonl(adjudicated_path)
    records, assignments, _ = load_protocol(protocol)
    by_id = {row.frame_id: row for row in records}
    if set(primary.frames) != set(adjudicated.frames):
        raise ValueError('conflict review changed dataset membership')
    selected_set = set(selected)
    for fid, original in primary.frames.items():
        candidate = adjudicated.frames[fid]
        if fid not in selected_set and asdict(original) != asdict(candidate):
            raise ValueError(f'conflict review changed an unselected frame: {fid}')
    for fid in selected:
        row = by_id[fid]
        original = primary.frames[fid]
        candidate = adjudicated.frames[fid]
        if (assignments[row.group_id] != 'train' or candidate.split != 'train'
                or original.group_id != row.group_id or candidate.group_id != row.group_id
                or original.source_anchor_hash != row.source_sha256
                or candidate.source_anchor_hash != row.source_sha256
                or not is_resolved(candidate, require_blind=True)):
            raise ValueError(f'conflict frame is not resolved source training: {fid}')
        prior_reviews = [asdict(review) for review in original.reviews]
        later_reviews = [asdict(review) for review in candidate.reviews]
        if (later_reviews[:len(prior_reviews)] != prior_reviews
                or len(later_reviews) != len(prior_reviews) + 3):
            raise ValueError(f'conflict review chain differs from primary: {fid}')
        proposals = candidate.reviews[-3:-1]
        decision = candidate.reviews[-1]
        if (any(not review.blind or review.decision != 'needs_work' for review in proposals)
                or not decision.blind or decision.decision != 'adjudicate'
                or len({review.reviewer for review in (*proposals, decision)}) != 3
                or set(decision.adjudicates) != {review.review_id for review in proposals}):
            raise ValueError(f'conflict frame lacks independent adjudication: {fid}')
        primary.frames[fid] = deepcopy(candidate)
    save_jsonl(primary, output)
    manifest = {'primary_sha256': file_digest(primary_path),
                'adjudicated_sha256': file_digest(adjudicated_path),
                'selection_sha256': file_digest(selection_path),
                'selection_manifest_sha256': file_digest(selection_path.with_suffix('.manifest.json')),
                'protocol_sha256': binding['protocol_sha256'],
                'output_sha256': file_digest(output), 'corrected_train_frames': len(selected),
                'scope': 'selected source-training conflicts only; all other frames byte-equivalent'}
    write_json(output.with_suffix('.manifest.json'), manifest)
    return manifest


def merge_reviewed_subset(primary_path, reviewed_path, protocol, selection_path, output):
    """Overlay independently reviewed source-training frames from one bound branch."""
    output = Path(output)
    if output.exists() or output.with_suffix('.manifest.json').exists():
        raise ValueError('reviewed subset output already exists')
    primary = load_jsonl(primary_path)
    reviewed = load_jsonl(reviewed_path)
    records, assignments, _ = load_protocol(protocol)
    by_id = {row.frame_id: row for row in records}
    selection_path = Path(selection_path)
    selection = json.loads(selection_path.read_text())
    selected = selection.get('train', [])
    if (not isinstance(selected, list) or not selected or len(selected) != len(set(selected))
            or selection.get('val') or selection.get('test')):
        raise ValueError('reviewed subset must select unique source-training frames only')
    if set(primary.frames) != set(reviewed.frames):
        raise ValueError('reviewed subset changed dataset membership')
    for fid in selected:
        row = by_id.get(fid)
        original = primary.frames.get(fid)
        candidate = reviewed.frames.get(fid)
        if (row is None or assignments.get(row.group_id) != 'train'
                or original is None or candidate is None
                or original.split != 'train' or candidate.split != 'train'
                or original.group_id != row.group_id or candidate.group_id != row.group_id
                or original.source_anchor_hash != row.source_sha256
                or candidate.source_anchor_hash != row.source_sha256
                or not is_resolved(candidate, require_blind=True)):
            raise ValueError(f'reviewed frame is not resolved blind source training: {fid}')
        old_reviews = [asdict(review) for review in original.reviews]
        new_reviews = [asdict(review) for review in candidate.reviews]
        if (new_reviews[:len(old_reviews)] != old_reviews
                or len(new_reviews) < len(old_reviews) + 3):
            raise ValueError(f'reviewed frame does not continue the current label history: {fid}')
        fresh = candidate.reviews[len(old_reviews):]
        proposals = fresh[:-1]
        decision = fresh[-1]
        if (len(proposals) < 2 or any(not review.blind or review.decision != 'needs_work'
                                      for review in proposals)
                or len({review.reviewer for review in fresh}) != len(fresh)
                or not decision.blind or decision.decision != 'adjudicate'
                or set(decision.adjudicates) != {review.review_id for review in proposals}
                or any(review.reviewer in {item.reviewer for item in original.reviews}
                       for review in fresh)):
            raise ValueError(f'reviewed frame lacks a fresh independent decision chain: {fid}')
        primary.frames[fid] = deepcopy(candidate)
    save_jsonl(primary, output)
    manifest = {'primary_sha256': file_digest(primary_path),
                'reviewed_snapshot_sha256': file_digest(reviewed_path),
                'selection_sha256': file_digest(selection_path),
                'protocol_sha256': file_digest(Path(protocol)/'protocol.json'),
                'output_sha256': file_digest(output), 'overlaid_source_train_frames': len(selected),
                'scope': 'selected independently reviewed source-training frames only'}
    write_json(output.with_suffix('.manifest.json'), manifest)
    return manifest


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--primary", required=True)
    parser.add_argument("--supplemental", required=True)
    parser.add_argument("--protocol", default="outputs/protocol_v5")
    parser.add_argument("--selection")
    parser.add_argument("--select-unresolved", action="store_true")
    parser.add_argument("--audit-panel")
    parser.add_argument("--target-domain")
    parser.add_argument("--adjudicated-conflicts", action="store_true")
    parser.add_argument("--reviewed-subset", action="store_true")
    parser.add_argument("--output", required=True)
    args = parser.parse_args()
    if args.adjudicated_conflicts:
        if not args.selection:
            parser.error('--adjudicated-conflicts requires --selection')
        result=merge_adjudicated_conflicts(args.primary,args.supplemental,args.protocol,
                                            args.selection,args.output)
    elif args.reviewed_subset:
        if not args.selection:
            parser.error('--reviewed-subset requires --selection')
        result=merge_reviewed_subset(args.primary,args.supplemental,args.protocol,
                                     args.selection,args.output)
    elif args.select_unresolved:
        if not args.audit_panel:
            parser.error('--select-unresolved requires --audit-panel')
        panel=json.loads(Path(args.audit_panel).read_text())
        groups=[group['group_id'] for group in panel['groups']]
        result=select_unresolved_source_train(args.primary,args.supplemental,
                                              args.protocol,groups,args.output,
                                              target_domain=args.target_domain)
    else:
        if not args.selection:
            parser.error('merge requires --selection')
        result=merge_source_train(args.primary,args.supplemental,
                                  args.protocol,args.selection,args.output,
                                  target_domain=args.target_domain)
    print(json.dumps(result))
