use axum::{
    Json,
    extract::{Extension, Path, State, rejection::JsonRejection},
    http::StatusCode,
    response::Response,
};
use module_custom_world::{
    CustomWorldThemeMode, empty_agent_anchor_content_json, empty_agent_asset_coverage_json,
    empty_agent_creator_intent_readiness_json, empty_json_array, empty_json_object,
};
use serde_json::{Map, Value, json};
use shared_contracts::runtime::{
    CreateCustomWorldAgentSessionRequest, CustomWorldAgentCardDetailResponse,
    CustomWorldAgentCheckpointResponse, CustomWorldAgentMessageResponse,
    CustomWorldAgentOperationResponse, CustomWorldAgentSessionResponse,
    CustomWorldAgentSessionSnapshotResponse, CustomWorldDraftCardDetailResponse,
    CustomWorldDraftCardDetailSectionResponse, CustomWorldDraftCardSummaryResponse,
    CustomWorldGalleryCardResponse, CustomWorldGalleryDetailResponse, CustomWorldGalleryResponse,
    CustomWorldLibraryEntryResponse, CustomWorldLibraryMutationResponse,
    CustomWorldLibraryResponse, CustomWorldProfileUpsertRequest, CustomWorldPublishGateResponse,
    CustomWorldResultPreviewBlockerResponse, CustomWorldSupportedActionResponse,
    CustomWorldWorkSummaryResponse, CustomWorldWorksResponse, ExecuteCustomWorldAgentActionRequest,
    SendCustomWorldAgentMessageRequest,
};
use shared_kernel::build_prefixed_uuid_id;
use spacetime_client::{
    CustomWorldAgentActionExecuteRecordInput, CustomWorldAgentCheckpointRecord,
    CustomWorldAgentMessageRecord, CustomWorldAgentMessageSubmitRecordInput,
    CustomWorldAgentOperationRecord, CustomWorldAgentSessionCreateRecordInput,
    CustomWorldAgentSessionRecord, CustomWorldDraftCardDetailRecord,
    CustomWorldDraftCardDetailSectionRecord, CustomWorldDraftCardRecord,
    CustomWorldGalleryEntryRecord, CustomWorldLibraryEntryRecord,
    CustomWorldProfileUpsertRecordInput, CustomWorldPublishGateRecord,
    CustomWorldResultPreviewBlockerRecord, CustomWorldSupportedActionRecord,
    CustomWorldWorkSummaryRecord, SpacetimeClientError,
};

use crate::{
    api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
    request_context::RequestContext, sse::SseEventBuffer, state::AppState,
};

pub async fn get_custom_world_library(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    let owner_user_id = authenticated.claims().user_id().to_string();
    let entries = state
        .spacetime_client()
        .list_custom_world_profiles(owner_user_id)
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldLibraryResponse {
            entries: entries
                .into_iter()
                .map(map_custom_world_library_entry_response)
                .collect(),
        },
    ))
}

pub async fn get_custom_world_library_detail(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    Path(profile_id): Path<String>,
) -> Result<Json<Value>, Response> {
    if profile_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-library",
                "message": "profileId is required",
            })),
        ));
    }

    let detail = state
        .spacetime_client()
        .get_custom_world_library_detail(authenticated.claims().user_id().to_string(), profile_id)
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldGalleryDetailResponse {
            entry: map_custom_world_library_entry_response(detail.entry),
        },
    ))
}

pub async fn put_custom_world_library_profile(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    Path(profile_id): Path<String>,
    payload: Result<Json<CustomWorldProfileUpsertRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = payload.map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-library",
                "message": error.body_text(),
            })),
        )
    })?;

    let owner_user_id = authenticated.claims().user_id().to_string();
    if profile_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-library",
                "message": "profileId is required",
            })),
        ));
    }

    let metadata = extract_custom_world_metadata(&payload.profile).map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-library",
                "message": error,
            })),
        )
    })?;
    let author_display_name = resolve_author_display_name(&authenticated);
    let mutation = state
        .spacetime_client()
        .upsert_custom_world_profile(CustomWorldProfileUpsertRecordInput {
            profile_id: profile_id.clone(),
            owner_user_id: owner_user_id.clone(),
            source_agent_session_id: None,
            world_name: metadata.world_name,
            subtitle: metadata.subtitle,
            summary_text: metadata.summary_text,
            theme_mode: metadata.theme_mode,
            cover_image_src: metadata.cover_image_src,
            profile_payload_json: serde_json::to_string(&payload.profile).map_err(|error| {
                custom_world_error_response(
                    &request_context,
                    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                        "provider": "custom-world-library",
                        "message": format!("profile JSON 序列化失败：{error}"),
                    })),
                )
            })?,
            playable_npc_count: metadata.playable_npc_count,
            landmark_count: metadata.landmark_count,
            author_display_name,
            updated_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldLibraryMutationResponse {
            entry: map_custom_world_library_entry_response(mutation.entry.clone()),
            entries: vec![map_custom_world_library_entry_response(mutation.entry)],
        },
    ))
}

