"""Executable planning adoption recipe, using the native owner and independent reader.

OpenAI Codex as Directed by Tyson Weihs. Inputs are invented, not operational data.
Run from a source checkout; Python does not implement flight or hashing semantics.
"""
import argparse
import copy
import json
import subprocess
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[4]
CRATE = ROOT / 'modules/planning/rust/planning_engine'
BINARY = CRATE / 'target/debug/aeronautiql-planning-engine'
sys.path.insert(0, str(ROOT / 'modules/planning/schema/v1_1/results'))
from validators import admit_result, validate_snapshot
from draw import validate_draw

CONTEXT = {'slot': 'activeMap', 'slotRevision': 1,
           'navigationContextRevision': 'example-navigation-1', 'mode': 'planning'}


def call(operation, request):
    """Send one strict JSON request to the same dispatcher used by the C ABI."""
    response = subprocess.run([str(BINARY), operation], input=json.dumps(request, allow_nan=False),
                              text=True, capture_output=True, check=True)
    return json.loads(response.stdout)


def prepare(request):
    request = copy.deepcopy(request)
    request['resources'] = call('capture-resources', request['resources'])
    request['job']['dependencyKey'] = call('prepare-key', request)
    return request


def publication(request, results, sources=None):
    """Publish and independently admit a matched snapshot/draw pair."""
    dependencies = {leg['legId']: call('prepare-key', {**request, 'legId': leg['legId']})
                    for leg in request['intent']['legs']}
    value = {'intent': request['intent'], 'dependencies': dependencies, 'results': results,
             'generation': 1, 'snapshotId': 'example-snapshot', 'projectionId': 'example-draw',
             'context': CONTEXT, 'reuseSources': sources or []}
    bundle = call('publish', value)
    validate_snapshot(bundle['snapshot'], request['intent'], dependencies)
    validate_draw(request['intent'], bundle['snapshot'], bundle['draw'], dependencies, CONTEXT)
    return bundle


def must_reject(operation, request):
    try:
        call(operation, request)
    except subprocess.CalledProcessError as error:
        assert 'panicked' not in error.stderr
        return
    raise AssertionError(f'{operation} accepted an invalid or stale request')


def map_edit(request, result, mapping, hit, operation):
    return {'intent': request['intent'], 'result': result, 'context': CONTEXT,
            'now': '2026-11-21T12:00:01Z', 'newCommitId': 'example-edited-commit',
            'command': {'schemaVersion': '1.1', 'commandId': 'example-gesture',
                        'documentId': request['intent']['documentId'],
                        'baseCommitId': request['intent']['commitId'],
                        'issuedAt': '2026-11-21T12:00:00Z', 'expiresAt': '2026-11-21T12:01:00Z',
                        'origin': {'kind': 'map', 'capture': {'legId': request['legId'],
                                   'resolutionMappingId': mapping['resolutionMappingId'],
                                   'editMappingId': mapping['editMappingId'],
                                   'context': CONTEXT, 'hit': hit}}, 'operation': operation}}


