use super::*;

pub async fn create_match3d_agent_session(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<CreateMatch3DAgentSessionRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_AGENT_PROVIDER)?;
    let config = build_config_from_create_request(&payload);
    let seed_text = build_seed_text(&payload, &config);
    let welcome_message_text = MATCH3D_QUESTION_THEME.to_string();

    let session = state
        .spacetime_client()
        .create_match3d_agent_session(Match3DAgentSessionCreateRecordInput {
            session_id: build_prefixed_uuid_id(MATCH3D_SESSION_ID_PREFIX),
            owner_user_id: authenticated.claims().user_id().to_string(),
            seed_text,
            welcome_message_id: build_prefixed_uuid_id(MATCH3D_MESSAGE_ID_PREFIX),
            welcome_message_text,
            config_json: serialize_match3d_config(&config),
            created_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_AGENT_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DAgentSessionResponse {
            session: load_match3d_agent_session_response_with_persisted_assets(
                &state,
                authenticated.claims().user_id(),
                session,
            )
            .await,
        },
    ))
}

pub async fn get_match3d_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,
        MATCH3D_AGENT_PROVIDER,
        &session_id,
        "sessionId",
    )?;

    let session = state
        .spacetime_client()
        .get_match3d_agent_session(session_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_AGENT_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DAgentSessionResponse {
            session: load_match3d_agent_session_response_with_persisted_assets(
                &state,
                authenticated.claims().user_id(),
                session,
            )
            .await,
        },
    ))
}

pub async fn submit_match3d_agent_message(
    State(state): State<AppState>,
    Path(session_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<SendMatch3DAgentMessageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_AGENT_PROVIDER)?;
    let session = submit_and_finalize_match3d_message(
        &state,
        &request_context,
        authenticated.claims().user_id(),
        session_id,
        payload,
    )
    .await?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DAgentSessionResponse {
            session: load_match3d_agent_session_response_with_persisted_assets(
                &state,
                authenticated.claims().user_id(),
                session,
            )
            .await,
        },
    ))
}

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

    let owner_user_id = authenticated.claims().user_id().to_string();
    let request_context_for_stream = request_context.clone();
    let stream = async_stream::stream! {
        let result = submit_and_finalize_match3d_message(
            &state,
            &request_context_for_stream,
            owner_user_id.as_str(),
            session_id,
            payload,
        )
        .await;

        match result {
            Ok(session) => {
                let session_response = load_match3d_agent_session_response_with_persisted_assets(
                    &state,
                    owner_user_id.as_str(),
                    session,
                )
                .await;
                if let Some(reply) = session_response.last_assistant_reply.clone() {
                    yield Ok::<Event, Infallible>(match3d_sse_json_event_or_error(
                        "reply_delta",
                        json!({ "text": reply }),
                    ));
                }
                yield Ok::<Event, Infallible>(match3d_sse_json_event_or_error(
                    "session",
                    json!({ "session": session_response }),
                ));
                yield Ok::<Event, Infallible>(match3d_sse_json_event_or_error(
                    "done",
                    json!({ "ok": true }),
                ));
            }
            Err(response) => {
                yield Ok::<Event, Infallible>(match3d_sse_json_event_or_error(
                    "error",
                    json!({ "message": response.status().to_string() }),
                ));
            }
        }
    };

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

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

    if payload.action.trim() != "match3d_compile_draft" {
        return Err(match3d_bad_request(
            &request_context,
            MATCH3D_AGENT_PROVIDER,
            "unknown match3d action",
        ));
    }

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

    Ok(json_success_body(
        Some(&request_context),
        Match3DAgentActionResponse {
            session: map_match3d_agent_session_response_with_assets(
                session,
                &generated_item_assets,
            ),
        },
    ))
}

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

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

    Ok(json_success_body(
        Some(&request_context),
        Match3DAgentActionResponse {
            session: map_match3d_agent_session_response_with_assets(
                session,
                &generated_item_assets,
            ),
        },
    ))
}

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

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

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

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

