//! Shared reducer test fixtures.
//!
//! These helpers only write common trace scaffolding. Scenario-specific event
//! sequences stay in each test so the behavior under test remains visible.

use serde_json::json;
use tempfile::TempDir;

use crate::model::ToolCallSummary;
use crate::payload::RawPayloadKind;
use crate::payload::RawPayloadRef;
use crate::raw_event::RawTraceEventContext;
use crate::raw_event::RawTraceEventPayload;
use crate::replay_bundle;
use crate::writer::TraceWriter;

pub(crate) const ROOT_THREAD_ID: &str = "thread-root";
pub(crate) const AGENT_ROOT_THREAD_ID: &str = "019d0000-0000-7000-8000-000000000001";

pub(crate) fn message(role: &str, text: &str) -> serde_json::Value {
    json!({
        "type": "message",
        "role": role,
        "content": [{"type": "input_text", "text": text}]
    })
}

pub(crate) fn generic_summary(label: &str) -> ToolCallSummary {
    ToolCallSummary::Generic {
        label: label.to_string(),
        input_preview: None,
        output_preview: None,
    }
}

pub(crate) fn create_started_writer(temp: &TempDir) -> anyhow::Result<TraceWriter> {
    create_started_writer_for_thread(temp, ROOT_THREAD_ID, "/root")
}

pub(crate) fn create_started_agent_writer(temp: &TempDir) -> anyhow::Result<TraceWriter> {
    create_started_writer_for_thread(temp, AGENT_ROOT_THREAD_ID, "/root")
}

pub(crate) fn create_started_writer_for_thread(
    temp: &TempDir,
    thread_id: &str,
    agent_path: &str,
) -> anyhow::Result<TraceWriter> {
    let writer = TraceWriter::create(
        temp.path(),
        "trace-1".to_string(),
        "rollout-1".to_string(),
        thread_id.to_string(),
    )?;
    start_thread(&writer, thread_id, agent_path)?;
    Ok(writer)
}

pub(crate) fn start_thread(
    writer: &TraceWriter,
    thread_id: &str,
    agent_path: &str,
) -> anyhow::Result<()> {
    writer.append(RawTraceEventPayload::ThreadStarted {
        thread_id: thread_id.to_string(),
        agent_path: agent_path.to_string(),
        metadata_payload: None,
    })?;
    Ok(())
}

pub(crate) fn start_turn(writer: &TraceWriter, turn_id: &str) -> anyhow::Result<()> {
    start_turn_for_thread(writer, ROOT_THREAD_ID, turn_id)
}

pub(crate) fn start_agent_turn(writer: &TraceWriter, turn_id: &str) -> anyhow::Result<()> {
    start_turn_for_thread(writer, AGENT_ROOT_THREAD_ID, turn_id)
}

pub(crate) fn start_turn_for_thread(
    writer: &TraceWriter,
    thread_id: &str,
    turn_id: &str,
) -> anyhow::Result<()> {
    writer.append(RawTraceEventPayload::CodexTurnStarted {
        codex_turn_id: turn_id.to_string(),
        thread_id: thread_id.to_string(),
    })?;
    Ok(())
}

pub(crate) fn trace_context(turn_id: &str) -> RawTraceEventContext {
    trace_context_for_thread(ROOT_THREAD_ID, turn_id)
}

pub(crate) fn trace_context_for_agent(turn_id: &str) -> RawTraceEventContext {
    trace_context_for_thread(AGENT_ROOT_THREAD_ID, turn_id)
}

pub(crate) fn trace_context_for_thread(thread_id: &str, turn_id: &str) -> RawTraceEventContext {
    RawTraceEventContext {
        thread_id: Some(thread_id.to_string()),
        codex_turn_id: Some(turn_id.to_string()),
    }
}

pub(crate) fn append_inference_start(
    writer: &TraceWriter,
    inference_call_id: &str,
    codex_turn_id: &str,
    request_payload: RawPayloadRef,
) -> anyhow::Result<()> {
    append_inference_start_for_thread(
        writer,
        ROOT_THREAD_ID,
        codex_turn_id,
        inference_call_id,
        request_payload,
    )
}

pub(crate) fn append_inference_start_for_thread(
    writer: &TraceWriter,
    thread_id: &str,
    codex_turn_id: &str,
    inference_call_id: &str,
    request_payload: RawPayloadRef,
) -> anyhow::Result<()> {
    writer.append(RawTraceEventPayload::InferenceStarted {
        inference_call_id: inference_call_id.to_string(),
        thread_id: thread_id.to_string(),
        codex_turn_id: codex_turn_id.to_string(),
        model: "gpt-test".to_string(),
        provider_name: "test-provider".to_string(),
        request_payload,
    })?;
    Ok(())
}

pub(crate) fn append_inference_completion(
    writer: &TraceWriter,
    inference_call_id: &str,
    response_id: &str,
    response_payload: RawPayloadRef,
) -> anyhow::Result<()> {
    writer.append(RawTraceEventPayload::InferenceCompleted {
        inference_call_id: inference_call_id.to_string(),
        response_id: Some(response_id.to_string()),
        upstream_request_id: None,
        response_payload,
    })?;
    Ok(())
}

pub(crate) fn append_inference_request(
    writer: &TraceWriter,
    thread_id: &str,
    turn_id: &str,
    inference_id: &str,
    input: Vec<serde_json::Value>,
) -> anyhow::Result<()> {
    let request =
        writer.write_json_payload(RawPayloadKind::InferenceRequest, &json!({ "input": input }))?;
    append_inference_start_for_thread(writer, thread_id, turn_id, inference_id, request)
}

pub(crate) fn append_completed_inference(
    writer: &TraceWriter,
    thread_id: &str,
    turn_id: &str,
    inference_id: &str,
    input: Vec<serde_json::Value>,
    output_items: Vec<serde_json::Value>,
) -> anyhow::Result<()> {
    append_inference_request(writer, thread_id, turn_id, inference_id, input)?;
    let response = writer.write_json_payload(
        RawPayloadKind::InferenceResponse,
        &json!({
            "response_id": format!("resp-{inference_id}"),
            "output_items": output_items,
        }),
    )?;
    writer.append_with_context(
        trace_context_for_thread(thread_id, turn_id),
        RawTraceEventPayload::InferenceCompleted {
            inference_call_id: inference_id.to_string(),
            response_id: Some(format!("resp-{inference_id}")),
            upstream_request_id: None,
            response_payload: response,
        },
    )?;
    Ok(())
}

pub(crate) fn expect_replay_error(temp: &TempDir, expected: &str) -> anyhow::Result<()> {
    let Err(err) = replay_bundle(temp.path()) else {
        panic!("expected replay error containing {expected}");
    };
    let message = err.to_string();
    assert!(message.contains(expected), "unexpected error: {message}");
    Ok(())
}