"""Unmodified upstream SWE-Pruner inference behind a bounded private SSH pipe."""
import argparse
from contextlib import redirect_stdout
from hashlib import sha256
import importlib.metadata
import json
import os
from pathlib import Path
import sys
import time

REVISION = '863cee3198c715c9df1faa422a3490e0832bb734'
BACKBONE = 'e61197ed45024b0ed8a2d74b80b4d909f1255473'
ROOT = Path('/workspace/atmem-swe-pruner')


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--qualify', action='store_true')
    args = parser.parse_args()
    output = sys.stdout
    os.environ['HF_HOME'] = str(ROOT / 'hf')
    os.environ['HF_HUB_DISABLE_IMPLICIT_TOKEN'] = '1'
    tick = time.monotonic()
    with redirect_stdout(sys.stderr):
        from huggingface_hub import snapshot_download
        path = snapshot_download('ayanami-kitasan/code-pruner', revision=REVISION,
                                 local_dir=str(ROOT / 'model'), token=False)
        base = snapshot_download('Qwen/Qwen3-Reranker-0.6B', revision=BACKBONE,
                                 local_dir=str(ROOT / 'backbone-config'), allow_patterns=['config.json'], token=False)
        import torch
        from swe_pruner.configuration import SwePrunerConfig
        from swe_pruner.prune_wrapper import SwePrunerForCodePruning, PruneRequest
        if not torch.cuda.is_available():
            raise RuntimeError('qualified CUDA device required; no silent CPU fallback')
        config = SwePrunerConfig.from_pretrained(path, local_files_only=True,
            backbone_model_name_or_path=base, trust_remote_code=False)
        model = SwePrunerForCodePruning.from_pretrained(path, config=config, local_files_only=True)
        torch.cuda.synchronize()
        attention = model.model.backbone.config._attn_implementation
        if attention != 'flash_attention_2':
            raise RuntimeError('FlashAttention-2 did not activate; do not score an unqualified backend')
    metadata = {'model_revision': REVISION, 'backbone_config_revision': BACKBONE,
                'gpu': torch.cuda.get_device_name(), 'torch': torch.__version__,
                'dtype': str(next(model.parameters()).dtype), 'attention': attention,
                'package': importlib.metadata.version('swe-pruner'),
                'flash_attention': importlib.metadata.version('flash-attn'),
                'transformers': importlib.metadata.version('transformers'),
                'load_seconds': time.monotonic() - tick,
                'adaptations': [], 'threshold': 0.5}
    (ROOT / 'last-runtime.json').write_text(json.dumps(metadata, indent=2))

    def prune(request):
        if set(request) != {'query', 'code'} or not all(isinstance(v, str) for v in request.values()):
            raise ValueError('exact textual query and code required')
        if not 1 <= len(request['query']) <= 1000 or not 1 <= len(request['code'].encode()) <= 24000:
            raise ValueError('bounded nonempty query and source required')
        tick = time.monotonic()
        with redirect_stdout(sys.stderr):
            result = model.prune(PruneRequest(**request, threshold=0.5))
            torch.cuda.synchronize()
        elapsed = time.monotonic() - tick
        raw = result.model_dump()
        if result.error_msg:
            raise RuntimeError(result.error_msg)
        with (ROOT / 'inference-audit.jsonl').open('a') as audit:
            audit.write(json.dumps({'request': request, 'result': raw, 'seconds': elapsed,
                                    'runtime': metadata}) + '\n')
        return {key: raw[key] for key in ('pruned_code', 'kept_frags', 'origin_token_cnt',
                                          'left_token_cnt', 'model_input_token_cnt', 'score')} | {
            'seconds': elapsed, 'source_sha256': sha256(request['code'].encode()).hexdigest()}

    if args.qualify:
        cases = json.loads((ROOT / 'cases.json').read_text())
        trials = []
        for case in cases['cases']:
            trial = {'id': case['id'], **prune({'query': case['query'], 'code': case['code']})}
            trials.append(trial)
            print(json.dumps({'stage': 'qualified_case', 'id': case['id'], 'seconds': trial['seconds'],
                              'original_tokens': trial['origin_token_cnt'], 'remaining_tokens': trial['left_token_cnt']}),
                  file=output, flush=True)
        (ROOT / 'qualification.json').write_text(json.dumps({'runtime': metadata, 'cases': trials}, indent=2))
        return
    print(json.dumps({'status': 'ready', 'runtime': metadata}), file=output, flush=True)
    for line in sys.stdin:
        try:
            if len(line.encode()) > 50000:
                raise ValueError('request too large')
            response = prune(json.loads(line))
        except Exception as exc:
            response = {'error': type(exc).__name__ + ': ' + str(exc)}
        print(json.dumps(response), file=output, flush=True)


if __name__ == '__main__':
    main()