pub async fn publish_custom_world_library_profile(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    Path(profile_id): Path<String>,
) -> Result<Json<Value>, Response> {
    let owner_user_id = authenticated.claims().user_id().to_string();
    if profile_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-library",
                "message": "profileId is required",
            })),
        ));
    }

    let mutation = state
        .spacetime_client()
        .publish_custom_world_profile(
            profile_id,
            owner_user_id,
            resolve_author_display_name(&authenticated),
            current_utc_micros(),
        )
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldLibraryMutationResponse {
            entry: map_custom_world_library_entry_response(mutation.entry.clone()),
            entries: vec![map_custom_world_library_entry_response(mutation.entry)],
        },
    ))
}

pub async fn unpublish_custom_world_library_profile(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    Path(profile_id): Path<String>,
) -> Result<Json<Value>, Response> {
    let owner_user_id = authenticated.claims().user_id().to_string();
    if profile_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-library",
                "message": "profileId is required",
            })),
        ));
    }

    let mutation = state
        .spacetime_client()
        .unpublish_custom_world_profile(
            profile_id,
            owner_user_id,
            resolve_author_display_name(&authenticated),
            current_utc_micros(),
        )
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldLibraryMutationResponse {
            entry: map_custom_world_library_entry_response(mutation.entry.clone()),
            entries: vec![map_custom_world_library_entry_response(mutation.entry)],
        },
    ))
}

pub async fn list_custom_world_gallery(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
) -> Result<Json<Value>, Response> {
    let entries = state
        .spacetime_client()
        .list_custom_world_gallery_entries()
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldGalleryResponse {
            entries: entries
                .into_iter()
                .map(map_custom_world_gallery_card_response)
                .collect(),
        },
    ))
}

pub async fn get_custom_world_gallery_detail(
    State(state): State<AppState>,
    Path((owner_user_id, profile_id)): Path<(String, String)>,
    Extension(request_context): Extension<RequestContext>,
) -> Result<Json<Value>, Response> {
    if owner_user_id.trim().is_empty() || profile_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-gallery",
                "message": "ownerUserId and profileId are required",
            })),
        ));
    }

    let detail = state
        .spacetime_client()
        .get_custom_world_gallery_detail(owner_user_id, profile_id)
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldGalleryDetailResponse {
            entry: map_custom_world_library_entry_response(detail.entry),
        },
    ))
}

pub async fn create_custom_world_agent_session(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<CreateCustomWorldAgentSessionRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = payload.map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": error.body_text(),
            })),
        )
    })?;

    let seed_text = payload.seed_text.unwrap_or_default().trim().to_string();
    let welcome_message_text = build_custom_world_agent_welcome_text(&seed_text);
    let session = state
        .spacetime_client()
        .create_custom_world_agent_session(CustomWorldAgentSessionCreateRecordInput {
            session_id: build_prefixed_uuid_id("custom-world-agent-session-"),
            owner_user_id: authenticated.claims().user_id().to_string(),
            seed_text,
            welcome_message_id: build_prefixed_uuid_id("message-"),
            welcome_message_text,
            anchor_content_json: empty_agent_anchor_content_json(),
            creator_intent_json: Some(empty_json_object()),
            creator_intent_readiness_json: empty_agent_creator_intent_readiness_json(),
            anchor_pack_json: Some(empty_json_object()),
            lock_state_json: Some(empty_json_object()),
            draft_profile_json: Some(empty_json_object()),
            pending_clarifications_json: empty_json_array(),
            suggested_actions_json: empty_json_array(),
            recommended_replies_json: empty_json_array(),
            quality_findings_json: empty_json_array(),
            asset_coverage_json: empty_agent_asset_coverage_json(),
            checkpoints_json: empty_json_array(),
            created_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldAgentSessionResponse {
            session: map_custom_world_agent_session_response(session),
        },
    ))
}