pub async fn get_match3d_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,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let item = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DWorkDetailResponse {
            item: map_match3d_work_profile_response(item),
        },
    ))
}

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

    let existing = state
        .spacetime_client()
        .get_match3d_work_detail(
            profile_id.clone(),
            authenticated.claims().user_id().to_string(),
        )
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;
    let theme_text = payload
        .theme_text
        .clone()
        .filter(|value| !value.trim().is_empty())
        .unwrap_or(existing.theme_text);
    let item = state
        .spacetime_client()
        .update_match3d_work(Match3DWorkUpdateRecordInput {
            profile_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            game_name: payload.game_name,
            theme_text,
            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(),
            cover_asset_id: String::new(),
            clear_count: payload.clear_count,
            difficulty: payload.difficulty,
            updated_at_micros: current_utc_micros(),
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DWorkMutationResponse {
            item: map_match3d_work_profile_response(item),
        },
    ))
}

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

    let owner_user_id = authenticated.claims().user_id().to_string();
    let existing = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id.clone(), owner_user_id.clone())
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;
    let session_id = existing.source_session_id.clone().ok_or_else(|| {
        match3d_error_response(
            &request_context,
            MATCH3D_WORKS_PROVIDER,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": MATCH3D_WORKS_PROVIDER,
                "message": "抓大鹅作品缺少来源 session，无法写回音频素材",
            })),
        )
    })?;
    let assets = payload
        .generated_item_assets
        .into_iter()
        .map(Match3DGeneratedItemAsset::from)
        .collect::<Vec<_>>();
    let session = upsert_match3d_draft_snapshot(
        &state,
        &request_context,
        &authenticated,
        session_id,
        owner_user_id.clone(),
        profile_id.clone(),
        Some(existing.game_name),
        Some(existing.summary),
        Some(serde_json::to_string(&existing.tags).unwrap_or_default()),
        existing.cover_image_src,
        None,
        serialize_match3d_generated_item_assets(&assets),
    )
    .await?;

    let item = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id, owner_user_id)
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;
    let _ = session;
    Ok(json_success_body(
        Some(&request_context),
        Match3DWorkMutationResponse {
            item: map_match3d_work_profile_response(item),
        },
    ))
}

