use std::{
    collections::BTreeMap,
    convert::Infallible,
    time::{SystemTime, UNIX_EPOCH},
};

use axum::{
    Json,
    body::to_bytes,
    extract::{Extension, Path, State, rejection::JsonRejection},
    http::{HeaderName, StatusCode, header},
    response::{
        IntoResponse, Response,
        sse::{Event, Sse},
    },
};
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
use module_assets::{
    AssetObjectAccessPolicy, AssetObjectFieldError, build_asset_entity_binding_input,
    build_asset_object_upsert_input, generate_asset_binding_id, generate_asset_object_id,
};
use module_square_hole::{
    SQUARE_HOLE_MESSAGE_ID_PREFIX, SQUARE_HOLE_PROFILE_ID_PREFIX, SQUARE_HOLE_RUN_ID_PREFIX,
    SQUARE_HOLE_SESSION_ID_PREFIX, default_background_prompt, normalize_hole_options,
    normalize_shape_options,
};
use platform_oss::{LegacyAssetPrefix, OssHeadObjectRequest, OssObjectAccess};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use shared_contracts::{
    square_hole_agent::{
        CreateSquareHoleSessionRequest, ExecuteSquareHoleActionRequest,
        SendSquareHoleMessageRequest, SquareHoleActionResponse, SquareHoleAgentMessageResponse,
        SquareHoleAnchorItemResponse, SquareHoleAnchorPackResponse,
        SquareHoleCreatorConfigResponse, SquareHoleHoleOptionResponse,
        SquareHoleResultDraftResponse, SquareHoleSessionResponse,
        SquareHoleSessionSnapshotResponse, SquareHoleShapeOptionResponse,
    },
    square_hole_runtime::{
        DropSquareHoleShapeRequest, SquareHoleDropFeedbackResponse, SquareHoleDropResponse,
        SquareHoleHoleSnapshotResponse, SquareHoleRunResponse, SquareHoleRunSnapshotResponse,
        SquareHoleShapeSnapshotResponse, StartSquareHoleRunRequest, StopSquareHoleRunRequest,
    },
    square_hole_works::{
        PutSquareHoleWorkRequest, RegenerateSquareHoleWorkImageRequest,
        SquareHoleHoleOptionResponse as SquareHoleWorkHoleOptionResponse,
        SquareHoleShapeOptionResponse as SquareHoleWorkShapeOptionResponse,
        SquareHoleWorkDetailResponse, SquareHoleWorkMutationResponse,
        SquareHoleWorkProfileResponse, SquareHoleWorkSummaryResponse, SquareHoleWorksResponse,
    },
};
use shared_kernel::build_prefixed_uuid_id;
use spacetime_client::{
    SpacetimeClientError, SquareHoleAgentMessageRecord, SquareHoleAgentMessageSubmitRecordInput,
    SquareHoleAgentSessionCreateRecordInput, SquareHoleAgentSessionRecord,
    SquareHoleAnchorItemRecord, SquareHoleAnchorPackRecord, SquareHoleCompileDraftRecordInput,
    SquareHoleCreatorConfigRecord, SquareHoleDropFeedbackRecord, SquareHoleHoleOptionRecord,
    SquareHoleHoleSnapshotRecord, SquareHoleResultDraftRecord, SquareHoleRunDropRecordInput,
    SquareHoleRunRecord, SquareHoleRunRestartRecordInput, SquareHoleRunStartRecordInput,
    SquareHoleRunStopRecordInput, SquareHoleRunTimeUpRecordInput, SquareHoleShapeOptionRecord,
    SquareHoleShapeSnapshotRecord, SquareHoleWorkProfileRecord, SquareHoleWorkUpdateRecordInput,
};

use crate::generated_image_assets::{
    GeneratedImageAssetAdapter, GeneratedImageAssetDataUrl,
    adapter::GeneratedImageAssetAdapterMetadata, adapter::GeneratedImageAssetPersistInput,
    normalize_generated_image_asset_mime,
};
use crate::{
    ai_generation_drafts::{AiGenerationDraftContext, AiGenerationDraftWriter},
    api_response::json_success_body,
    auth::AuthenticatedAccessToken,
    http_error::AppError,
    openai_image_generation::{
        DownloadedOpenAiImage, build_openai_image_http_client, create_openai_image_generation,
        require_openai_image_settings,
    },
    platform_errors::map_oss_error,
    request_context::RequestContext,
    square_hole_agent_turn::{
        SquareHoleAgentTurnRequest, build_finalize_record_input, run_square_hole_agent_turn,
    },
    state::AppState,
    work_play_tracking::{WorkPlayTrackingDraft, record_work_play_start_after_success},
};