pub async fn get_custom_world_agent_session(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    if session_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "sessionId is required",
            })),
        ));
    }

    let session = state
        .spacetime_client()
        .get_custom_world_agent_session(session_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        map_custom_world_agent_session_response(session),
    ))
}

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

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

pub async fn get_custom_world_agent_card_detail(
    State(state): State<AppState>,
    Path((session_id, card_id)): Path<(String, String)>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    if session_id.trim().is_empty() || card_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "sessionId and cardId are required",
            })),
        ));
    }

    let card = state
        .spacetime_client()
        .get_custom_world_agent_card_detail(
            session_id,
            authenticated.claims().user_id().to_string(),
            card_id,
        )
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        CustomWorldAgentCardDetailResponse {
            card: map_custom_world_draft_card_detail_response(card),
        },
    ))
}

pub async fn submit_custom_world_agent_message(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<SendCustomWorldAgentMessageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = payload.map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": error.body_text(),
            })),
        )
    })?;

    if session_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "sessionId is required",
            })),
        ));
    }

    let client_message_id = payload.client_message_id.trim().to_string();
    let message_text = payload.text.trim().to_string();
    if client_message_id.is_empty() || message_text.is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "clientMessageId and text are required",
            })),
        ));
    }

    let operation = state
        .spacetime_client()
        .submit_custom_world_agent_message(CustomWorldAgentMessageSubmitRecordInput {
            session_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            user_message_id: client_message_id,
            user_message_text: message_text,
            operation_id: build_prefixed_uuid_id("operation-"),
            submitted_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        json!({
            "operation": map_custom_world_agent_operation_response(operation),
        }),
    ))
}

pub async fn stream_custom_world_agent_message(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<SendCustomWorldAgentMessageRequest>, JsonRejection>,
) -> Result<Response, Response> {
    let Json(payload) = payload.map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": error.body_text(),
            })),
        )
    })?;

    if session_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "sessionId is required",
            })),
        ));
    }

    let client_message_id = payload.client_message_id.trim().to_string();
    let message_text = payload.text.trim().to_string();
    if client_message_id.is_empty() || message_text.is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "clientMessageId and text are required",
            })),
        ));
    }

    let owner_user_id = authenticated.claims().user_id().to_string();
    state
        .spacetime_client()
        .submit_custom_world_agent_message(CustomWorldAgentMessageSubmitRecordInput {
            session_id: session_id.clone(),
            owner_user_id: owner_user_id.clone(),
            user_message_id: client_message_id,
            user_message_text: message_text,
            operation_id: build_prefixed_uuid_id("operation-"),
            submitted_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    let session = state
        .spacetime_client()
        .get_custom_world_agent_session(session_id, owner_user_id)
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;
    let session_response = map_custom_world_agent_session_response(session);
    let reply_text = resolve_stream_reply_text(&session_response);

    // 这里先用“一次性构造完整 SSE 文本”的最小兼容方案，
    // 复用 Stage 7 的同步 deterministic 写表逻辑，保证前端当前的 reader 协议可直接消费。
    let mut sse = SseEventBuffer::new();
    sse.push_json("reply_delta", &json!({ "text": reply_text }))
        .map_err(|error| custom_world_error_response(&request_context, error))?;
    sse.push_json("session", &json!({ "session": session_response }))
        .map_err(|error| custom_world_error_response(&request_context, error))?;
    sse.push_json("done", &json!({ "ok": true }))
        .map_err(|error| custom_world_error_response(&request_context, error))?;

    Ok(sse.into_response())
}

pub async fn get_custom_world_agent_operation(
    State(state): State<AppState>,
    Path((session_id, operation_id)): Path<(String, String)>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
) -> Result<Json<Value>, Response> {
    if session_id.trim().is_empty() || operation_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "sessionId and operationId are required",
            })),
        ));
    }

    let operation = state
        .spacetime_client()
        .get_custom_world_agent_operation(
            session_id,
            authenticated.claims().user_id().to_string(),
            operation_id,
        )
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        map_custom_world_agent_operation_response(operation),
    ))
}

