"""Make one real OpenAI request; no retries, model fallback, or pipeline imports.

Run from the repository root:
    backend/.venv/bin/python backend/tools/prompt_measure/probe_gpt6_astra.py
    backend/.venv/bin/python backend/tools/prompt_measure/probe_gpt6_astra.py --api chat
"""

from __future__ import annotations

import argparse
import json
import os
import time
from datetime import datetime, timezone
from pathlib import Path

import httpx
from dotenv import load_dotenv
from openai import APIError, OpenAI

MODEL = "gpt-6-astra"
EXPECTED = "ASTRA_OK"
BACKEND = Path(__file__).resolve().parents[2]


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--api", choices=("responses", "chat"), default="responses")
    parser.add_argument("--key-slot", choices=("primary", "secondary"), default="primary")
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()

    load_dotenv(BACKEND / ".env", override=False)
    key_name = "OPENAI_API_KEY" if args.key_slot == "primary" else "OPENAI_API_KEY_SECONDARY"
    key = os.environ.get(key_name, "").strip()
    if not key:
        parser.error(f"{key_name} is not configured")

    requests: list[dict] = []

    def on_request(request: httpx.Request) -> None:
        requests.append({"method": request.method, "path": request.url.path})

    report = {
        "started_at": datetime.now(timezone.utc).isoformat(),
        "api": args.api,
        "base_url": "https://api.openai.com/v1",
        "requested_model": MODEL,
        "key_slot": args.key_slot,
        "sdk_max_retries": 0,
        "reasoning_effort": "low",
        "max_output_tokens": 256,
        "expected_output": EXPECTED,
        "ok": False,
    }
    started = time.monotonic()
    try:
        with OpenAI(
            api_key=key,
            base_url=report["base_url"],
            max_retries=0,
            timeout=60.0,
            http_client=httpx.Client(event_hooks={"request": [on_request]}),
        ) as client:
            prompt = f"This is an API connectivity test. Reply with exactly {EXPECTED} and nothing else."
            if args.api == "responses":
                raw = client.responses.with_raw_response.create(
                    model=MODEL,
                    input=prompt,
                    reasoning={"effort": "low"},
                    max_output_tokens=256,
                    store=False,
                )
                response = raw.parse()
                output = response.output_text.strip()
                completed = response.status == "completed"
                report["response_status"] = response.status
            else:
                raw = client.chat.completions.with_raw_response.create(
                    model=MODEL,
                    messages=[{"role": "user", "content": prompt}],
                    reasoning_effort="low",
                    max_completion_tokens=256,
                    store=False,
                )
                response = raw.parse()
                output = (response.choices[0].message.content or "").strip()
                completed = response.choices[0].finish_reason == "stop"
                report["finish_reason"] = response.choices[0].finish_reason
            report.update(
                http_status=raw.status_code,
                returned_model=response.model,
                response_id=response.id,
                request_id=raw.headers.get("x-request-id"),
                output=output,
                usage=response.usage.model_dump(mode="json") if response.usage else None,
                ok=completed and output == EXPECTED,
            )
    except APIError as exc:
        report.update(
            error_type=type(exc).__name__,
            http_status=getattr(exc, "status_code", None),
            request_id=getattr(exc, "request_id", None),
            error_code=getattr(exc, "code", None),
            error=str(exc).replace(key, "[REDACTED]"),
        )
    finally:
        report["elapsed_seconds"] = round(time.monotonic() - started, 3)
        report["http_attempts"] = requests
        report["http_attempt_count"] = len(requests)
        rendered = json.dumps(report, ensure_ascii=False, indent=2)
        if args.output:
            args.output.parent.mkdir(parents=True, exist_ok=True)
            args.output.write_text(rendered + "\n", encoding="utf-8")
        print(rendered)
    return 0 if report["ok"] else 1


if __name__ == "__main__":
    raise SystemExit(main())