const SQUARE_HOLE_AGENT_PROVIDER: &str = "square-hole-agent";
const SQUARE_HOLE_WORKS_PROVIDER: &str = "square-hole-works";
const SQUARE_HOLE_RUNTIME_PROVIDER: &str = "square-hole-runtime";
const SQUARE_HOLE_DEFAULT_THEME: &str = "纸箱";
const SQUARE_HOLE_DEFAULT_TWIST_RULE: &str = "方洞万能";
const SQUARE_HOLE_DEFAULT_SHAPE_COUNT: u32 = 12;
const SQUARE_HOLE_DEFAULT_DIFFICULTY: u32 = 4;
const SQUARE_HOLE_QUESTION_THEME: &str = "你想做什么题材";
const SQUARE_HOLE_ENTITY_KIND: &str = "square_hole_work";
const SQUARE_HOLE_COVER_IMAGE_KIND: &str = "square_hole_cover_image";
const SQUARE_HOLE_BACKGROUND_IMAGE_KIND: &str = "square_hole_background_image";
const SQUARE_HOLE_SHAPE_IMAGE_KIND: &str = "square_hole_shape_image";
const SQUARE_HOLE_HOLE_IMAGE_KIND: &str = "square_hole_hole_image";

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct SquareHoleConfigJson {
    theme_text: String,
    twist_rule: String,
    shape_count: u32,
    difficulty: u32,
    #[serde(default)]
    shape_options: Vec<SquareHoleConfigShapeOptionJson>,
    #[serde(default)]
    hole_options: Vec<SquareHoleConfigHoleOptionJson>,
    #[serde(default)]
    background_prompt: String,
    #[serde(default, deserialize_with = "deserialize_optional_string_as_default")]
    cover_image_src: String,
    #[serde(default, deserialize_with = "deserialize_optional_string_as_default")]
    background_image_src: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct SquareHoleConfigShapeOptionJson {
    option_id: String,
    shape_kind: String,
    label: String,
    #[serde(default)]
    target_hole_id: String,
    image_prompt: String,
    #[serde(default, deserialize_with = "deserialize_optional_string_as_default")]
    image_src: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct SquareHoleConfigHoleOptionJson {
    hole_id: String,
    hole_kind: String,
    label: String,
    #[serde(default)]
    image_prompt: String,
    #[serde(default, deserialize_with = "deserialize_optional_string_as_default")]
    image_src: String,
}

#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct CompileSquareHoleDraftRequest {
    #[serde(default)]
    game_name: Option<String>,
    #[serde(default)]
    summary: Option<String>,
    #[serde(default)]
    tags: Option<Vec<String>>,
    #[serde(default)]
    cover_image_src: Option<String>,
}

pub async fn create_square_hole_agent_session(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<CreateSquareHoleSessionRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_AGENT_PROVIDER)?;
    let config = build_config_from_create_request(&payload);
    let seed_text = build_seed_text(&payload, &config);
    let welcome_message_text = SQUARE_HOLE_QUESTION_THEME.to_string();

    let session = state
        .spacetime_client()
        .create_square_hole_agent_session(SquareHoleAgentSessionCreateRecordInput {
            session_id: build_prefixed_uuid_id(SQUARE_HOLE_SESSION_ID_PREFIX),
            owner_user_id: authenticated.claims().user_id().to_string(),
            seed_text,
            welcome_message_id: build_prefixed_uuid_id(SQUARE_HOLE_MESSAGE_ID_PREFIX),
            welcome_message_text,
            config_json: serialize_square_hole_config(&config),
            created_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleSessionResponse {
            session: map_square_hole_agent_session_response(session),
        },
    ))
}

pub async fn get_square_hole_agent_session(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &session_id,
        "sessionId",
    )?;

    let session = state
        .spacetime_client()
        .get_square_hole_agent_session(session_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleSessionResponse {
            session: map_square_hole_agent_session_response(session),
        },
    ))
}

pub async fn submit_square_hole_agent_message(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<SendSquareHoleMessageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_AGENT_PROVIDER)?;
    let session = submit_and_finalize_square_hole_message(
        &state,
        &request_context,
        authenticated.claims().user_id(),
        session_id,
        payload,
        |_| {},
    )
    .await?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleSessionResponse {
            session: map_square_hole_agent_session_response(session),
        },
    ))
}

pub async fn stream_square_hole_agent_message(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<SendSquareHoleMessageRequest>, JsonRejection>,
) -> Result<Response, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_AGENT_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &session_id,
        "sessionId",
    )?;

    let owner_user_id = authenticated.claims().user_id().to_string();
    let request_context_for_stream = request_context.clone();
    let state = state.clone();
    let stream = async_stream::stream! {
        let mut draft_writer = AiGenerationDraftWriter::new(AiGenerationDraftContext::new(
            "square-hole",
            owner_user_id.as_str(),
            session_id.as_str(),
            payload.client_message_id.as_str(),
            "方洞挑战生成草稿",
        ));
        if let Err(error) = draft_writer.ensure_started(state.spacetime_client()).await {
            tracing::warn!(error = %error, "方洞挑战生成草稿任务启动失败，主生成流程继续执行");
        }

        let (reply_tx, mut reply_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
        let result = {
            let run_turn = submit_and_finalize_square_hole_message(
                &state,
                &request_context_for_stream,
                owner_user_id.as_str(),
                session_id.clone(),
                payload,
                move |text| {
                    let _ = reply_tx.send(text.to_string());
                },
            );
            tokio::pin!(run_turn);

            loop {
                tokio::select! {
                    result = &mut run_turn => break result,
                    maybe_text = reply_rx.recv() => {
                        if let Some(text) = maybe_text {
                            draft_writer.persist_visible_text(state.spacetime_client(), text.as_str()).await;
                            yield Ok::<Event, Infallible>(square_hole_sse_json_event_or_error(
                                "reply_delta",
                                json!({ "text": text }),
                            ));
                        }
                    }
                }
            }
        };

        while let Some(text) = reply_rx.recv().await {
            draft_writer.persist_visible_text(state.spacetime_client(), text.as_str()).await;
            yield Ok::<Event, Infallible>(square_hole_sse_json_event_or_error(
                "reply_delta",
                json!({ "text": text }),
            ));
        }

        let session = match result {
            Ok(session) => session,
            Err(response) => {
                let message = extract_square_hole_response_error_message(response).await;
                yield Ok::<Event, Infallible>(square_hole_sse_json_event_or_error(
                    "error",
                    json!({ "message": message }),
                ));
                return;
            }
        };

        let session_response = map_square_hole_agent_session_response(session);
        yield Ok::<Event, Infallible>(square_hole_sse_json_event_or_error(
            "session",
            json!({ "session": session_response }),
        ));
        yield Ok::<Event, Infallible>(square_hole_sse_json_event_or_error(
            "done",
            json!({ "ok": true }),
        ));
    };

    Ok(Sse::new(stream).into_response())
}