pub async fn persist_match3d_generated_model(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<PersistMatch3DGeneratedModelRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &payload.item_id,
        "itemId",
    )?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &payload.item_name,
        "itemName",
    )?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &payload.source_url,
        "sourceUrl",
    )?;

    let owner_user_id = authenticated.claims().user_id().to_string();
    let existing = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id.clone(), owner_user_id.clone())
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;
    let session_id = existing.source_session_id.clone().ok_or_else(|| {
        match3d_error_response(
            &request_context,
            MATCH3D_WORKS_PROVIDER,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": MATCH3D_WORKS_PROVIDER,
                "message": "抓大鹅作品缺少来源 session，无法保存历史模型",
            })),
        )
    })?;

    let mut assets =
        parse_match3d_generated_item_assets(existing.generated_item_assets_json.as_deref())
            .into_iter()
            .map(Match3DGeneratedItemAsset::from)
            .collect::<Vec<_>>();
    let current_asset = assets
        .iter()
        .find(|asset| asset.item_id == payload.item_id)
        .cloned();
    let item_name = normalize_match3d_item_name(payload.item_name.as_str());
    let item_name = if item_name.is_empty() {
        current_asset
            .as_ref()
            .map(|asset| asset.item_name.clone())
            .unwrap_or_else(|| payload.item_name.trim().to_string())
    } else {
        item_name
    };
    let model_file = hyper3d_contract::Hyper3dDownloadFilePayload {
        name: normalize_optional_text(payload.file_name.as_deref())
            .unwrap_or_else(|| "model.glb".to_string()),
        url: payload.source_url.trim().to_string(),
    };
    let downloaded_model = download_match3d_legacy_model(&model_file)
        .await
        .map_err(|error| match3d_error_response(&request_context, MATCH3D_WORKS_PROVIDER, error))?;
    let task_uuid = normalize_optional_text(payload.task_uuid.as_deref());
    let item_slug = build_match3d_item_slug(payload.item_id.as_str(), item_name.as_str());
    let generated_at_micros = current_utc_micros();
    let uploaded_model = persist_match3d_generated_bytes(
        &state,
        owner_user_id.as_str(),
        session_id.as_str(),
        profile_id.as_str(),
        &[
            "items",
            item_slug.as_str(),
            "model",
            task_uuid.as_deref().unwrap_or("manual"),
        ],
        downloaded_model.file_name.as_str(),
        downloaded_model.content_type.as_str(),
        downloaded_model.bytes,
        "match3d_item_model",
        task_uuid.as_deref(),
        generated_at_micros,
    )
    .await
    .map_err(|error| match3d_error_response(&request_context, MATCH3D_WORKS_PROVIDER, error))?;
    let next_asset = Match3DGeneratedItemAsset {
        item_id: payload.item_id,
        item_name,
        item_size: current_asset
            .as_ref()
            .and_then(|asset| asset.item_size.clone())
            .or_else(|| Some(MATCH3D_ITEM_SIZE_LARGE.to_string())),
        image_src: current_asset
            .as_ref()
            .and_then(|asset| asset.image_src.clone()),
        image_object_key: current_asset
            .as_ref()
            .and_then(|asset| asset.image_object_key.clone()),
        image_views: current_asset
            .as_ref()
            .map(|asset| asset.image_views.clone())
            .unwrap_or_default(),
        model_src: Some(uploaded_model.src),
        model_object_key: Some(uploaded_model.object_key),
        model_file_name: Some(downloaded_model.file_name),
        task_uuid,
        subscription_key: normalize_optional_text(payload.subscription_key.as_deref()).or_else(
            || {
                current_asset
                    .as_ref()
                    .and_then(|asset| asset.subscription_key.clone())
            },
        ),
        sound_prompt: current_asset
            .as_ref()
            .and_then(|asset| asset.sound_prompt.clone()),
        background_music_title: current_asset
            .as_ref()
            .and_then(|asset| asset.background_music_title.clone()),
        background_music_style: current_asset
            .as_ref()
            .and_then(|asset| asset.background_music_style.clone()),
        background_music_prompt: current_asset
            .as_ref()
            .and_then(|asset| asset.background_music_prompt.clone()),
        background_music: current_asset
            .as_ref()
            .and_then(|asset| asset.background_music.clone()),
        click_sound: current_asset
            .as_ref()
            .and_then(|asset| asset.click_sound.clone()),
        background_asset: current_asset
            .as_ref()
            .and_then(|asset| asset.background_asset.clone()),
        status: "model_ready".to_string(),
        error: None,
    };
    upsert_match3d_generated_item_asset(&mut assets, next_asset.clone());
    persist_match3d_generated_item_assets_snapshot(
        &state,
        &request_context,
        &authenticated,
        session_id.as_str(),
        owner_user_id.as_str(),
        profile_id.as_str(),
        &assets,
    )
    .await?;

    Ok(json_success_body(
        Some(&request_context),
        PersistMatch3DGeneratedModelResponse {
            asset: map_match3d_generated_item_asset_for_work(Match3DGeneratedItemAssetJson::from(
                next_asset,
            )),
        },
    ))
}

