"""Offline OpenRouter catalog transcription; never grants trial eligibility."""
import argparse
from decimal import Decimal, InvalidOperation
import hashlib
import json
from pathlib import Path

from .store import canonical, get

SOURCE = 'https://openrouter.ai/api/v1/models'


def review(root, capture_id, config):
    receipt = get(root, 'captures', capture_id)
    if receipt['url'] != SOURCE or receipt['final_url'] != SOURCE:
        raise ValueError('expected the OpenRouter public model catalog')
    raw = (Path(root) / 'data/artifacts' / receipt['content_sha256']).read_bytes()
    if hashlib.sha256(raw).hexdigest() != receipt['content_sha256']:
        raise ValueError('catalog artifact integrity mismatch')
    entries = json.loads(raw)['data']
    ids = [item['id'] for item in entries]
    if len(ids) != len(set(ids)):
        raise ValueError('ambiguous duplicate catalog model ID')
    configured = [item['id'] for item in config['models']]
    if len(configured) != len(set(configured)):
        raise ValueError('duplicate configured model ID')
    index = {item['id']: item for item in entries}
    rows = []
    for model in config['models']:
        item = index.get(model['id'])
        row = {'model_id': model['id'], 'listed': item is not None,
               'requester_access_verified': None, 'benchmark_comparability_verified': None}
        if item is not None:
            prices = {}
            for field in ('prompt', 'completion'):
                try:
                    rate = Decimal(str(item.get('pricing', {}).get(field))) * 1000000
                    cap = Decimal(str(model['max_usd_per_million'][field]))
                    if not rate.is_finite() or rate < 0 or not cap.is_finite() or cap < 0:
                        raise ValueError('nonfinite or negative price')
                except (InvalidOperation, ValueError, KeyError):
                    prices[field] = {'advertised_usd_per_million': None, 'within_configured_cap': None}
                else:
                    prices[field] = {'advertised_usd_per_million': str(rate),
                                     'within_configured_cap': rate <= cap}
            row.update(canonical_slug=item.get('canonical_slug'),
                       advertised_context_length=item.get('context_length'),
                       supported_parameters=item.get('supported_parameters', []),
                       base_prices=prices,
                       pricing_requires_endpoint_review=bool(item.get('pricing', {}).get('overrides')))
        rows.append(row)
    return {'schema_version': 1, 'kind': 'public_catalog_transcription',
            'capture_id': capture_id, 'artifact_sha256': receipt['content_sha256'],
            'observed_at': receipt['retrieved_at'],
            'config_sha256': hashlib.sha256(canonical(config)).hexdigest(),
            'campaign': config['campaign'], 'execution_authorized': False,
            'limitations': ['Catalog listing does not prove requester access or backend availability',
                            'Base prices exclude extra charges and do not guarantee routed endpoint prices',
                            'Canonical slug is provider metadata, not an immutable serving-weight attestation',
                            'This review supplies no benchmark score, calibration or spending authorization'],
            'models': rows}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--root', type=Path, default=Path.cwd())
    parser.add_argument('--capture', required=True)
    parser.add_argument('--config', type=Path, required=True)
    args = parser.parse_args()
    try:
        print(json.dumps(review(args.root, args.capture, json.loads(args.config.read_text())), indent=2))
    except (OSError, ValueError, KeyError, TypeError) as exc:
        parser.exit(1, f'Catalog review failed: {exc}\n')


if __name__ == '__main__':
    main()