pub async fn execute_square_hole_agent_action(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<ExecuteSquareHoleActionRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_AGENT_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &session_id,
        "sessionId",
    )?;

    let session = match payload.action.trim() {
        "square_hole_compile_draft" => {
            compile_square_hole_draft_for_session(
                &state,
                &request_context,
                &authenticated,
                session_id,
                payload.game_name,
                payload.summary,
                payload.tags,
                payload.cover_image_src,
            )
            .await?
        }
        "square_hole_generate_visual_assets" => {
            generate_square_hole_visual_assets_for_session(
                &state,
                &request_context,
                &authenticated,
                session_id,
                payload.regenerate_visual_assets.unwrap_or(false),
                payload.visual_asset_slot,
                payload.visual_asset_option_id,
            )
            .await?
        }
        _ => {
            return Err(square_hole_bad_request(
                &request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                "unknown square hole action",
            ));
        }
    };

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleActionResponse {
            session: map_square_hole_agent_session_response(session),
        },
    ))
}

pub async fn compile_square_hole_agent_draft(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<CompileSquareHoleDraftRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let payload = payload
        .map(|Json(payload)| payload)
        .unwrap_or(CompileSquareHoleDraftRequest {
            game_name: None,
            summary: None,
            tags: None,
            cover_image_src: None,
        });
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &session_id,
        "sessionId",
    )?;

    let session = compile_square_hole_draft_for_session(
        &state,
        &request_context,
        &authenticated,
        session_id,
        payload.game_name,
        payload.summary,
        payload.tags,
        payload.cover_image_src,
    )
    .await?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleActionResponse {
            session: map_square_hole_agent_session_response(session),
        },
    ))
}

pub async fn get_square_hole_works(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    let items = state
        .spacetime_client()
        .list_square_hole_works(authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorksResponse {
            items: items
                .into_iter()
                .map(map_square_hole_work_summary_response)
                .collect(),
        },
    ))
}

pub async fn list_square_hole_gallery(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
) -> Result<Json<Value>, Response> {
    let items = state
        .spacetime_client()
        .list_square_hole_gallery()
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorksResponse {
            items: items
                .into_iter()
                .map(map_square_hole_work_summary_response)
                .collect(),
        },
    ))
}

pub async fn get_square_hole_work_detail(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let item = state
        .spacetime_client()
        .get_square_hole_work_detail(profile_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorkDetailResponse {
            item: map_square_hole_work_profile_response(item),
        },
    ))
}

pub async fn put_square_hole_work(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<PutSquareHoleWorkRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let existing = state
        .spacetime_client()
        .get_square_hole_work_detail(
            profile_id.clone(),
            authenticated.claims().user_id().to_string(),
        )
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;
    let theme_text = payload
        .theme_text
        .clone()
        .filter(|value| !value.trim().is_empty())
        .unwrap_or(existing.theme_text);
    let hole_options = payload
        .hole_options
        .clone()
        .map(square_hole_work_hole_options_to_records)
        .unwrap_or_else(|| existing.hole_options.clone());
    let hole_options_json = serialize_square_hole_hole_option_records(&hole_options);
    let shape_options = payload
        .shape_options
        .clone()
        .map(|options| square_hole_work_shape_options_to_records(options, hole_options.as_slice()))
        .unwrap_or_else(|| existing.shape_options.clone());
    let shape_options_json = serialize_square_hole_shape_option_records(&shape_options);
    let item = state
        .spacetime_client()
        .update_square_hole_work(SquareHoleWorkUpdateRecordInput {
            profile_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            game_name: payload.game_name,
            theme_text,
            twist_rule: payload.twist_rule,
            summary_text: payload.summary,
            tags_json: serde_json::to_string(&normalize_tags(payload.tags)).unwrap_or_default(),
            cover_image_src: payload.cover_image_src.unwrap_or_default(),
            background_prompt: payload
                .background_prompt
                .filter(|value| !value.trim().is_empty())
                .unwrap_or(existing.background_prompt),
            background_image_src: payload
                .background_image_src
                .unwrap_or(existing.background_image_src.unwrap_or_default()),
            shape_options_json,
            hole_options_json,
            shape_count: payload.shape_count,
            difficulty: payload.difficulty,
            updated_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorkMutationResponse {
            item: map_square_hole_work_profile_response(item),
        },
    ))
}