pub async fn generate_match3d_cover_image(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<GenerateMatch3DCoverImageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;
    let prompt = normalize_match3d_cover_prompt(payload.prompt.as_str());
    ensure_non_empty(&request_context, MATCH3D_WORKS_PROVIDER, &prompt, "prompt")?;

    let context =
        load_match3d_work_asset_context(&state, &request_context, &authenticated, &profile_id)
            .await?;
    let generated_cover = generate_match3d_cover_image_asset(
        &state,
        &request_context,
        &context.owner_user_id,
        context.session_id.as_str(),
        profile_id.as_str(),
        &context.config,
        prompt.as_str(),
        payload.uploaded_image_src,
        collect_match3d_cover_reference_image_sources(
            payload.reference_image_src,
            payload.reference_image_srcs,
        ),
    )
    .await
    .map_err(|error| match3d_error_response(&request_context, MATCH3D_WORKS_PROVIDER, error))?;

    let item = update_match3d_work_cover_only(
        &state,
        &request_context,
        context.owner_user_id.as_str(),
        context.profile,
        generated_cover.src.as_str(),
    )
    .await?;

    Ok(json_success_body(
        Some(&request_context),
        GenerateMatch3DCoverImageResponse {
            item: map_match3d_work_profile_response(item),
            cover_image_src: generated_cover.src,
            cover_image_object_key: generated_cover.object_key,
            prompt,
        },
    ))
}
pub async fn generate_match3d_background_image_for_work(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<GenerateMatch3DBackgroundImageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;
    let prompt = normalize_match3d_background_prompt(payload.prompt.as_str());
    ensure_non_empty(&request_context, MATCH3D_WORKS_PROVIDER, &prompt, "prompt")?;
    let prompt_fingerprint = build_match3d_prompt_fingerprint(prompt.as_str());

    let context =
        load_match3d_work_asset_context(&state, &request_context, &authenticated, &profile_id)
            .await?;
    let Match3DWorkAssetContext {
        owner_user_id,
        session_id,
        profile,
        config,
        assets,
    } = context;
    let billing_asset_id = format!("{}:{}:{}", session_id, profile_id, prompt_fingerprint);
    let (generated_background, generated_assets) = execute_billable_asset_operation_with_cost(
        &state,
        owner_user_id.as_str(),
        "match3d_ui_background_image",
        billing_asset_id.as_str(),
        MATCH3D_BACKGROUND_IMAGE_POINTS_COST,
        async {
            let generated_background = generate_match3d_background_image(
                &state,
                &request_context,
                owner_user_id.as_str(),
                session_id.as_str(),
                profile_id.as_str(),
                &config,
                prompt.as_str(),
            )
            .await?;
            let mut assets = assets;
            attach_match3d_background_asset_to_assets(&mut assets, generated_background.clone());
            let save_result = persist_match3d_generated_item_assets_snapshot(
                &state,
                &request_context,
                &authenticated,
                session_id.as_str(),
                owner_user_id.as_str(),
                profile_id.as_str(),
                &assets,
            )
            .await;
            if let Err(response) = save_result {
                tracing::warn!(
                    provider = MATCH3D_WORKS_PROVIDER,
                    profile_id,
                    owner_user_id = %owner_user_id,
                    status = %response.status(),
                    "抓大鹅 UI 背景图已生成但 SpacetimeDB 草稿写回不可用，降级返回本次生成资产"
                );
            }
            Ok((generated_background, assets))
        },
    )
    .await
    .map_err(|error| match3d_error_response(&request_context, MATCH3D_WORKS_PROVIDER, error))?;

    let item = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id.clone(), owner_user_id.clone())
        .await
        .map(|item| map_match3d_work_profile_response(item))
        .unwrap_or_else(|error| {
            tracing::warn!(
                provider = MATCH3D_WORKS_PROVIDER,
                profile_id,
                owner_user_id = %owner_user_id,
                error = %error,
                "抓大鹅 UI 背景图生成后读取作品详情失败，降级使用写回前快照"
            );
            map_match3d_work_profile_response(build_match3d_work_profile_record_with_assets(
                profile,
                &generated_assets,
            ))
        });
    let background_image_src = generated_background.image_src.clone().unwrap_or_default();
    let background_image_object_key = generated_background
        .image_object_key
        .clone()
        .unwrap_or_default();

    Ok(json_success_body(
        Some(&request_context),
        GenerateMatch3DBackgroundImageResponse {
            item,
            background_image_src,
            background_image_object_key,
            generated_background_asset: map_match3d_background_asset_for_work(generated_background),
            prompt,
        },
    ))
}

