import argparse
import asyncio
import json
from types import SimpleNamespace

import httpx

from arbi_serve.admin_console.targets import _openai_client, _probe_request
from arbi_serve.admin_console.vision_concurrency import _image_url, image_request

parser = argparse.ArgumentParser()
parser.add_argument('--arm', required=True)
args = parser.parse_args()
base = 'http://127.0.0.1:19094'
model = 'vision-quant-trial'

def prompt(index, repeats):
    return f'Run {index}. Read this passage.\n' + 'Memory capacity passage alpha beta gamma delta.\n' * repeats + '\nList the integers from 1 to 1000, one per line. Continue until the output limit.'

async def main():
    async with httpx.AsyncClient(base_url=base, timeout=180) as http:
        async def count(text):
            response = await http.post('/tokenize', json={'model':model,'messages':[{'role':'user','content':text}],'enable_thinking':False})
            response.raise_for_status()
            return response.json()['count']
        lo, hi = 0, 2000
        while lo + 1 < hi:
            mid = (lo + hi) // 2
            if await count(prompt(0, mid)) <= 12288:
                lo = mid
            else:
                hi = mid
        prompts = [prompt(i, lo) for i in range(8)]
        counts = [await count(text) for text in prompts]
        assert all(12000 <= n <= 12288 for n in counts), counts
        print(json.dumps({'test':'resolved_prompt_tokens','arm':args.arm,'counts':counts,'total':sum(counts)}), flush=True)
        before = (await http.get('/v1/admin/memory/live')).json()
        assert before['operator']['closes'] and not before['unresolved']
        events = [asyncio.Event() for _ in prompts]
        async with _openai_client(base, None, timeout=300) as client:
            async def text(index):
                async def create(**kwargs):
                    kwargs['seed'] = 42
                    kwargs['extra_body']['ignore_eos'] = True
                    events[index].set()
                    return await client.chat.completions.create(**kwargs)
                proxy = SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=create)))
                result = await _probe_request(proxy, base, model, prompts[index], max_tokens=512, prompt_tokens=counts[index], cache=False, sampler={'temperature':0,'enable_thinking':False})
                assert not result['error'] and result['tokens'] == 512, result
                assert result['prefill_steps'] >= 6, result
                return result
            tasks = [asyncio.create_task(text(i)) for i in range(8)]
            await asyncio.wait_for(asyncio.gather(*(event.wait() for event in events)), timeout=60)
            await asyncio.sleep(0.1)
            url, digest = _image_url(4096, 'long-prefill-reserve-proof')
            media = await image_request(client, SimpleNamespace(model=model,detail='high'), url)
            overlap = not all(task.done() for task in tasks)
            results = await asyncio.gather(*tasks)
            print(json.dumps({'test':'long_prefill_with_media','arm':args.arm,'image_sha256':digest,'media_returned_while_text_inflight':overlap,'texts':results,'image':media}), flush=True)
        after = (await http.get('/v1/admin/memory/live')).json()
        health = (await http.get('/health')).json()
        assert after['operator']['closes'] and not after['unresolved']
        assert health['status'] == 'ok' and not health.get('memory',{}).get('degraded',False)
        print(json.dumps({'test':'post_long_prefill_health','health':health,'kv_mapped':after['kv_mapped'],'ledger_closes':True}), flush=True)

asyncio.run(main())