pub async fn publish_square_hole_work(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let item = state
        .spacetime_client()
        .publish_square_hole_work(
            profile_id,
            authenticated.claims().user_id().to_string(),
            current_utc_micros(),
        )
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorkMutationResponse {
            item: map_square_hole_work_profile_response(item),
        },
    ))
}

pub async fn regenerate_square_hole_work_image(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<RegenerateSquareHoleWorkImageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let owner_user_id = authenticated.claims().user_id().to_string();
    let item = regenerate_square_hole_visual_asset_for_work(
        &state,
        &request_context,
        owner_user_id,
        profile_id,
        payload.visual_asset_slot,
        payload.visual_asset_option_id,
    )
    .await?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorkMutationResponse {
            item: map_square_hole_work_profile_response(item),
        },
    ))
}

pub async fn delete_square_hole_work(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let items = state
        .spacetime_client()
        .delete_square_hole_work(profile_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_WORKS_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleWorksResponse {
            items: items
                .into_iter()
                .map(map_square_hole_work_summary_response)
                .collect(),
        },
    ))
}

pub async fn start_square_hole_run(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<StartSquareHoleRunRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let maybe_payload = payload.ok().map(|Json(payload)| payload);
    let profile_id = maybe_payload
        .map(|payload| payload.profile_id)
        .filter(|value| !value.trim().is_empty())
        .unwrap_or(profile_id);
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let run = state
        .spacetime_client()
        .start_square_hole_run(SquareHoleRunStartRecordInput {
            run_id: build_prefixed_uuid_id(SQUARE_HOLE_RUN_ID_PREFIX),
            owner_user_id: authenticated.claims().user_id().to_string(),
            profile_id: profile_id.clone(),
            started_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_RUNTIME_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    record_work_play_start_after_success(
        &state,
        &request_context,
        WorkPlayTrackingDraft::new(
            "square-hole",
            profile_id.clone(),
            &authenticated,
            "/api/runtime/square-hole/...",
        )
        .profile_id(profile_id.clone())
        .extra(json!({
            "runId": run.run_id,
        })),
    )
    .await;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleRunResponse {
            run: map_square_hole_run_response(run),
        },
    ))
}

pub async fn get_square_hole_run(
    State(state): State<AppState>,
    Path(run_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &run_id,
        "runId",
    )?;

    let run = state
        .spacetime_client()
        .get_square_hole_run(run_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_RUNTIME_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleRunResponse {
            run: map_square_hole_run_response(run),
        },
    ))
}

pub async fn drop_square_hole_shape(
    State(state): State<AppState>,
    Path(run_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<DropSquareHoleShapeRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = square_hole_json(payload, &request_context, SQUARE_HOLE_RUNTIME_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &run_id,
        "runId",
    )?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &payload.hole_id,
        "holeId",
    )?;
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &payload.client_event_id,
        "clientEventId",
    )?;

    let confirmation = state
        .spacetime_client()
        .drop_square_hole_shape(SquareHoleRunDropRecordInput {
            run_id: payload.run_id.unwrap_or(run_id),
            owner_user_id: authenticated.claims().user_id().to_string(),
            hole_id: payload.hole_id,
            client_snapshot_version: payload.client_snapshot_version,
            client_event_id: payload.client_event_id,
            dropped_at_ms: payload.dropped_at_ms.min(i64::MAX as u64) as i64,
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_RUNTIME_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleDropResponse {
            feedback: map_square_hole_feedback_response(confirmation.feedback),
            run: map_square_hole_run_response(confirmation.run),
        },
    ))
}

pub async fn stop_square_hole_run(
    State(state): State<AppState>,
    Path(run_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<StopSquareHoleRunRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let _ = payload.ok();
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &run_id,
        "runId",
    )?;

    let run = state
        .spacetime_client()
        .stop_square_hole_run(SquareHoleRunStopRecordInput {
            run_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            stopped_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_RUNTIME_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleRunResponse {
            run: map_square_hole_run_response(run),
        },
    ))
}

pub async fn restart_square_hole_run(
    State(state): State<AppState>,
    Path(run_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &run_id,
        "runId",
    )?;

    let run = state
        .spacetime_client()
        .restart_square_hole_run(SquareHoleRunRestartRecordInput {
            source_run_id: run_id,
            next_run_id: build_prefixed_uuid_id(SQUARE_HOLE_RUN_ID_PREFIX),
            owner_user_id: authenticated.claims().user_id().to_string(),
            restarted_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_RUNTIME_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleRunResponse {
            run: map_square_hole_run_response(run),
        },
    ))
}

