"""Prepare or execute one immutable task/model/attempt through local Harbor."""
import argparse
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tomllib
from simrepairbench.campaign import RateCard,digest,link_harbor_job,save
from simrepairbench.campaign_models import ModelEpisodeStore,load_plan,model_episode_index,repair_prompt_sha256
from simrepairbench.campaign_versioned import RunIdentity,VersionedBudgetLedger,canonical_hash,model_config_id
from simrepairbench import campaign
from simrepairbench.campaign_observation import OBSERVATION_POLICY,validated_png


def prepare(args):
    plan,authorizations=load_plan(args.run_plan)
    configuration=json.loads(args.model_configuration.read_text());config_id=model_config_id(configuration)
    if configuration['provider']!='openai' or configuration['requested_model']!='gpt-6-astra':raise ValueError('This controller supports the authorized Astra configuration only')
    if configuration['harness_version']!='3.0.0' or configuration['system_prompt_sha256']!=repair_prompt_sha256() or configuration['tools'].get('schema_sha256')!=canonical_hash(campaign.TOOLS):raise ValueError('Configured harness, tools or prompt differ')
    if configuration.get('observation_policy')!=OBSERVATION_POLICY:raise ValueError('The initial broken PNG observation contract is required')
    generation=configuration['generation']
    if generation!={'max_output_tokens':4096,'max_input_tokens':128000} or configuration['reasoning_effort']!='medium':raise ValueError('Unsupported campaign generation limits')
    rows=[row for row in plan['runs'] if row['case_id']==args.case and row['model_config_id']==config_id and row['attempt_id']==args.attempt_id]
    if len(rows)!=1:raise ValueError('Exactly one authorized immutable attempt is required')
    row=rows[0];identity=RunIdentity(row['case_id'],row['task_revision'],config_id,row['attempt_id']);pins=row['input']
    if pins['dataset_version']!='0.3.0':raise ValueError('This launcher requires the revised 0.3.0 input release')
    for name in ('package_sha256','asset_sha256','harbor_task_digest','objective_profile_sha256','initial_observation_sha256'):
        if not campaign.SHA.fullmatch(pins.get(name,'')):raise ValueError('Missing immutable input pin: '+name)
    if not __import__('re').fullmatch('[0-9a-f]{40}',pins.get('hf_revision','')):raise ValueError('Immutable published HF input revision required')
    if not args.ledger.is_file():raise ValueError('The existing financial ledger must be preserved')
    task=args.task_path.resolve();cfg=tomllib.loads((task/'task.toml').read_text())
    if cfg['metadata']['case_id']!=identity.case_id or cfg['metadata']['task_revision']!=identity.task_revision:raise ValueError('Task identity differs from the planned revision')
    if cfg['environment']['network_mode']!='no-network' or cfg['verifier']['environment_mode']!='separate' or cfg['verifier']['environment']['network_mode']!='no-network':raise ValueError('Task isolation differs from the qualified protocol')
    if digest(task/'environment/input/asset.usdc')!=pins['asset_sha256']:raise ValueError('Actor input USD differs from the planned input')
    image_path=task/'environment/input/visual-observation.png'
    validated_png(image_path,pins['initial_observation_sha256'])
    rates=RateCard.load(args.rates)
    if rates.provider!=configuration['provider'] or rates.model!=configuration['requested_model']:raise ValueError('Price card differs from the configured model')
    episode=identity.episode_id(plan['campaign_id'])
    kwargs={'budget_db':str(args.ledger.resolve()),'campaign_id':plan['campaign_id'],'case_id':identity.case_id,'episode_id':episode,
            'episode_root':str(args.episodes.resolve()),'price_card':str(args.rates.resolve()),'input_package_sha256':pins['package_sha256'],
            'input_package_path':pins['package_path'],'input_asset_sha256':pins['asset_sha256'],'max_output_tokens':4096,'reasoning_effort':'medium',
            'initial_observation_path':str(image_path),'run_plan':str(args.run_plan.resolve()),'model_configuration':str(args.model_configuration.resolve()),'task_revision':identity.task_revision,'model_config_id':config_id,'attempt_id':identity.attempt_id}
    argv=[args.harbor,'run','-p',str(task),'-a','simrepairbench.campaign_models:VersionedAstraAgent','-m','openai/gpt-6-astra','-n','1','-k','1','-r','0','-o',str(args.jobs.resolve()),'--job-name',episode]
    for key,value in kwargs.items():argv+=['--ak',key+'='+json.dumps(value)]
    return plan,authorizations,configuration,identity,pins,argv


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    for flag in ('run-plan','model-configuration','ledger','rates','episodes','task-path','jobs'):parser.add_argument('--'+flag,type=Path,required=True)
    parser.add_argument('--case',required=True);parser.add_argument('--attempt-id',type=int,default=1);parser.add_argument('--harbor',default='harbor')
    parser.add_argument('--preflight',type=Path,help='Passed native artifact-transfer control receipt for this exact task')
    parser.add_argument('--execute',action='store_true',help='Run the authorized single episode; default only prints its command')
    args=parser.parse_args();plan,authorizations,configuration,identity,pins,argv=prepare(args)
    result={'schema':'simrepairbench-launch-plan-v3','campaign_id':plan['campaign_id'],'identity':identity.__dict__,'episode_id':identity.episode_id(plan['campaign_id']),
            'input':pins,'argv':argv,'executed':False,'financial_ledger':str(args.ledger.resolve()),'new_ledger_created':False,'public_uploads':False,'private_archival':False}
    if not args.execute:print(json.dumps(result,indent=2));return
    if args.preflight is None:raise ValueError('A passed native control receipt is required before inference')
    preflight=json.loads(args.preflight.read_text())
    for name,value in {'passed':True,'task_revision':identity.task_revision,'harbor_task_digest':pins['harbor_task_digest'],'input_asset_sha256':pins['asset_sha256'],
                       'actor_no_network':True,'separate_verifier':True,'artifact_transfer_passed':True,'actor_reference_absent':True}.items():
        if preflight.get(name)!=value:raise ValueError('Native preflight mismatch: '+name)
    from harbor.publisher.packager import Packager
    from harbor.models.task.task import Task
    Task(args.task_path)
    actual,_=Packager.compute_content_hash(args.task_path)
    if actual!=pins['harbor_task_digest']:raise ValueError('Task archive content differs from the published digest')
    ledger=VersionedBudgetLedger(args.ledger,plan['campaign_id'],authorizations=authorizations,bound_identity=identity)
    summary=ledger.summary()
    if summary['state']!='active' or any(call['state'] in ('reserved','uncertain') for call in summary['calls']):raise ValueError('Financial campaign is held or provider usage is unsettled')
    required=max(12*1024**3,12*sum(p.stat().st_size for p in args.task_path.rglob('*') if p.is_file())+4*1024**3)
    if shutil.disk_usage(args.jobs.resolve().parent).free<required:raise ValueError('Observed-peak disk headroom guard failed')
    episode=identity.episode_id(plan['campaign_id']);store=ModelEpisodeStore(args.episodes,plan['campaign_id'],identity.case_id,episode,identity=identity,configuration=configuration,input_context=pins)
    if store.manifest.exists() or (args.jobs/episode).exists():raise ValueError('An existing attempt cannot be rerun')
    args.jobs.mkdir(parents=True,exist_ok=True);result.update(executed=True,preflight_sha256=digest(args.preflight),disk_required_bytes=required)
    print(json.dumps(result),flush=True)
    environment=os.environ.copy();source=Path(__file__).resolve().parents[1]/'src';environment['PYTHONPATH']=str(source)+os.pathsep+environment.get('PYTHONPATH','')
    process=subprocess.run(argv,check=False,env=environment)
    # Harbor's verifier runs after the actor. Attach only verifier-owned outputs.
    if store.manifest.exists():
        save(store.path/'harbor-command.json',result)
        if (args.jobs/episode).is_dir():link_harbor_job(store,args.jobs/episode)
        model_episode_index(args.episodes,plan['campaign_id'])
    raise SystemExit(process.returncode)


if __name__=='__main__':main()