def run(output):
    # docs:start lifecycle
    request = json.loads(Path(__file__).with_name('request.json').read_text())
    assert call('validate', request['intent']) == {'valid': True}
    assert call('check-support', request['intent']) == {'valid': True}
    request = prepare(request)
    pending = call('resolve', request)
    assert pending['evaluation']['state'] == 'pending'
    publication(request, [pending])
    result = call('evaluate', request)
    assert admit_result(result, request['job']['dependencyKey'], request['intent'], request['resources']) == 'accepted'
    bundle = publication(request, [result])
    assert bundle['snapshot']['planState'] == 'complete'

    # docs:end lifecycle

    # Resource failures retain the current lateral path, without invented metrics.
    unavailable = copy.deepcopy(request)
    unavailable['resources']['winds']['source']['kind'] = 'unsupported-weather'
    unavailable = prepare(unavailable)
    missing = call('evaluate', unavailable)
    assert missing['evaluation']['state'] == 'unavailable'
    assert publication(unavailable, [missing])['draw']['edges']

    # Repeated identifiers have separate occurrence IDs. Edit only the captured one.
    repeated = copy.deepcopy(request)
    repeated['intent']['legs'][0]['elements'] = [
        {'elementId': eid, 'kind': 'fix', 'ident': ident}
        for eid, ident in [('first-visit', 'FIXA'), ('middle', 'FIXB'), ('second-visit', 'FIXA')]]
    repeated = prepare(repeated)
    resolved = call('evaluate', repeated)
    mapping = call('edit-mapping', {'intent': repeated['intent'], 'result': resolved, 'context': CONTEXT})
    vertex = next(v for v in mapping['vertices'] if v.get('elementId') == 'second-visit')
    replacement = {'elementId': 'second-visit', 'kind': 'coordinate',
                   'coordinate': {'latitudeDeg': 34, 'longitudeDeg': -101, 'datum': 'WGS84'}}
    operation = {'type': 'replaceElement', 'legId': 'outbound', 'elementId': 'second-visit', 'element': replacement}
    command = map_edit(repeated, resolved, mapping, {'kind': 'vertex', 'vertexId': vertex['vertexId']}, operation)
    changed = call('map-edit', command)
    assert changed['legs'][0]['elements'][0] == repeated['intent']['legs'][0]['elements'][0]
    assert changed['legs'][0]['elements'][2] == replacement
    deletion = copy.deepcopy(command)
    deletion['command']['operation'] = {'type': 'deleteElement', 'legId': 'outbound', 'elementId': 'second-visit'}
    assert len(call('map-edit', deletion)['legs'][0]['elements']) == 2
    edge = next(e for e in mapping['edges'] if e['state'] == 'editable')
    insertion = {'type': 'insertElement', 'legId': 'outbound',
                 'afterElementId': None if edge['insertion']['kind'] == 'beforeFirst' else edge['insertion']['elementId'],
                 'element': {**replacement, 'elementId': 'inserted-point'}}
    insert = map_edit(repeated, resolved, mapping, {'kind': 'edge', 'edgeId': edge['edgeId']}, insertion)
    assert len(call('map-edit', insert)['legs'][0]['elements']) == 4
    stale = copy.deepcopy(command)
    stale['context']['slotRevision'] += 1  # clear/reselect invalidates this captured gesture
    must_reject('map-edit', stale)
    stale_result = copy.deepcopy(request)
    stale_result['intent']['commitId'] = 'different-commit'
    must_reject('publish', {'intent': stale_result['intent'],
                          'dependencies': {'outbound': call('prepare-key', stale_result)},
                          'results': [result], 'generation': 2, 'snapshotId': 'stale',
                          'projectionId': 'stale', 'context': CONTEXT})
    for mutation in ['version', 'duplicate']:
        bad = copy.deepcopy(repeated['intent'])
        if mutation == 'version': bad['schemaVersion'] = '999.0'
        else: bad['legs'][0]['elements'][2]['elementId'] = 'first-visit'
        must_reject('validate', bad)

    # Reuse has a new current envelope; retain the admitted original capture.
    source = {key: copy.deepcopy(request[key]) for key in ('intent', 'resources')}
    source['result'] = result
    reuse = copy.deepcopy(request)
    reuse['intent']['commitId'] = 'example-commit-2'
    reuse['job'].update(jobId='reuse-job', resultId='reuse-result')
    reuse = prepare(reuse)
    reuse['source'] = source
    reused = call('reuse', reuse)
    assert reused['evaluation'] == result['evaluation']
    assert admit_result(reused, reuse['job']['dependencyKey'], reuse['intent'], reuse['resources'], [source]) == 'accepted'
    publication(reuse, [reused], [source])
    expired = copy.deepcopy(reuse)
    expired['resources']['winds']['revision'] = 'changed-weather'
    expired = prepare(expired)
    must_reject('reuse', expired)

    # A portable file round trip is independent of a host's SQLite/cloud coordinator.
    output.mkdir(parents=True, exist_ok=True)
    for name, value in [('intent', request['intent']), ('request', request), ('result', result),
                        ('snapshot', bundle['snapshot']), ('draw', bundle['draw'])]:
        path = output / f'{name}.json'
        path.write_text(json.dumps(value, indent=2, allow_nan=False) + '\n')
        assert json.loads(path.read_text()) == value
    print('PASS: validate, capture, resolve, evaluate, publish, independent admission,')
    print('      unavailable weather, insert/replace/delete, repeated occurrence, stale rejection,')
    print('      unsupported version, duplicate IDs, reuse/expiry and portable file round trip')


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output', type=Path, required=True, help='Directory for generated example artifacts')
    run(parser.parse_args().output)