pub async fn finish_square_hole_time_up(
    State(state): State<AppState>,
    Path(run_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    ensure_non_empty(
        &request_context,
        SQUARE_HOLE_RUNTIME_PROVIDER,
        &run_id,
        "runId",
    )?;

    let run = state
        .spacetime_client()
        .finish_square_hole_time_up(SquareHoleRunTimeUpRecordInput {
            run_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            finished_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                &request_context,
                SQUARE_HOLE_RUNTIME_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        SquareHoleRunResponse {
            run: map_square_hole_run_response(run),
        },
    ))
}

async fn submit_and_finalize_square_hole_message(
    state: &AppState,
    request_context: &RequestContext,
    owner_user_id: &str,
    session_id: String,
    payload: SendSquareHoleMessageRequest,
    on_reply_update: impl FnMut(&str),
) -> Result<SquareHoleAgentSessionRecord, Response> {
    ensure_non_empty(
        request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &session_id,
        "sessionId",
    )?;
    ensure_non_empty(
        request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &payload.client_message_id,
        "clientMessageId",
    )?;
    ensure_non_empty(
        request_context,
        SQUARE_HOLE_AGENT_PROVIDER,
        &payload.text,
        "text",
    )?;

    let submitted = state
        .spacetime_client()
        .submit_square_hole_agent_message(SquareHoleAgentMessageSubmitRecordInput {
            session_id: session_id.clone(),
            owner_user_id: owner_user_id.to_string(),
            user_message_id: payload.client_message_id.clone(),
            user_message_text: payload.text.clone(),
            submitted_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;
    let turn_result = run_square_hole_agent_turn(
        SquareHoleAgentTurnRequest {
            llm_client: state.llm_client(),
            session: &submitted,
            quick_fill_requested: payload.quick_fill_requested.unwrap_or(false),
            enable_web_search: state.config.creation_agent_llm_web_search_enabled,
        },
        on_reply_update,
    )
    .await
    .map_err(|error| {
        square_hole_error_response(
            request_context,
            SQUARE_HOLE_AGENT_PROVIDER,
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": SQUARE_HOLE_AGENT_PROVIDER,
                "message": error.to_string(),
            })),
        )
    })?;

    let finalize_input = build_finalize_record_input(
        session_id,
        owner_user_id.to_string(),
        build_prefixed_uuid_id(SQUARE_HOLE_MESSAGE_ID_PREFIX),
        turn_result,
        current_utc_micros(),
    );

    state
        .spacetime_client()
        .finalize_square_hole_agent_message(finalize_input)
        .await
        .map_err(|error| {
            square_hole_error_response(
                request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                map_square_hole_client_error(error),
            )
        })
}

async fn compile_square_hole_draft_for_session(
    state: &AppState,
    request_context: &RequestContext,
    authenticated: &AuthenticatedAccessToken,
    session_id: String,
    game_name: Option<String>,
    summary: Option<String>,
    tags: Option<Vec<String>>,
    cover_image_src: Option<String>,
) -> Result<SquareHoleAgentSessionRecord, Response> {
    let owner_user_id = authenticated.claims().user_id().to_string();
    let session = state
        .spacetime_client()
        .get_square_hole_agent_session(session_id.clone(), owner_user_id.clone())
        .await
        .map_err(|error| {
            square_hole_error_response(
                request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                map_square_hole_client_error(error),
            )
        })?;
    if session.current_turn < 2 || session.progress_percent < 100 {
        return Err(square_hole_bad_request(
            request_context,
            SQUARE_HOLE_AGENT_PROVIDER,
            "square hole 创作配置尚未确认完成",
        ));
    }

    let config = resolve_config_or_default(Some(&session.config));
    let tags_json = tags
        .as_ref()
        .map(|tags| serde_json::to_string(&normalize_tags(tags.clone())).unwrap_or_default());

    state
        .spacetime_client()
        .compile_square_hole_draft(SquareHoleCompileDraftRecordInput {
            session_id,
            owner_user_id,
            profile_id: build_prefixed_uuid_id(SQUARE_HOLE_PROFILE_ID_PREFIX),
            author_display_name: resolve_author_display_name(state, authenticated),
            game_name: game_name.or_else(|| Some(format!("{}方洞挑战", config.theme_text))),
            summary_text: summary,
            tags_json,
            cover_image_src,
            compiled_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            square_hole_error_response(
                request_context,
                SQUARE_HOLE_AGENT_PROVIDER,
                map_square_hole_client_error(error),
            )
        })
}

mod visual_assets;

use visual_assets::{
    generate_square_hole_visual_assets_for_session, regenerate_square_hole_visual_asset_for_work,
};

mod mappers;

use mappers::*;

fn build_config_from_create_request(
    payload: &CreateSquareHoleSessionRequest,
) -> SquareHoleConfigJson {
    let theme_text = payload
        .theme_text
        .as_deref()
        .or(payload.seed_text.as_deref())
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .unwrap_or(SQUARE_HOLE_DEFAULT_THEME);
    let hole_options = normalize_hole_options(Vec::new(), theme_text);
    SquareHoleConfigJson {
        theme_text: theme_text.to_string(),
        twist_rule: payload
            .twist_rule
            .as_deref()
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .unwrap_or(SQUARE_HOLE_DEFAULT_TWIST_RULE)
            .to_string(),
        shape_count: payload
            .shape_count
            .unwrap_or(SQUARE_HOLE_DEFAULT_SHAPE_COUNT)
            .max(1),
        difficulty: payload
            .difficulty
            .unwrap_or(SQUARE_HOLE_DEFAULT_DIFFICULTY)
            .clamp(1, 10),
        shape_options: square_hole_shape_records_to_config_json(normalize_shape_options(
            Vec::new(),
            theme_text,
            hole_options.as_slice(),
        )),
        hole_options: square_hole_hole_records_to_config_json(hole_options),
        background_prompt: default_background_prompt(theme_text),
        cover_image_src: String::new(),
        background_image_src: String::new(),
    }
}