pub async fn generate_match3d_container_image_for_work(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<GenerateMatch3DContainerImageRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;
    let prompt = normalize_match3d_background_prompt(payload.prompt.as_str());
    ensure_non_empty(&request_context, MATCH3D_WORKS_PROVIDER, &prompt, "prompt")?;
    let prompt_fingerprint = build_match3d_prompt_fingerprint(prompt.as_str());

    let context =
        load_match3d_work_asset_context(&state, &request_context, &authenticated, &profile_id)
            .await?;
    let Match3DWorkAssetContext {
        owner_user_id,
        session_id,
        profile,
        config,
        assets,
    } = context;
    let billing_asset_id = format!(
        "{}:{}:{}:container",
        session_id, profile_id, prompt_fingerprint
    );
    let (generated_background, generated_assets) = execute_billable_asset_operation_with_cost(
        &state,
        owner_user_id.as_str(),
        "match3d_ui_container_image",
        billing_asset_id.as_str(),
        MATCH3D_BACKGROUND_IMAGE_POINTS_COST,
        async {
            let generated_container = generate_match3d_container_image(
                &state,
                &request_context,
                owner_user_id.as_str(),
                session_id.as_str(),
                profile_id.as_str(),
                &config,
                prompt.as_str(),
            )
            .await?;
            let mut assets = assets;
            let generated_background =
                merge_match3d_container_image_into_background_asset(&assets, generated_container);
            attach_match3d_background_asset_to_assets(&mut assets, generated_background.clone());
            let save_result = persist_match3d_generated_item_assets_snapshot(
                &state,
                &request_context,
                &authenticated,
                session_id.as_str(),
                owner_user_id.as_str(),
                profile_id.as_str(),
                &assets,
            )
            .await;
            if let Err(response) = save_result {
                tracing::warn!(
                    provider = MATCH3D_WORKS_PROVIDER,
                    profile_id,
                    owner_user_id = %owner_user_id,
                    status = %response.status(),
                    "抓大鹅容器形象已生成但 SpacetimeDB 草稿写回不可用，降级返回本次生成资产"
                );
            }
            Ok((generated_background, assets))
        },
    )
    .await
    .map_err(|error| match3d_error_response(&request_context, MATCH3D_WORKS_PROVIDER, error))?;

    let item = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id.clone(), owner_user_id.clone())
        .await
        .map(|item| map_match3d_work_profile_response(item))
        .unwrap_or_else(|error| {
            tracing::warn!(
                provider = MATCH3D_WORKS_PROVIDER,
                profile_id,
                owner_user_id = %owner_user_id,
                error = %error,
                "抓大鹅容器形象生成后读取作品详情失败，降级使用写回前快照"
            );
            map_match3d_work_profile_response(build_match3d_work_profile_record_with_assets(
                profile,
                &generated_assets,
            ))
        });
    let container_image_src = generated_background
        .container_image_src
        .clone()
        .unwrap_or_default();
    let container_image_object_key = generated_background
        .container_image_object_key
        .clone()
        .unwrap_or_default();

    Ok(json_success_body(
        Some(&request_context),
        GenerateMatch3DContainerImageResponse {
            item,
            container_image_src,
            container_image_object_key,
            generated_background_asset: map_match3d_background_asset_for_work(generated_background),
            prompt,
        },
    ))
}