pub async fn execute_custom_world_agent_action(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<ExecuteCustomWorldAgentActionRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = payload.map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": error.body_text(),
            })),
        )
    })?;

    if session_id.trim().is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "sessionId is required",
            })),
        ));
    }

    let action = payload.action.trim().to_string();
    if action.is_empty() {
        return Err(custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": "action is required",
            })),
        ));
    }

    let payload_json = serde_json::to_string(&payload).map_err(|error| {
        custom_world_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "custom-world-agent",
                "message": format!("action payload JSON 序列化失败：{error}"),
            })),
        )
    })?;

    let result = state
        .spacetime_client()
        .execute_custom_world_agent_action(CustomWorldAgentActionExecuteRecordInput {
            session_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            operation_id: build_prefixed_uuid_id("operation-"),
            action,
            payload_json: Some(payload_json),
            submitted_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            custom_world_error_response(&request_context, map_custom_world_client_error(error))
        })?;

    Ok(json_success_body(
        Some(&request_context),
        json!({
            "operation": map_custom_world_agent_operation_response(result.operation),
        }),
    ))
}

fn map_custom_world_library_entry_response(
    entry: CustomWorldLibraryEntryRecord,
) -> CustomWorldLibraryEntryResponse {
    CustomWorldLibraryEntryResponse {
        owner_user_id: entry.owner_user_id,
        profile_id: entry.profile_id,
        profile: entry.profile,
        visibility: entry.visibility,
        published_at: entry.published_at,
        updated_at: entry.updated_at,
        author_display_name: entry.author_display_name,
        world_name: entry.world_name,
        subtitle: entry.subtitle,
        summary_text: entry.summary_text,
        cover_image_src: entry.cover_image_src,
        theme_mode: entry.theme_mode,
        playable_npc_count: entry.playable_npc_count,
        landmark_count: entry.landmark_count,
    }
}

fn map_custom_world_gallery_card_response(
    entry: CustomWorldGalleryEntryRecord,
) -> CustomWorldGalleryCardResponse {
    CustomWorldGalleryCardResponse {
        owner_user_id: entry.owner_user_id,
        profile_id: entry.profile_id,
        visibility: entry.visibility,
        published_at: entry.published_at,
        updated_at: entry.updated_at,
        author_display_name: entry.author_display_name,
        world_name: entry.world_name,
        subtitle: entry.subtitle,
        summary_text: entry.summary_text,
        cover_image_src: entry.cover_image_src,
        theme_mode: entry.theme_mode,
        playable_npc_count: entry.playable_npc_count,
        landmark_count: entry.landmark_count,
    }
}

fn map_custom_world_work_summary_response(
    item: CustomWorldWorkSummaryRecord,
) -> CustomWorldWorkSummaryResponse {
    CustomWorldWorkSummaryResponse {
        work_id: item.work_id,
        source_type: item.source_type,
        status: item.status,
        title: item.title,
        subtitle: item.subtitle,
        summary: item.summary,
        cover_image_src: item.cover_image_src,
        cover_render_mode: item.cover_render_mode,
        cover_character_image_srcs: item.cover_character_image_srcs,
        updated_at: item.updated_at,
        published_at: item.published_at,
        stage: item.stage,
        stage_label: item.stage_label,
        playable_npc_count: item.playable_npc_count,
        landmark_count: item.landmark_count,
        role_visual_ready_count: item.role_visual_ready_count,
        role_animation_ready_count: item.role_animation_ready_count,
        role_asset_summary_label: item.role_asset_summary_label,
        session_id: item.session_id,
        profile_id: item.profile_id,
        can_resume: item.can_resume,
        can_enter_world: item.can_enter_world,
        blocker_count: item.blocker_count,
        publish_ready: item.publish_ready,
    }
}

fn map_custom_world_agent_session_response(
    session: CustomWorldAgentSessionRecord,
) -> CustomWorldAgentSessionSnapshotResponse {
    CustomWorldAgentSessionSnapshotResponse {
        session_id: session.session_id,
        current_turn: session.current_turn,
        anchor_content: session.anchor_content,
        progress_percent: session.progress_percent,
        last_assistant_reply: session.last_assistant_reply,
        stage: session.stage,
        focus_card_id: session.focus_card_id,
        creator_intent: session.creator_intent,
        creator_intent_readiness: session.creator_intent_readiness,
        anchor_pack: session.anchor_pack,
        lock_state: session.lock_state,
        draft_profile: session.draft_profile,
        messages: session
            .messages
            .into_iter()
            .map(map_custom_world_agent_message_response)
            .collect(),
        draft_cards: session
            .draft_cards
            .into_iter()
            .map(map_custom_world_draft_card_response)
            .collect(),
        pending_clarifications: session.pending_clarifications,
        suggested_actions: session.suggested_actions,
        recommended_replies: session.recommended_replies,
        quality_findings: session.quality_findings,
        asset_coverage: session.asset_coverage,
        checkpoints: session
            .checkpoints
            .into_iter()
            .map(map_custom_world_agent_checkpoint_response)
            .collect(),
        supported_actions: session
            .supported_actions
            .into_iter()
            .map(map_custom_world_supported_action_response)
            .collect(),
        publish_gate: session
            .publish_gate
            .map(map_custom_world_publish_gate_response),
        result_preview: session.result_preview,
        updated_at: session.updated_at,
    }
}