fn resolve_config_or_default(
    config: Option<&SquareHoleCreatorConfigRecord>,
) -> SquareHoleConfigJson {
    config
        .map(|config| SquareHoleConfigJson {
            theme_text: config.theme_text.clone(),
            twist_rule: config.twist_rule.clone(),
            shape_count: config.shape_count.max(1),
            difficulty: config.difficulty.clamp(1, 10),
            shape_options: square_hole_shape_records_to_config_json(config.shape_options.clone()),
            hole_options: square_hole_hole_records_to_config_json(config.hole_options.clone()),
            background_prompt: config.background_prompt.clone(),
            cover_image_src: config.cover_image_src.clone().unwrap_or_default(),
            background_image_src: config.background_image_src.clone().unwrap_or_default(),
        })
        .unwrap_or_else(|| SquareHoleConfigJson {
            theme_text: SQUARE_HOLE_DEFAULT_THEME.to_string(),
            twist_rule: SQUARE_HOLE_DEFAULT_TWIST_RULE.to_string(),
            shape_count: SQUARE_HOLE_DEFAULT_SHAPE_COUNT,
            difficulty: SQUARE_HOLE_DEFAULT_DIFFICULTY,
            shape_options: {
                let hole_options = normalize_hole_options(Vec::new(), SQUARE_HOLE_DEFAULT_THEME);
                square_hole_shape_records_to_config_json(normalize_shape_options(
                    Vec::new(),
                    SQUARE_HOLE_DEFAULT_THEME,
                    hole_options.as_slice(),
                ))
            },
            hole_options: square_hole_hole_records_to_config_json(normalize_hole_options(
                Vec::new(),
                SQUARE_HOLE_DEFAULT_THEME,
            )),
            background_prompt: default_background_prompt(SQUARE_HOLE_DEFAULT_THEME),
            cover_image_src: String::new(),
            background_image_src: String::new(),
        })
}

fn serialize_square_hole_config(config: &SquareHoleConfigJson) -> Option<String> {
    serde_json::to_string(config).ok()
}

fn deserialize_optional_string_as_default<'de, D>(deserializer: D) -> Result<String, D::Error>
where
    D: serde::Deserializer<'de>,
{
    Ok(Option::<String>::deserialize(deserializer)?.unwrap_or_default())
}

fn build_seed_text(
    payload: &CreateSquareHoleSessionRequest,
    config: &SquareHoleConfigJson,
) -> String {
    payload
        .seed_text
        .as_deref()
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(str::to_string)
        .unwrap_or_else(|| {
            format!(
                "{}题材，{}，{} 个形状，难度{}",
                config.theme_text, config.twist_rule, config.shape_count, config.difficulty
            )
        })
}

fn normalize_tags(tags: Vec<String>) -> Vec<String> {
    let mut result = Vec::new();
    for tag in tags {
        let trimmed = tag.trim();
        if !trimmed.is_empty() && !result.iter().any(|value| value == trimmed) {
            result.push(trimmed.to_string());
        }
        if result.len() >= 6 {
            break;
        }
    }
    result
}

fn square_hole_shape_records_to_config_json(
    options: Vec<impl Into<SquareHoleConfigShapeOptionJson>>,
) -> Vec<SquareHoleConfigShapeOptionJson> {
    options.into_iter().map(Into::into).collect()
}

fn square_hole_hole_records_to_config_json(
    options: Vec<impl Into<SquareHoleConfigHoleOptionJson>>,
) -> Vec<SquareHoleConfigHoleOptionJson> {
    options.into_iter().map(Into::into).collect()
}

fn square_hole_work_shape_options_to_records(
    options: Vec<SquareHoleWorkShapeOptionResponse>,
    hole_options: &[SquareHoleHoleOptionRecord],
) -> Vec<SquareHoleShapeOptionRecord> {
    let fallback_hole_id = hole_options
        .first()
        .map(|option| option.hole_id.clone())
        .unwrap_or_else(|| "hole-1".to_string());
    options
        .into_iter()
        .map(|option| SquareHoleShapeOptionRecord {
            option_id: option.option_id,
            shape_kind: option.shape_kind,
            label: option.label,
            target_hole_id: hole_options
                .iter()
                .find(|hole| hole.hole_id == option.target_hole_id)
                .map(|hole| hole.hole_id.clone())
                .unwrap_or_else(|| fallback_hole_id.clone()),
            image_prompt: option.image_prompt,
            image_src: option.image_src.filter(|value| !value.trim().is_empty()),
        })
        .collect()
}

fn square_hole_work_hole_options_to_records(
    options: Vec<SquareHoleWorkHoleOptionResponse>,
) -> Vec<SquareHoleHoleOptionRecord> {
    options
        .into_iter()
        .map(|option| SquareHoleHoleOptionRecord {
            hole_id: option.hole_id,
            hole_kind: option.hole_kind,
            label: option.label,
            image_prompt: option.image_prompt,
            image_src: option.image_src.filter(|value| !value.trim().is_empty()),
        })
        .collect()
}