pub async fn generate_match3d_item_assets_for_work(
    State(state): State<AppState>,
    Path(profile_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<GenerateMatch3DItemAssetsRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_WORKS_PROVIDER)?;
    ensure_non_empty(
        &request_context,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;
    let item_names = normalize_match3d_batch_item_names(payload.item_names);
    if item_names.is_empty() {
        return Err(match3d_bad_request(
            &request_context,
            MATCH3D_WORKS_PROVIDER,
            "请填写至少一个物品名称",
        ));
    }
    let generation_mode = normalize_match3d_item_assets_generation_mode(payload.mode.as_deref());

    let context =
        load_match3d_work_asset_context(&state, &request_context, &authenticated, &profile_id)
            .await?;
    let Match3DWorkAssetContext {
        owner_user_id,
        session_id,
        profile,
        config,
        assets,
    } = context;
    let generation_plan =
        build_match3d_item_assets_generation_plan(generation_mode, item_names, &assets);
    if generation_plan.billed_item_count() == 0 {
        return Ok(json_success_body(
            Some(&request_context),
            GenerateMatch3DItemAssetsResponse {
                item: map_match3d_work_profile_response(profile),
                generated_item_assets: sort_match3d_generated_assets(assets)
                    .into_iter()
                    .map(Match3DGeneratedItemAssetJson::from)
                    .map(map_match3d_generated_item_asset_for_work)
                    .collect(),
            },
        ));
    }
    let billed_item_count = generation_plan.billed_item_count();
    let points_cost = calculate_match3d_item_assets_points_cost(billed_item_count);
    let billing_asset_id = format!(
        "{}:{}:{}:{}",
        session_id,
        profile_id,
        billed_item_count,
        build_match3d_prompt_fingerprint(generation_plan.billing_fingerprint_source().as_str())
    );
    let generated_assets = execute_billable_asset_operation_with_cost(
        &state,
        owner_user_id.as_str(),
        "match3d_item_assets",
        billing_asset_id.as_str(),
        points_cost,
        async {
            append_match3d_item_assets(
                &state,
                &request_context,
                &authenticated,
                owner_user_id.as_str(),
                session_id.as_str(),
                profile_id.as_str(),
                &config,
                generation_plan,
                assets,
            )
            .await
            .map_err(|response| {
                AppError::from_status(response.status()).with_details(json!({
                    "provider": MATCH3D_WORKS_PROVIDER,
                    "message": "抓大鹅批量新增物品素材失败",
                }))
            })
        },
    )
    .await
    .map_err(|error| match3d_error_response(&request_context, MATCH3D_WORKS_PROVIDER, error))?;

    let item = state
        .spacetime_client()
        .get_match3d_work_detail(profile_id, owner_user_id)
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;
    Ok(json_success_body(
        Some(&request_context),
        GenerateMatch3DItemAssetsResponse {
            item: map_match3d_work_profile_response(item),
            generated_item_assets: generated_assets
                .into_iter()
                .map(Match3DGeneratedItemAssetJson::from)
                .map(map_match3d_generated_item_asset_for_work)
                .collect(),
        },
    ))
}

pub async fn generate_match3d_work_tags(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Extension(_authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<GenerateMatch3DWorkTagsRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_WORKS_PROVIDER)?;
    let tags = generate_match3d_work_tags_for_profile(
        &state,
        payload.game_name.as_str(),
        payload.theme_text.as_str(),
        payload.summary.as_deref(),
    )
    .await;

    Ok(json_success_body(
        Some(&request_context),
        GenerateMatch3DWorkTagsResponse { tags },
    ))
}

pub async fn publish_match3d_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,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let item = state
        .spacetime_client()
        .publish_match3d_work(
            profile_id,
            authenticated.claims().user_id().to_string(),
            current_utc_micros(),
        )
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DWorkMutationResponse {
            item: map_match3d_work_profile_response(item),
        },
    ))
}