fn map_custom_world_publish_gate_response(
    gate: CustomWorldPublishGateRecord,
) -> CustomWorldPublishGateResponse {
    CustomWorldPublishGateResponse {
        profile_id: gate.profile_id,
        blockers: gate
            .blockers
            .into_iter()
            .map(map_custom_world_result_preview_blocker_response)
            .collect(),
        blocker_count: gate.blocker_count,
        publish_ready: gate.publish_ready,
        can_enter_world: gate.can_enter_world,
    }
}

fn map_custom_world_agent_message_response(
    message: CustomWorldAgentMessageRecord,
) -> CustomWorldAgentMessageResponse {
    CustomWorldAgentMessageResponse {
        id: message.message_id,
        role: message.role,
        kind: message.kind,
        text: message.text,
        created_at: message.created_at,
        related_operation_id: message.related_operation_id,
    }
}

fn map_custom_world_agent_operation_response(
    operation: CustomWorldAgentOperationRecord,
) -> CustomWorldAgentOperationResponse {
    CustomWorldAgentOperationResponse {
        operation_id: operation.operation_id,
        operation_type: operation.operation_type,
        status: operation.status,
        phase_label: operation.phase_label,
        phase_detail: operation.phase_detail,
        progress: operation.progress,
        error: operation.error_message,
    }
}

fn map_custom_world_draft_card_response(
    card: CustomWorldDraftCardRecord,
) -> CustomWorldDraftCardSummaryResponse {
    CustomWorldDraftCardSummaryResponse {
        id: card.card_id,
        kind: card.kind,
        title: card.title,
        subtitle: card.subtitle,
        summary: card.summary,
        status: card.status,
        linked_ids: card.linked_ids,
        warning_count: card.warning_count,
        asset_status: card.asset_status,
        asset_status_label: card.asset_status_label,
    }
}

fn map_custom_world_draft_card_detail_response(
    card: CustomWorldDraftCardDetailRecord,
) -> CustomWorldDraftCardDetailResponse {
    CustomWorldDraftCardDetailResponse {
        id: card.card_id,
        kind: card.kind,
        title: card.title,
        sections: card
            .sections
            .into_iter()
            .map(map_custom_world_draft_card_detail_section_response)
            .collect(),
        linked_ids: card.linked_ids,
        locked: card.locked,
        editable: card.editable,
        editable_section_ids: card.editable_section_ids,
        warning_messages: card.warning_messages,
        asset_status: card.asset_status,
        asset_status_label: card.asset_status_label,
    }
}

fn map_custom_world_draft_card_detail_section_response(
    section: CustomWorldDraftCardDetailSectionRecord,
) -> CustomWorldDraftCardDetailSectionResponse {
    CustomWorldDraftCardDetailSectionResponse {
        id: section.section_id,
        label: section.label,
        value: section.value,
    }
}

fn map_custom_world_agent_checkpoint_response(
    checkpoint: CustomWorldAgentCheckpointRecord,
) -> CustomWorldAgentCheckpointResponse {
    CustomWorldAgentCheckpointResponse {
        checkpoint_id: checkpoint.checkpoint_id,
        created_at: checkpoint.created_at,
        label: checkpoint.label,
    }
}

fn map_custom_world_supported_action_response(
    action: CustomWorldSupportedActionRecord,
) -> CustomWorldSupportedActionResponse {
    CustomWorldSupportedActionResponse {
        action: action.action,
        enabled: action.enabled,
        reason: action.reason,
    }
}

fn map_custom_world_result_preview_blocker_response(
    blocker: CustomWorldResultPreviewBlockerRecord,
) -> CustomWorldResultPreviewBlockerResponse {
    CustomWorldResultPreviewBlockerResponse {
        id: blocker.id,
        code: blocker.code,
        message: blocker.message,
    }
}

fn resolve_stream_reply_text(session: &CustomWorldAgentSessionSnapshotResponse) -> String {
    session
        .last_assistant_reply
        .clone()
        .or_else(|| {
            session
                .messages
                .iter()
                .rev()
                .find(|message| message.role == "assistant")
                .map(|message| message.text.clone())
        })
        .unwrap_or_default()
}