fn serialize_square_hole_shape_option_records(options: &[SquareHoleShapeOptionRecord]) -> String {
    let json_options: Vec<SquareHoleConfigShapeOptionJson> =
        options.iter().cloned().map(Into::into).collect();
    serde_json::to_string(&json_options).unwrap_or_default()
}

fn serialize_square_hole_hole_option_records(options: &[SquareHoleHoleOptionRecord]) -> String {
    let json_options: Vec<SquareHoleConfigHoleOptionJson> =
        options.iter().cloned().map(Into::into).collect();
    serde_json::to_string(&json_options).unwrap_or_default()
}

fn clean_prompt_text(value: &str, fallback: &str) -> String {
    let cleaned = value
        .trim()
        .split_whitespace()
        .collect::<Vec<_>>()
        .join(" ");
    if cleaned.is_empty() {
        fallback.to_string()
    } else {
        cleaned.chars().take(180).collect()
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
enum SquareHoleVisualAssetSlotRequest {
    Cover,
    Background,
    Shape(String),
    Hole(String),
}

fn normalize_square_hole_visual_asset_slot(
    slot: Option<&str>,
    option_id: Option<&str>,
) -> Option<SquareHoleVisualAssetSlotRequest> {
    match slot.map(str::trim).unwrap_or_default() {
        "cover" => Some(SquareHoleVisualAssetSlotRequest::Cover),
        "background" => Some(SquareHoleVisualAssetSlotRequest::Background),
        "shape" => option_id
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .map(|value| SquareHoleVisualAssetSlotRequest::Shape(value.to_string())),
        "hole" => option_id
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .map(|value| SquareHoleVisualAssetSlotRequest::Hole(value.to_string())),
        _ => None,
    }
}

fn should_generate_square_hole_cover_image(
    requested_slot: Option<&SquareHoleVisualAssetSlotRequest>,
    regenerate_visual_assets: bool,
    current_image_src: &str,
) -> bool {
    matches!(
        requested_slot,
        Some(SquareHoleVisualAssetSlotRequest::Cover)
    ) || (requested_slot.is_none()
        && (regenerate_visual_assets || current_image_src.trim().is_empty()))
}

fn should_generate_square_hole_background_image(
    requested_slot: Option<&SquareHoleVisualAssetSlotRequest>,
    regenerate_visual_assets: bool,
    current_image_src: &str,
) -> bool {
    matches!(
        requested_slot,
        Some(SquareHoleVisualAssetSlotRequest::Background)
    ) || (requested_slot.is_none()
        && (regenerate_visual_assets || current_image_src.trim().is_empty()))
}

fn should_generate_square_hole_shape_image(
    requested_slot: Option<&SquareHoleVisualAssetSlotRequest>,
    regenerate_visual_assets: bool,
    option: &SquareHoleShapeOptionRecord,
) -> bool {
    match requested_slot {
        Some(SquareHoleVisualAssetSlotRequest::Shape(option_id)) => option.option_id == *option_id,
        Some(_) => false,
        None => {
            regenerate_visual_assets
                || option
                    .image_src
                    .as_deref()
                    .map(str::trim)
                    .filter(|value| !value.is_empty())
                    .is_none()
        }
    }
}

fn should_generate_square_hole_hole_image(
    requested_slot: Option<&SquareHoleVisualAssetSlotRequest>,
    regenerate_visual_assets: bool,
    option: &SquareHoleHoleOptionRecord,
) -> bool {
    match requested_slot {
        Some(SquareHoleVisualAssetSlotRequest::Hole(hole_id)) => option.hole_id == *hole_id,
        Some(_) => false,
        None => {
            regenerate_visual_assets
                || option
                    .image_src
                    .as_deref()
                    .map(str::trim)
                    .filter(|value| !value.is_empty())
                    .is_none()
        }
    }
}

impl From<module_square_hole::SquareHoleShapeOption> for SquareHoleConfigShapeOptionJson {
    fn from(option: module_square_hole::SquareHoleShapeOption) -> Self {
        Self {
            option_id: option.option_id,
            shape_kind: option.shape_kind,
            label: option.label,
            target_hole_id: option.target_hole_id,
            image_prompt: option.image_prompt,
            image_src: option.image_src.unwrap_or_default(),
        }
    }
}

impl From<SquareHoleShapeOptionRecord> for SquareHoleConfigShapeOptionJson {
    fn from(option: SquareHoleShapeOptionRecord) -> Self {
        Self {
            option_id: option.option_id,
            shape_kind: option.shape_kind,
            label: option.label,
            target_hole_id: option.target_hole_id,
            image_prompt: option.image_prompt,
            image_src: option.image_src.unwrap_or_default(),
        }
    }
}

impl From<module_square_hole::SquareHoleHoleOption> for SquareHoleConfigHoleOptionJson {
    fn from(option: module_square_hole::SquareHoleHoleOption) -> Self {
        Self {
            hole_id: option.hole_id,
            hole_kind: option.hole_kind,
            label: option.label,
            image_prompt: option.image_prompt,
            image_src: option.image_src.unwrap_or_default(),
        }
    }
}

impl From<SquareHoleHoleOptionRecord> for SquareHoleConfigHoleOptionJson {
    fn from(option: SquareHoleHoleOptionRecord) -> Self {
        Self {
            hole_id: option.hole_id,
            hole_kind: option.hole_kind,
            label: option.label,
            image_prompt: option.image_prompt,
            image_src: option.image_src.unwrap_or_default(),
        }
    }
}

fn resolve_author_display_name(
    state: &AppState,
    authenticated: &AuthenticatedAccessToken,
) -> String {
    state
        .auth_user_service()
        .get_user_by_id(authenticated.claims().user_id())
        .ok()
        .flatten()
        .map(|user| user.display_name)
        .filter(|value| !value.trim().is_empty())
        .unwrap_or_else(|| "玩家".to_string())
}

fn normalize_square_hole_run_status(value: &str) -> &str {
    match value {
        "Running" | "running" => "running",
        "Won" | "won" => "won",
        "Failed" | "failed" => "failed",
        "Stopped" | "stopped" => "stopped",
        _ => value,
    }
}

fn ensure_non_empty(
    request_context: &RequestContext,
    provider: &str,
    value: &str,
    field_name: &str,
) -> Result<(), Response> {
    if value.trim().is_empty() {
        return Err(square_hole_bad_request(
            request_context,
            provider,
            format!("{field_name} is required").as_str(),
        ));
    }
    Ok(())
}

fn square_hole_json<T>(
    payload: Result<Json<T>, JsonRejection>,
    request_context: &RequestContext,
    provider: &str,
) -> Result<Json<T>, Response> {
    payload.map_err(|error| {
        square_hole_error_response(
            request_context,
            provider,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": provider,
                "message": error.body_text(),
            })),
        )
    })
}

