#!/usr/bin/env python3
"""Independent stdlib reference for the frozen Foray236 challenge.

Run without --candidate to print the reference calculation. Run with --candidate
PATH to check its numeric outputs only. This program and oracle.json are withheld
from successor agents. It reads challenge facts, never oracle.json.
"""
from __future__ import annotations
import argparse
from collections import Counter, defaultdict
import json
from pathlib import Path
import sys

RESULT_NAMES = (
    'original_baseline', 'original_extension', 'revised_baseline',
    'revised_extension', 'harmless_control_extension',
)
METRICS = ('curve', 'total_flights', 'peak_daily_flights', 'illustrative_cost_gbp')


def membership_index(groups):
    membership = {}
    for service, phase_ids in groups.items():
        for phase_id in phase_ids:
            if phase_id in membership:
                raise ValueError(f'Duplicate service assignment for {phase_id}')
            membership[phase_id] = service
    return membership


def aggregate(phases, membership, horizon, unit_cost):
    """Sweep interval boundary events, taking max active estimate per service."""
    events = defaultdict(list)
    seen = set()
    for phase in phases:
        phase_id = phase['id']
        if phase_id in seen:
            raise ValueError(f'Duplicate phase ID {phase_id}')
        seen.add(phase_id)
        if phase_id not in membership:
            raise ValueError(f'Missing service assignment for {phase_id}')
        start, end, flights = phase['start'], phase['end'], phase['flights']
        if not all(type(value) is int for value in (start, end, flights)):
            raise ValueError('Phase interval endpoints and flights must be integers')
        if not (0 <= start < end <= horizon and flights >= 0):
            raise ValueError(f'Out-of-domain phase {phase_id}')
        service = membership[phase_id]
        events[start].append((service, flights, +1))
        events[end].append((service, flights, -1))
    active = defaultdict(Counter)
    curve = []
    by_service = {service: [] for service in sorted(set(membership.values()))}
    for day in range(horizon):
        # Both boundary event kinds happen before this day's value, so starts
        # are included and ends are excluded even when intervals meet.
        for service, flights, delta in events[day]:
            active[service][flights] += delta
            if active[service][flights] == 0:
                del active[service][flights]
            elif active[service][flights] < 0:
                raise ValueError('Unbalanced interval event')
        for service in by_service:
            by_service[service].append(max(active[service], default=0))
        curve.append(sum(by_service[service][-1] for service in by_service))
    return {
        'curve': curve,
        'total_flights': sum(curve),
        'peak_daily_flights': max(curve, default=0),
        'illustrative_cost_gbp': sum(curve) * unit_cost,
        'service_curves': by_service,
    }


def reference(challenge):
    case = challenge['source_facts']
    baseline = case['baseline_phases']
    extended = baseline + [case['extension']]
    horizon, unit_cost = case['horizon'], case['unit_cost_gbp']
    old_membership = {phase['id']: 'one_shared_service' for phase in extended}
    revised_membership = membership_index(challenge['revision']['service_membership'])
    if set(revised_membership) != {phase['id'] for phase in extended}:
        raise ValueError('Revised service assignments must cover exactly the source phases')
    control = challenge['harmless_control']['change']
    if control['field'] != 'name':
        raise ValueError('This reference supports a display-name-only control')
    controlled = []
    changed = False
    for phase in extended:
        copy = dict(phase)
        if phase['id'] == control['phase_id']:
            if phase['name'] != control['before']:
                raise ValueError('Control old name differs from frozen case')
            copy['name'] = control['after']
            changed = True
        controlled.append(copy)
    if not changed:
        raise ValueError('Control phase missing')
    args = (horizon, unit_cost)
    outputs = {
        'original_baseline': aggregate(baseline, old_membership, *args),
        'original_extension': aggregate(extended, old_membership, *args),
        'revised_baseline': aggregate(baseline, revised_membership, *args),
        'revised_extension': aggregate(extended, revised_membership, *args),
        'harmless_control_extension': aggregate(controlled, old_membership, *args),
    }
    return {
        'challenge_id': challenge['challenge_id'],
        'outputs': outputs,
        'historical_versus_applicable': {
            'historical_conditional': ['original_baseline', 'original_extension'],
            'currently_applicable': ['revised_baseline', 'revised_extension'],
            'control_branch_applicable': ['original_baseline', 'harmless_control_extension'],
            'reusable': ['individual phase facts and expanded curves',
                         'maximum envelope within a service',
                         'end-exclusive interval handling',
                         'illustrative constant-rate cost multiplication'],
            'not_directly_reusable': 'The old baseline aggregate contains E and is not the corrected common-site aggregate.',
        },
        'current_limits': challenge['standing_limits'] + [
            'No aggregation result here is asserted to constitute formal sheafification.'
        ],
    }


def check_numeric(candidate, expected):
    errors = []
    outputs = candidate.get('outputs', {})
    if not isinstance(outputs, dict):
        return ['outputs must be an object']
    for name in RESULT_NAMES:
        actual = outputs.get(name)
        if not isinstance(actual, dict):
            errors.append(f'Missing output object: {name}')
            continue
        for metric in METRICS:
            value = actual.get(metric)
            target = expected['outputs'][name][metric]
            well_typed = (
                isinstance(value, list) and all(type(n) is int for n in value)
                if metric == 'curve' else type(value) is int
            )
            if not well_typed or value != target:
                errors.append(f'{name}.{metric}: expected {target!r}, got {value!r}')
    return errors


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--challenge', type=Path,
                        default=Path(__file__).resolve().parents[1] / 'challenge.json')
    parser.add_argument('--candidate', type=Path)
    options = parser.parse_args()
    challenge = json.loads(options.challenge.read_text())
    result = reference(challenge)
    if options.candidate is None:
        print(json.dumps(result, indent=2))
        return 0
    candidate = json.loads(options.candidate.read_text())
    errors = check_numeric(candidate, result)
    print(json.dumps({
        'numeric_pass': not errors,
        'errors': errors,
        'not_checked': ['interpretation', 'provenance citations', 'historical versus applicable work',
                        'capacity/feasibility/authority limits', 'candidate source correctness'],
        'scope': 'A numeric pass is not a complete experiment pass.'
    }, indent=2))
    return int(bool(errors))


if __name__ == '__main__':
    sys.exit(main())