fn map_custom_world_client_error(error: SpacetimeClientError) -> AppError {
    let status = match &error {
        SpacetimeClientError::Procedure(message)
            if message.contains("custom_world_profile 不存在") =>
        {
            StatusCode::NOT_FOUND
        }
        SpacetimeClientError::Procedure(message)
            if message.contains("custom_world_agent_session 不存在") =>
        {
            StatusCode::NOT_FOUND
        }
        SpacetimeClientError::Procedure(message)
            if message.contains("custom_world_agent_operation 不存在") =>
        {
            StatusCode::NOT_FOUND
        }
        SpacetimeClientError::Runtime(_) => StatusCode::BAD_REQUEST,
        _ => StatusCode::BAD_GATEWAY,
    };

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

fn custom_world_error_response(request_context: &RequestContext, error: AppError) -> Response {
    error.into_response_with_context(Some(request_context))
}

fn resolve_author_display_name(_authenticated: &AuthenticatedAccessToken) -> String {
    "玩家".to_string()
}

fn build_custom_world_agent_welcome_text(seed_text: &str) -> String {
    if seed_text.trim().is_empty() {
        return "我会先帮你把世界的核心锚点整理出来。你可以从世界钩子、玩家身份、主题氛围、核心冲突、关键关系或标志性元素开始。"
            .to_string();
    }

    "我已经收到你的世界起点，会先把它整理成创作锚点。你可以继续补充玩家身份、核心冲突、关键关系或标志性元素。".to_string()
}

struct CustomWorldProfileMetadata {
    world_name: String,
    subtitle: String,
    summary_text: String,
    cover_image_src: Option<String>,
    theme_mode: CustomWorldThemeMode,
    playable_npc_count: u32,
    landmark_count: u32,
}

fn extract_custom_world_metadata(profile: &Value) -> Result<CustomWorldProfileMetadata, String> {
    let object = profile
        .as_object()
        .ok_or_else(|| "profile 必须是 JSON object".to_string())?;

    let world_name = read_string_field(object, "name").unwrap_or_else(|| "未命名世界".to_string());
    let subtitle = read_string_field(object, "subtitle").unwrap_or_default();
    let summary_text = read_string_field(object, "summary").unwrap_or_default();
    let cover_image_src = resolve_cover_image_src(object);
    let theme_mode = read_string_field(object, "themeMode")
        .and_then(|value| CustomWorldThemeMode::from_client_str(&value))
        .unwrap_or(CustomWorldThemeMode::Mythic);
    let playable_npc_count = count_profile_roles(object);
    let landmark_count = object
        .get("landmarks")
        .and_then(Value::as_array)
        .map(|entries| entries.len() as u32)
        .unwrap_or(0);

    Ok(CustomWorldProfileMetadata {
        world_name,
        subtitle,
        summary_text,
        cover_image_src,
        theme_mode,
        playable_npc_count,
        landmark_count,
    })
}

fn read_string_field(object: &Map<String, Value>, key: &str) -> Option<String> {
    object
        .get(key)
        .and_then(Value::as_str)
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(ToOwned::to_owned)
}

fn resolve_cover_image_src(object: &Map<String, Value>) -> Option<String> {
    object
        .get("cover")
        .and_then(Value::as_object)
        .and_then(|cover| read_string_field(cover, "imageSrc"))
        .or_else(|| {
            object
                .get("camp")
                .and_then(Value::as_object)
                .and_then(|camp| read_string_field(camp, "imageSrc"))
        })
        .or_else(|| {
            object
                .get("landmarks")
                .and_then(Value::as_array)
                .and_then(|entries| entries.first())
                .and_then(Value::as_object)
                .and_then(|landmark| read_string_field(landmark, "imageSrc"))
        })
}

fn count_profile_roles(object: &Map<String, Value>) -> u32 {
    let playable = object
        .get("playableNpcs")
        .and_then(Value::as_array)
        .map(|entries| entries.len() as u32)
        .unwrap_or(0);
    let story = object
        .get("storyNpcs")
        .and_then(Value::as_array)
        .map(|entries| entries.len() as u32)
        .unwrap_or(0);

    playable.saturating_add(story)
}

fn current_utc_micros() -> i64 {
    use std::time::{SystemTime, UNIX_EPOCH};

    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system clock should be after unix epoch");
    i64::try_from(duration.as_micros()).expect("current unix micros should fit in i64")
}