async fn extract_square_hole_response_error_message(response: Response) -> String {
    let status = response.status();
    let body = match to_bytes(response.into_body(), 64 * 1024).await {
        Ok(body) => body,
        Err(_) => return format!("方洞挑战生成失败：{status}"),
    };
    let body_text = String::from_utf8_lossy(&body).trim().to_string();
    if body_text.is_empty() {
        return format!("方洞挑战生成失败：{status}");
    }

    if let Ok(body_json) = serde_json::from_str::<Value>(&body_text)
        && let Some(message) = find_square_hole_error_message(&body_json)
    {
        return message;
    }

    body_text
}

fn find_square_hole_error_message(value: &Value) -> Option<String> {
    if let Some(message) = value
        .get("details")
        .and_then(|details| details.get("message"))
        .and_then(Value::as_str)
        .map(str::trim)
        .filter(|message| !message.is_empty())
    {
        return Some(message.to_string());
    }

    if let Some(message) = value
        .get("message")
        .and_then(Value::as_str)
        .map(str::trim)
        .filter(|message| !message.is_empty())
    {
        return Some(message.to_string());
    }

    match value {
        Value::Array(items) => items.iter().find_map(find_square_hole_error_message),
        Value::Object(object) => object.values().find_map(find_square_hole_error_message),
        _ => None,
    }
}

fn square_hole_bad_request(
    request_context: &RequestContext,
    provider: &str,
    message: &str,
) -> Response {
    square_hole_error_response(
        request_context,
        provider,
        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
            "provider": provider,
            "message": message,
        })),
    )
}

fn map_square_hole_client_error(error: SpacetimeClientError) -> AppError {
    let status = match &error {
        SpacetimeClientError::Runtime(_) => StatusCode::BAD_REQUEST,
        SpacetimeClientError::Procedure(message)
            if message.contains("不存在")
                || message.contains("not found")
                || message.contains("does not exist") =>
        {
            StatusCode::NOT_FOUND
        }
        SpacetimeClientError::Procedure(message)
            if message.contains("发布需要")
                || message.contains("不能为空")
                || message.contains("必须") =>
        {
            StatusCode::BAD_REQUEST
        }
        _ => StatusCode::BAD_GATEWAY,
    };

    AppError::from_status(status).with_details(json!({
        "provider": "spacetimedb",
        "message": error.to_string(),
    }))
}

fn square_hole_error_response(
    request_context: &RequestContext,
    provider: &str,
    error: AppError,
) -> Response {
    let mut response = error.into_response_with_context(Some(request_context));
    response.headers_mut().insert(
        HeaderName::from_static("x-genarrative-provider"),
        header::HeaderValue::from_str(provider)
            .unwrap_or_else(|_| header::HeaderValue::from_static("square-hole")),
    );
    response
}

fn square_hole_sse_json_event(event_name: &str, payload: Value) -> Result<Event, AppError> {
    Event::default()
        .event(event_name)
        .json_data(payload)
        .map_err(|error| {
            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
                "provider": "sse",
                "message": format!("SSE payload 序列化失败：{error}"),
            }))
        })
}

fn square_hole_sse_json_event_or_error(event_name: &str, payload: Value) -> Event {
    match square_hole_sse_json_event(event_name, payload) {
        Ok(event) => event,
        Err(error) => Event::default().event("error").data(format!("{error:?}")),
    }
}

fn current_utc_micros() -> i64 {
    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default();
    (duration.as_secs() as i64) * 1_000_000 + i64::from(duration.subsec_micros())
}

fn current_utc_ms() -> i64 {
    current_utc_micros().saturating_div(1000)
}