pub async fn delete_match3d_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,
        MATCH3D_WORKS_PROVIDER,
        &profile_id,
        "profileId",
    )?;

    let items = state
        .spacetime_client()
        .delete_match3d_work(profile_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_WORKS_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

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

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

    let run = state
        .spacetime_client()
        .start_match3d_run(Match3DRunStartRecordInput {
            run_id: build_prefixed_uuid_id(MATCH3D_RUN_ID_PREFIX),
            owner_user_id: authenticated.claims().user_id().to_string(),
            profile_id: profile_id.clone(),
            started_at_ms: current_utc_ms(),
            item_type_count_override: maybe_payload
                .as_ref()
                .and_then(|payload| payload.item_type_count_override)
                .unwrap_or(0),
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_RUNTIME_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

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

    Ok(json_success_body(
        Some(&request_context),
        Match3DRunResponse {
            run: map_match3d_run_response(run),
        },
    ))
}

pub async fn get_match3d_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, MATCH3D_RUNTIME_PROVIDER, &run_id, "runId")?;

    let run = state
        .spacetime_client()
        .get_match3d_run(run_id, authenticated.claims().user_id().to_string())
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_RUNTIME_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DRunResponse {
            run: map_match3d_run_response(run),
        },
    ))
}

pub async fn click_match3d_item(
    State(state): State<AppState>,
    Path(run_id): Path<String>,
    Extension(request_context): Extension<RequestContext>,
    Extension(authenticated): Extension<AuthenticatedAccessToken>,
    payload: Result<Json<ClickMatch3DItemRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = match3d_json(payload, &request_context, MATCH3D_RUNTIME_PROVIDER)?;
    ensure_non_empty(&request_context, MATCH3D_RUNTIME_PROVIDER, &run_id, "runId")?;
    ensure_non_empty(
        &request_context,
        MATCH3D_RUNTIME_PROVIDER,
        &payload.item_instance_id,
        "itemInstanceId",
    )?;
    ensure_non_empty(
        &request_context,
        MATCH3D_RUNTIME_PROVIDER,
        &payload.client_event_id,
        "clientEventId",
    )?;

    let confirmation = state
        .spacetime_client()
        .click_match3d_item(Match3DRunClickRecordInput {
            run_id: payload.run_id.unwrap_or(run_id),
            owner_user_id: authenticated.claims().user_id().to_string(),
            item_instance_id: payload.item_instance_id,
            client_snapshot_version: payload.client_snapshot_version.min(u32::MAX as u64) as u32,
            client_event_id: payload.client_event_id,
            clicked_at_ms: payload.clicked_at_ms.min(i64::MAX as u64) as i64,
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_RUNTIME_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DClickResponse {
            confirmation: map_match3d_click_confirmation_response(confirmation),
        },
    ))
}

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

    let run = state
        .spacetime_client()
        .stop_match3d_run(Match3DRunStopRecordInput {
            run_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            stopped_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_RUNTIME_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DRunResponse {
            run: map_match3d_run_response(run),
        },
    ))
}

pub async fn restart_match3d_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, MATCH3D_RUNTIME_PROVIDER, &run_id, "runId")?;

    let run = state
        .spacetime_client()
        .restart_match3d_run(Match3DRunRestartRecordInput {
            source_run_id: run_id,
            next_run_id: build_prefixed_uuid_id(MATCH3D_RUN_ID_PREFIX),
            owner_user_id: authenticated.claims().user_id().to_string(),
            restarted_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_RUNTIME_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DRunResponse {
            run: map_match3d_run_response(run),
        },
    ))
}

pub async fn finish_match3d_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, MATCH3D_RUNTIME_PROVIDER, &run_id, "runId")?;

    let run = state
        .spacetime_client()
        .finish_match3d_time_up(Match3DRunTimeUpRecordInput {
            run_id,
            owner_user_id: authenticated.claims().user_id().to_string(),
            finished_at_ms: current_utc_ms(),
        })
        .await
        .map_err(|error| {
            match3d_error_response(
                &request_context,
                MATCH3D_RUNTIME_PROVIDER,
                map_match3d_client_error(error),
            )
        })?;

    Ok(json_success_body(
        Some(&request_context),
        Match3DRunResponse {
            run: map_match3d_run_response(run),
        },
    ))
}