use std::time::Instant;

use axum::{
    Json,
    extract::{Extension, State, rejection::JsonRejection},
    http::StatusCode,
    response::Response,
};
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
use image::{ColorType, GenericImageView, ImageEncoder, ImageFormat, codecs::png::PngEncoder};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};

use crate::{
    api_response::json_success_body,
    config::DEFAULT_VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS,
    http_error::AppError,
    openai_image_generation::{
        DownloadedOpenAiImage, OpenAiImageSettings, build_openai_image_http_client,
        create_openai_image_generation, require_openai_image_settings,
    },
    request_context::RequestContext,
    state::AppState,
};

const BABY_OBJECT_MATCH_PROVIDER: &str = "vector-engine-gpt-image-2";
const BABY_OBJECT_MATCH_IMAGE_SIZE: &str = "1024x1024";
const BABY_OBJECT_MATCH_BACKGROUND_IMAGE_SIZE: &str = "1536x1024";
const BABY_OBJECT_MATCH_SHEET_GRID_SIZE: u32 = 2;

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct GenerateBabyObjectMatchAssetsRequest {
    item_names: Vec<String>,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct GenerateBabyObjectMatchAssetsResponse {
    assets: Vec<BabyObjectMatchItemAssetPayload>,
    visual_package: BabyObjectMatchVisualPackagePayload,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct BabyObjectMatchItemAssetPayload {
    item_id: String,
    item_name: String,
    image_src: String,
    asset_object_id: Option<String>,
    generation_provider: String,
    prompt: String,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum BabyObjectMatchVisualAssetKind {
    Background,
    GiftBox,
    Basket,
}

impl BabyObjectMatchVisualAssetKind {
    fn asset_id(self) -> &'static str {
        match self {
            Self::Background => "baby-object-visual-background",
            Self::GiftBox => "baby-object-visual-gift-box",
            Self::Basket => "baby-object-visual-basket",
        }
    }

    fn contract_kind(self) -> &'static str {
        match self {
            Self::Background => "background",
            Self::GiftBox => "gift-box",
            Self::Basket => "basket",
        }
    }

    fn failure_context(self) -> &'static str {
        match self {
            Self::Background => "宝贝识物背景环境图片生成失败",
            Self::GiftBox => "宝贝识物礼物盒图片生成失败",
            Self::Basket => "宝贝识物篮子图片生成失败",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum BabyObjectMatchSheetSlot {
    ItemA,
    ItemB,
    Basket,
    GiftBox,
}

impl BabyObjectMatchSheetSlot {
    const ALL: [Self; 4] = [Self::ItemA, Self::ItemB, Self::Basket, Self::GiftBox];

    fn row(self) -> u32 {
        match self {
            Self::ItemA | Self::ItemB => 0,
            Self::Basket | Self::GiftBox => 1,
        }
    }

    fn col(self) -> u32 {
        match self {
            Self::ItemA | Self::Basket => 0,
            Self::ItemB | Self::GiftBox => 1,
        }
    }
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct BabyObjectMatchVisualPackagePayload {
    theme_prompt: String,
    assets: Vec<BabyObjectMatchVisualAssetPayload>,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct BabyObjectMatchVisualAssetPayload {
    asset_id: String,
    asset_kind: String,
    image_src: String,
    asset_object_id: Option<String>,
    generation_provider: String,
    prompt: String,
}

#[derive(Debug)]
struct BabyObjectMatchSheetAssets {
    items: Vec<BabyObjectMatchItemAssetPayload>,
    basket: BabyObjectMatchVisualAssetPayload,
    gift_box: BabyObjectMatchVisualAssetPayload,
}

#[derive(Clone, Copy, Debug)]
struct BabyObjectMatchSheetCellBounds {
    x0: u32,
    y0: u32,
    x1: u32,
    y1: u32,
}

pub async fn generate_baby_object_match_assets(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    payload: Result<Json<GenerateBabyObjectMatchAssetsRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = payload.map_err(|error| {
        baby_object_match_error_response(
            &request_context,
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "edutainment-baby-object",
                "message": error.body_text(),
            })),
        )
    })?;
    let item_names = normalize_item_names(payload.item_names)
        .map_err(|error| baby_object_match_error_response(&request_context, error))?;

    let settings = require_openai_image_settings(&state)
        .map_err(|error| baby_object_match_error_response(&request_context, error))?;
    let settings = with_baby_object_match_image_timeout(settings);
    let http_client = build_openai_image_http_client(&settings)
        .map_err(|error| baby_object_match_error_response(&request_context, error))?;

    let request_started_at = Instant::now();
    tracing::info!(
        item_count = item_names.len(),
        "宝贝识物 image-2 资源生成开始"
    );
    let (sheet_assets, background_asset, theme_prompt) =
        build_baby_object_match_optimized_assets(&http_client, &settings, item_names.as_slice())
            .await
            .map_err(|error| baby_object_match_error_response(&request_context, error))?;
    tracing::info!(
        elapsed_ms = request_started_at.elapsed().as_millis() as u64,
        "宝贝识物 image-2 资源生成完成"
    );

    let assets = sheet_assets.items;
    let visual_package = BabyObjectMatchVisualPackagePayload {
        theme_prompt,
        assets: vec![background_asset, sheet_assets.gift_box, sheet_assets.basket],
    };

    Ok(json_success_body(
        Some(&request_context),
        GenerateBabyObjectMatchAssetsResponse {
            assets,
            visual_package,
        },
    ))
}

fn normalize_item_names(item_names: Vec<String>) -> Result<Vec<String>, AppError> {
    let normalized = item_names
        .into_iter()
        .map(|value| value.trim().to_string())
        .collect::<Vec<_>>();

    if normalized.len() != 2 || normalized.iter().any(|value| value.is_empty()) {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": "edutainment-baby-object",
                "message": "请填写两个物品名称。",
            })),
        );
    }

    Ok(normalized)
}

async fn build_baby_object_match_optimized_assets(
    http_client: &reqwest::Client,
    settings: &OpenAiImageSettings,
    item_names: &[String],
) -> Result<
    (
        BabyObjectMatchSheetAssets,
        BabyObjectMatchVisualAssetPayload,
        String,
    ),
    AppError,
> {
    let theme_prompt = build_baby_object_match_visual_theme_prompt(item_names);
    let sheet_prompt = build_baby_object_match_sheet_prompt(item_names, theme_prompt.as_str());
    let background_prompt = build_baby_object_match_visual_asset_prompt(
        BabyObjectMatchVisualAssetKind::Background,
        item_names,
        theme_prompt.as_str(),
    );

    let (sheet_assets, background_asset) = tokio::try_join!(
        build_baby_object_match_sheet_assets(
            http_client,
            settings,
            item_names,
            sheet_prompt.as_str()
        ),
        build_baby_object_match_background_asset(http_client, settings, background_prompt.as_str()),
    )?;

    Ok((sheet_assets, background_asset, theme_prompt))
}

fn build_baby_object_match_sheet_prompt(item_names: &[String], theme_prompt: &str) -> String {
    let item_a = item_names.first().map(String::as_str).unwrap_or_default();
    let item_b = item_names.get(1).map(String::as_str).unwrap_or_default();

    format!(
        "{theme_prompt}\n\
        生成一张 1024x1024 的 2x2 游戏素材 sheet，严格均匀分成四格，但画面中不要绘制网格线、文字、标签或编号。\n\
        四格内容必须固定为：左上格是单一物品“{item_a}”；右上格是单一物品“{item_b}”；左下格是游戏左右两侧复用的大号篮子；右下格是游戏中央使用的大号礼物盒。\n\
        风格必须与寓教于乐板块统一：明亮、温暖、卡通绘本质感，适合 4-8 岁儿童，边缘清晰，色彩干净，能自然放在同一套游戏场景中。\n\
        物品格只允许出现围绕对应关键词的单一主体，不能出现组合物、多个物体、人物、手、篮子、礼物盒、文字、水印或 UI。\n\
        篮子格只生成一个主体饱满、开口清晰、可读性高的大号篮子，不能放入待分类物品，不能出现文字、人物、手或礼物盒，手柄和篮口镂空处不要留下白底描边或毛边。\n\
        礼物盒格只生成一个主体饱满、中心构图的大号礼物盒，不能出现篮子、待分类物品、人物、手或文字。\n\
        每格背景必须是统一纯白或接近纯白的干净背景，无场景、无阴影地面、无氛围渲染、无按钮、无边框，便于服务端将背景抠成透明 PNG。\n\
        每个主体必须完整居中，四周保留安全留白，不得跨格、贴边或越界。"
    )
}

fn build_baby_object_match_sheet_negative_prompt() -> &'static str {
    "文字，数字，水印，Logo，网格线，标签，按钮，UI，人物，手，复杂背景，场景，草地，天空，房间，光效氛围，多个物品，组合套装，物体跨格，贴边，越界，真实照片风，复杂投影"
}

fn with_baby_object_match_image_timeout(mut settings: OpenAiImageSettings) -> OpenAiImageSettings {
    settings.request_timeout_ms = settings
        .request_timeout_ms
        .max(DEFAULT_VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS);
    settings
}

async fn build_baby_object_match_sheet_assets(
    http_client: &reqwest::Client,
    settings: &OpenAiImageSettings,
    item_names: &[String],
    prompt: &str,
) -> Result<BabyObjectMatchSheetAssets, AppError> {
    let asset_started_at = Instant::now();
    tracing::info!("宝贝识物 image-2 2x2 素材 sheet 生成开始");
    let generated = create_openai_image_generation(
        http_client,
        settings,
        prompt,
        Some(build_baby_object_match_sheet_negative_prompt()),
        BABY_OBJECT_MATCH_IMAGE_SIZE,
        1,
        &[],
        "宝贝识物 2x2 素材 sheet 生成失败",
    )
    .await?;
    let generated_image = generated.images.into_iter().next().ok_or_else(|| {
        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
            "provider": "vector-engine",
            "message": "宝贝识物 2x2 素材 sheet 生成没有返回图片。",
        }))
    })?;
    let sliced = slice_baby_object_match_sheet(&generated_image)?;
    tracing::info!(
        elapsed_ms = asset_started_at.elapsed().as_millis() as u64,
        "宝贝识物 image-2 2x2 素材 sheet 生成完成"
    );

    Ok(BabyObjectMatchSheetAssets {
        items: vec![
            BabyObjectMatchItemAssetPayload {
                item_id: "baby-object-item-1".to_string(),
                item_name: item_names.first().cloned().unwrap_or_default(),
                image_src: sliced
                    .slot_data_url(BabyObjectMatchSheetSlot::ItemA)
                    .to_string(),
                asset_object_id: None,
                generation_provider: BABY_OBJECT_MATCH_PROVIDER.to_string(),
                prompt: prompt.to_string(),
            },
            BabyObjectMatchItemAssetPayload {
                item_id: "baby-object-item-2".to_string(),
                item_name: item_names.get(1).cloned().unwrap_or_default(),
                image_src: sliced
                    .slot_data_url(BabyObjectMatchSheetSlot::ItemB)
                    .to_string(),
                asset_object_id: None,
                generation_provider: BABY_OBJECT_MATCH_PROVIDER.to_string(),
                prompt: prompt.to_string(),
            },
        ],
        basket: BabyObjectMatchVisualAssetPayload {
            asset_id: BabyObjectMatchVisualAssetKind::Basket
                .asset_id()
                .to_string(),
            asset_kind: BabyObjectMatchVisualAssetKind::Basket
                .contract_kind()
                .to_string(),
            image_src: sliced
                .slot_data_url(BabyObjectMatchSheetSlot::Basket)
                .to_string(),
            asset_object_id: None,
            generation_provider: BABY_OBJECT_MATCH_PROVIDER.to_string(),
            prompt: prompt.to_string(),
        },
        gift_box: BabyObjectMatchVisualAssetPayload {
            asset_id: BabyObjectMatchVisualAssetKind::GiftBox
                .asset_id()
                .to_string(),
            asset_kind: BabyObjectMatchVisualAssetKind::GiftBox
                .contract_kind()
                .to_string(),
            image_src: sliced
                .slot_data_url(BabyObjectMatchSheetSlot::GiftBox)
                .to_string(),
            asset_object_id: None,
            generation_provider: BABY_OBJECT_MATCH_PROVIDER.to_string(),
            prompt: prompt.to_string(),
        },
    })
}

async fn build_baby_object_match_background_asset(
    http_client: &reqwest::Client,
    settings: &OpenAiImageSettings,
    prompt: &str,
) -> Result<BabyObjectMatchVisualAssetPayload, AppError> {
    let asset_started_at = Instant::now();
    let kind = BabyObjectMatchVisualAssetKind::Background;
    tracing::info!(
        asset_kind = kind.contract_kind(),
        "宝贝识物 image-2 场景资源生成开始"
    );
    let generated = create_openai_image_generation(
        http_client,
        settings,
        prompt,
        Some(build_baby_object_match_visual_negative_prompt(kind)),
        BABY_OBJECT_MATCH_BACKGROUND_IMAGE_SIZE,
        1,
        &[],
        kind.failure_context(),
    )
    .await?;
    let generated_image = generated.images.into_iter().next().ok_or_else(|| {
        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
            "provider": "vector-engine",
            "message": format!("{}：VectorEngine 没有返回图片。", kind.failure_context()),
        }))
    })?;
    let image_src = build_png_data_url(generated_image)?;
    tracing::info!(
        asset_kind = kind.contract_kind(),
        elapsed_ms = asset_started_at.elapsed().as_millis() as u64,
        "宝贝识物 image-2 场景资源生成完成"
    );

    Ok(BabyObjectMatchVisualAssetPayload {
        asset_id: kind.asset_id().to_string(),
        asset_kind: kind.contract_kind().to_string(),
        image_src,
        asset_object_id: None,
        generation_provider: BABY_OBJECT_MATCH_PROVIDER.to_string(),
        prompt: prompt.to_string(),
    })
}

fn build_baby_object_match_visual_theme_prompt(item_names: &[String]) -> String {
    let item_a = item_names.first().map(String::as_str).unwrap_or_default();
    let item_b = item_names.get(1).map(String::as_str).unwrap_or_default();
    let theme_hint = resolve_baby_object_match_theme_hint(item_names);

    format!(
        "根据创作者填写的两个物品关键词“{item_a}”和“{item_b}”，为儿童动作 Demo 玩法“宝贝识物”生成一套完整游戏视觉包装。\n\
        视觉必须保持寓教于乐板块统一的明亮、温暖、卡通绘本插画风，适合 4-8 岁儿童。\n\
        主题匹配：{theme_hint}\n\
        所有资源需要围绕这两个关键词形成统一主题，但不能改变物品识别和左右篮子固定规则。"
    )
}

fn resolve_baby_object_match_theme_hint(item_names: &[String]) -> &'static str {
    let joined = item_names.join(" ").to_lowercase();
    let fruit_keywords = [
        "苹果",
        "橘子",
        "桔子",
        "香蕉",
        "葡萄",
        "草莓",
        "西瓜",
        "梨",
        "桃",
        "水果",
        "apple",
        "orange",
        "banana",
        "grape",
        "strawberry",
        "watermelon",
        "fruit",
    ];
    let character_keywords = [
        "佩琪",
        "小猪佩奇",
        "小猪佩琪",
        "奥特曼",
        "动漫",
        "动画",
        "卡通",
        "玩具",
        "角色",
        "公仔",
        "peppa",
        "ultraman",
        "anime",
        "cartoon",
        "toy",
        "doll",
        "figure",
    ];

    if fruit_keywords
        .iter()
        .any(|keyword| joined.contains(keyword))
    {
        return "若关键词属于水果，背景环境和 UI 元素匹配果园、自然、阳光、树叶等主题。";
    }

    if character_keywords
        .iter()
        .any(|keyword| joined.contains(keyword))
    {
        return "若关键词属于动漫角色、玩具或公仔，背景环境和 UI 元素匹配动漫、玩具房、儿童玩具等主题。";
    }

    "根据关键词语义自然匹配合适主题，保持儿童寓教于乐插画风。"
}

fn build_baby_object_match_visual_asset_prompt(
    kind: BabyObjectMatchVisualAssetKind,
    item_names: &[String],
    theme_prompt: &str,
) -> String {
    let item_a = item_names.first().map(String::as_str).unwrap_or_default();
    let item_b = item_names.get(1).map(String::as_str).unwrap_or_default();
    let base = format!(
        "{theme_prompt}\n\
        当前两个关键词：{item_a}、{item_b}。\n\
        输出必须是无文字、无水印、无 Logo 的游戏美术资源。"
    );

    match kind {
        BabyObjectMatchVisualAssetKind::Background => format!(
            "{base}\n\
            生成游戏背景环境图。背景需要根据关键词主题匹配环境，例如水果可偏果园自然，动漫角色或玩具可偏动漫玩具主题。\n\
            保持中间、屏幕中下方和底部左右篮子区域清爽，给放大后的礼物盒、中央物品和左右大篮子预留足够空间，不能画入礼物盒、篮子、物品、人物、文字或操作 UI。"
        ),
        BabyObjectMatchVisualAssetKind::GiftBox => format!(
            "{base}\n\
            生成透明 PNG 的大号礼物盒资源。礼物盒会在游戏中以约 2 倍视觉尺寸展示，需要主体饱满、轮廓清晰、中心构图、边缘安全留白少，打开动画时可被烟雾遮罩后移除。\n\
            礼物盒要与关键词主题匹配，可以带主题贴纸感装饰，但不能出现任何文字、人物、手、篮子或待分类物品。背景需要纯白或透明友好，便于抠图。"
        ),
        BabyObjectMatchVisualAssetKind::Basket => format!(
            "{base}\n\
            生成透明 PNG 的大号篮子资源，游戏左右两侧会复用同一个篮子造型并以约 1.5 倍视觉尺寸展示。篮子主体要饱满、开口清晰、可读性高、边缘安全留白少。\n\
            篮子要与关键词主题匹配，可以有主题色和贴纸感边缘，但不能出现任何文字、礼物盒、人物、手或待分类物品。背景需要纯白或透明友好，便于抠图，手柄和篮口边缘不要留下白底描边或毛边。"
        ),
    }
}

fn build_baby_object_match_visual_negative_prompt(
    kind: BabyObjectMatchVisualAssetKind,
) -> &'static str {
    match kind {
        BabyObjectMatchVisualAssetKind::Background => {
            "文字，数字，水印，Logo，按钮，说明面板，人物，手，礼物盒，篮子，中心物品，复杂前景遮挡，真实照片风，暗黑风"
        }
        BabyObjectMatchVisualAssetKind::GiftBox => {
            "文字，数字，水印，Logo，人物，手，篮子，待分类物品，大面积背景，场景，真实照片风"
        }
        BabyObjectMatchVisualAssetKind::Basket => {
            "文字，数字，水印，Logo，人物，手，礼物盒，待分类物品，大面积背景，场景，真实照片风"
        }
    }
}

struct BabyObjectMatchSlicedSheet {
    item_a: String,
    item_b: String,
    basket: String,
    gift_box: String,
}

impl BabyObjectMatchSlicedSheet {
    fn slot_data_url(&self, slot: BabyObjectMatchSheetSlot) -> &str {
        match slot {
            BabyObjectMatchSheetSlot::ItemA => self.item_a.as_str(),
            BabyObjectMatchSheetSlot::ItemB => self.item_b.as_str(),
            BabyObjectMatchSheetSlot::Basket => self.basket.as_str(),
            BabyObjectMatchSheetSlot::GiftBox => self.gift_box.as_str(),
        }
    }
}

fn slice_baby_object_match_sheet(
    image: &DownloadedOpenAiImage,
) -> Result<BabyObjectMatchSlicedSheet, AppError> {
    let png_bytes = normalize_generated_image_to_png(image.bytes.as_slice())?;
    let source = image::load_from_memory_with_format(png_bytes.as_slice(), ImageFormat::Png)
        .map_err(|error| {
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": "vector-engine",
                "message": format!("解析宝贝识物 2x2 素材 sheet 失败：{error}"),
            }))
        })?;
    let source = apply_baby_object_match_sheet_background_alpha(source);
    let (width, height) = source.dimensions();
    if width < BABY_OBJECT_MATCH_SHEET_GRID_SIZE || height < BABY_OBJECT_MATCH_SHEET_GRID_SIZE {
        return Err(
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": "vector-engine",
                "message": "宝贝识物 2x2 素材 sheet 尺寸过小，无法切割。",
            })),
        );
    }

    let mut data_urls = Vec::with_capacity(BabyObjectMatchSheetSlot::ALL.len());
    for slot in BabyObjectMatchSheetSlot::ALL {
        let (crop_x, crop_y, crop_width, crop_height) =
            resolve_baby_object_match_sheet_cell_crop(&source, slot);
        let cropped = source.crop_imm(crop_x, crop_y, crop_width, crop_height);
        data_urls.push(encode_baby_object_match_dynamic_image_data_url(
            cropped,
            slot == BabyObjectMatchSheetSlot::Basket,
        )?);
    }

    Ok(BabyObjectMatchSlicedSheet {
        item_a: data_urls.remove(0),
        item_b: data_urls.remove(0),
        basket: data_urls.remove(0),
        gift_box: data_urls.remove(0),
    })
}

fn resolve_baby_object_match_sheet_cell_crop(
    source: &image::DynamicImage,
    slot: BabyObjectMatchSheetSlot,
) -> (u32, u32, u32, u32) {
    let (image_width, image_height) = source.dimensions();
    let cell = resolve_baby_object_match_sheet_cell_bounds(
        image_width,
        image_height,
        slot.row(),
        slot.col(),
    );
    let Some(foreground) = detect_baby_object_match_sheet_foreground_bounds(source, cell) else {
        return cell.to_crop_tuple();
    };

    let pad_x = (cell.width() / 14).clamp(6, 24);
    let pad_y = (cell.height() / 14).clamp(6, 24);
    BabyObjectMatchSheetCellBounds {
        x0: foreground.x0.saturating_sub(pad_x).max(cell.x0),
        y0: foreground.y0.saturating_sub(pad_y).max(cell.y0),
        x1: foreground.x1.saturating_add(pad_x).min(cell.x1),
        y1: foreground.y1.saturating_add(pad_y).min(cell.y1),
    }
    .to_crop_tuple()
}

fn resolve_baby_object_match_sheet_cell_bounds(
    image_width: u32,
    image_height: u32,
    row: u32,
    col: u32,
) -> BabyObjectMatchSheetCellBounds {
    let cell_x0 = col.saturating_mul(image_width) / BABY_OBJECT_MATCH_SHEET_GRID_SIZE;
    let cell_x1 =
        (col.saturating_add(1)).saturating_mul(image_width) / BABY_OBJECT_MATCH_SHEET_GRID_SIZE;
    let cell_y0 = row.saturating_mul(image_height) / BABY_OBJECT_MATCH_SHEET_GRID_SIZE;
    let cell_y1 =
        (row.saturating_add(1)).saturating_mul(image_height) / BABY_OBJECT_MATCH_SHEET_GRID_SIZE;

    BabyObjectMatchSheetCellBounds {
        x0: cell_x0.min(image_width.saturating_sub(1)),
        y0: cell_y0.min(image_height.saturating_sub(1)),
        x1: cell_x1.clamp(cell_x0.saturating_add(1), image_width),
        y1: cell_y1.clamp(cell_y0.saturating_add(1), image_height),
    }
}

fn detect_baby_object_match_sheet_foreground_bounds(
    source: &image::DynamicImage,
    cell: BabyObjectMatchSheetCellBounds,
) -> Option<BabyObjectMatchSheetCellBounds> {
    let mut foreground: Option<BabyObjectMatchSheetCellBounds> = None;
    let mut foreground_pixels = 0u32;

    for y in cell.y0..cell.y1 {
        for x in cell.x0..cell.x1 {
            let pixel = source.get_pixel(x, y).0;
            if pixel[3] <= 24 {
                continue;
            }
            foreground_pixels = foreground_pixels.saturating_add(1);
            foreground = Some(match foreground {
                Some(bounds) => BabyObjectMatchSheetCellBounds {
                    x0: bounds.x0.min(x),
                    y0: bounds.y0.min(y),
                    x1: bounds.x1.max(x.saturating_add(1)),
                    y1: bounds.y1.max(y.saturating_add(1)),
                },
                None => BabyObjectMatchSheetCellBounds {
                    x0: x,
                    y0: y,
                    x1: x.saturating_add(1),
                    y1: y.saturating_add(1),
                },
            });
        }
    }

    let min_foreground_pixels = (cell.area() / 360).clamp(16, 240);
    foreground.filter(|bounds| {
        foreground_pixels >= min_foreground_pixels && bounds.width() > 2 && bounds.height() > 2
    })
}

fn apply_baby_object_match_sheet_background_alpha(
    source: image::DynamicImage,
) -> image::DynamicImage {
    let mut image = source.to_rgba8();
    let (width, height) = image.dimensions();
    if width == 0 || height == 0 {
        return image::DynamicImage::ImageRgba8(image);
    }

    for slot in BabyObjectMatchSheetSlot::ALL {
        let cell =
            resolve_baby_object_match_sheet_cell_bounds(width, height, slot.row(), slot.col());
        remove_baby_object_match_sheet_cell_background(
            image.as_mut(),
            width as usize,
            height as usize,
            cell,
        );
    }

    image::DynamicImage::ImageRgba8(image)
}

fn remove_baby_object_match_sheet_cell_background(
    pixels: &mut [u8],
    image_width: usize,
    image_height: usize,
    cell: BabyObjectMatchSheetCellBounds,
) -> bool {
    let pixel_count = image_width.saturating_mul(image_height);
    if pixel_count == 0 || pixels.len() < pixel_count.saturating_mul(4) {
        return false;
    }

    let background =
        sample_baby_object_match_sheet_cell_background(pixels, image_width, image_height, cell);
    let mut background_mask = vec![0u8; pixel_count];
    let mut queue = Vec::<usize>::new();
    let mut queue_index = 0usize;
    let mut changed = false;

    let mut seed_background_pixel = |x: u32, y: u32| {
        let pixel_index = y as usize * image_width + x as usize;
        if background_mask[pixel_index] != 0 {
            return;
        }
        let offset = pixel_index * 4;
        let pixel = [
            pixels[offset],
            pixels[offset + 1],
            pixels[offset + 2],
            pixels[offset + 3],
        ];
        if !is_baby_object_match_sheet_background_pixel(pixel, background) {
            return;
        }
        background_mask[pixel_index] = 1;
        queue.push(pixel_index);
    };

    for x in cell.x0..cell.x1 {
        seed_background_pixel(x, cell.y0);
        seed_background_pixel(x, cell.y1.saturating_sub(1));
    }
    for y in cell.y0.saturating_add(1)..cell.y1.saturating_sub(1) {
        seed_background_pixel(cell.x0, y);
        seed_background_pixel(cell.x1.saturating_sub(1), y);
    }

    while queue_index < queue.len() {
        let pixel_index = queue[queue_index];
        queue_index += 1;

        let x = (pixel_index % image_width) as u32;
        let y = (pixel_index / image_width) as u32;
        let neighbors = [
            (x.saturating_sub(1), y, x > cell.x0),
            (x.saturating_add(1), y, x + 1 < cell.x1),
            (x, y.saturating_sub(1), y > cell.y0),
            (x, y.saturating_add(1), y + 1 < cell.y1),
        ];

        for (next_x, next_y, within_cell) in neighbors {
            if !within_cell || next_x as usize >= image_width || next_y as usize >= image_height {
                continue;
            }
            let next_pixel_index = next_y as usize * image_width + next_x as usize;
            if background_mask[next_pixel_index] != 0 {
                continue;
            }
            let offset = next_pixel_index * 4;
            let pixel = [
                pixels[offset],
                pixels[offset + 1],
                pixels[offset + 2],
                pixels[offset + 3],
            ];
            if !is_baby_object_match_sheet_background_pixel(pixel, background) {
                continue;
            }
            background_mask[next_pixel_index] = 1;
            queue.push(next_pixel_index);
        }
    }

    for y in cell.y0..cell.y1 {
        for x in cell.x0..cell.x1 {
            let pixel_index = y as usize * image_width + x as usize;
            if background_mask[pixel_index] == 0 {
                continue;
            }
            let alpha_offset = pixel_index * 4 + 3;
            if pixels[alpha_offset] != 0 {
                pixels[alpha_offset] = 0;
                changed = true;
            }
        }
    }

    changed
}

fn sample_baby_object_match_sheet_cell_background(
    pixels: &[u8],
    image_width: usize,
    image_height: usize,
    cell: BabyObjectMatchSheetCellBounds,
) -> [u8; 4] {
    let sample_size = (cell.width().min(cell.height()) / 12).clamp(2, 8);
    let sample_points = [
        (cell.x0, cell.y0),
        (cell.x1.saturating_sub(sample_size), cell.y0),
        (cell.x0, cell.y1.saturating_sub(sample_size)),
        (
            cell.x1.saturating_sub(sample_size),
            cell.y1.saturating_sub(sample_size),
        ),
    ];
    let mut samples = Vec::new();

    for (start_x, start_y) in sample_points {
        let mut totals = [0u32; 4];
        let mut count = 0u32;
        for y in start_y..start_y.saturating_add(sample_size).min(cell.y1) {
            if y as usize >= image_height {
                continue;
            }
            for x in start_x..start_x.saturating_add(sample_size).min(cell.x1) {
                if x as usize >= image_width {
                    continue;
                }
                let offset = (y as usize * image_width + x as usize) * 4;
                totals[0] = totals[0].saturating_add(pixels[offset] as u32);
                totals[1] = totals[1].saturating_add(pixels[offset + 1] as u32);
                totals[2] = totals[2].saturating_add(pixels[offset + 2] as u32);
                totals[3] = totals[3].saturating_add(pixels[offset + 3] as u32);
                count = count.saturating_add(1);
            }
        }
        if count > 0 {
            samples.push([
                (totals[0] / count) as u8,
                (totals[1] / count) as u8,
                (totals[2] / count) as u8,
                (totals[3] / count) as u8,
            ]);
        }
    }

    samples
        .into_iter()
        .min_by_key(|sample| {
            let luminance = sample[0] as u16 + sample[1] as u16 + sample[2] as u16;
            (sample[3] as u16, u16::MAX.saturating_sub(luminance))
        })
        .unwrap_or([255, 255, 255, 255])
}

fn is_baby_object_match_sheet_background_pixel(pixel: [u8; 4], background: [u8; 4]) -> bool {
    if pixel[3] <= 32 {
        return true;
    }
    if background[3] <= 32 {
        return pixel[3] <= 48;
    }

    let color_diff = (pixel[0] as i32 - background[0] as i32).abs()
        + (pixel[1] as i32 - background[1] as i32).abs()
        + (pixel[2] as i32 - background[2] as i32).abs();
    if color_diff <= 58 {
        return true;
    }

    let background_luminance = background[0] as u16 + background[1] as u16 + background[2] as u16;
    let pixel_luminance = pixel[0] as u16 + pixel[1] as u16 + pixel[2] as u16;
    background_luminance >= 720 && pixel_luminance >= 720 && color_diff <= 96
}

impl BabyObjectMatchSheetCellBounds {
    fn width(self) -> u32 {
        self.x1.saturating_sub(self.x0).max(1)
    }

    fn height(self) -> u32 {
        self.y1.saturating_sub(self.y0).max(1)
    }

    fn area(self) -> u32 {
        self.width().saturating_mul(self.height())
    }

    fn to_crop_tuple(self) -> (u32, u32, u32, u32) {
        (self.x0, self.y0, self.width(), self.height())
    }
}

fn build_png_data_url(image: DownloadedOpenAiImage) -> Result<String, AppError> {
    let png_bytes = normalize_generated_image_to_png(image.bytes.as_slice())?;
    Ok(format!(
        "data:image/png;base64,{}",
        BASE64_STANDARD.encode(png_bytes)
    ))
}

fn normalize_generated_image_to_png(source: &[u8]) -> Result<Vec<u8>, AppError> {
    let rgba_image = image::load_from_memory(source)
        .map_err(|error| {
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": "vector-engine",
                "message": format!("解析宝贝识物物品图片失败：{error}"),
            }))
        })?
        .to_rgba8();
    let (width, height) = rgba_image.dimensions();
    let mut encoded = Vec::new();
    let encoder = PngEncoder::new(&mut encoded);
    encoder
        .write_image(rgba_image.as_raw(), width, height, ColorType::Rgba8.into())
        .map_err(|error| {
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": "vector-engine",
                "message": format!("转换宝贝识物物品图片为 PNG 失败：{error}"),
            }))
        })?;

    Ok(encoded)
}

fn encode_baby_object_match_dynamic_image_data_url(
    image: image::DynamicImage,
    clean_white_edge_matte: bool,
) -> Result<String, AppError> {
    let mut rgba_image = image.to_rgba8();
    if clean_white_edge_matte {
        remove_baby_object_match_basket_white_matte(&mut rgba_image);
    }
    let (width, height) = rgba_image.dimensions();
    let mut encoded = Vec::new();
    let encoder = PngEncoder::new(&mut encoded);
    encoder
        .write_image(rgba_image.as_raw(), width, height, ColorType::Rgba8.into())
        .map_err(|error| {
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": "vector-engine",
                "message": format!("编码宝贝识物 2x2 素材切图失败：{error}"),
            }))
        })?;
    Ok(format!(
        "data:image/png;base64,{}",
        BASE64_STANDARD.encode(encoded)
    ))
}

fn remove_baby_object_match_basket_white_matte(image: &mut image::RgbaImage) -> bool {
    let mut changed = false;
    for pixel in image.pixels_mut() {
        let [red, green, blue, alpha] = pixel.0;
        if alpha <= 24 {
            continue;
        }

        let max_channel = red.max(green).max(blue);
        let min_channel = red.min(green).min(blue);
        let luminance = red as u16 + green as u16 + blue as u16;
        let channel_spread = max_channel.saturating_sub(min_channel);
        if luminance < 690 || channel_spread > 42 {
            continue;
        }

        let next_alpha = if luminance >= 735 && channel_spread <= 30 {
            0
        } else {
            ((alpha as f32) * 0.18).round() as u8
        };
        if next_alpha != alpha {
            pixel.0[3] = next_alpha;
            changed = true;
        }
    }

    changed
}

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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sheet_prompt_locks_two_by_two_asset_layout() {
        let names = vec!["苹果".to_string(), "香蕉".to_string()];
        let theme_prompt = build_baby_object_match_visual_theme_prompt(names.as_slice());
        let prompt = build_baby_object_match_sheet_prompt(names.as_slice(), theme_prompt.as_str());

        assert!(prompt.contains("苹果"));
        assert!(prompt.contains("香蕉"));
        assert!(prompt.contains("2x2"));
        assert!(prompt.contains("左上格"));
        assert!(prompt.contains("右上格"));
        assert!(prompt.contains("左下格"));
        assert!(prompt.contains("右下格"));
        assert!(prompt.contains("卡通绘本"));
        assert!(prompt.contains("白底描边"));
        assert!(prompt.contains("纯白"));
    }

    #[test]
    fn visual_theme_prompt_maps_fruit_keywords_to_nature_theme() {
        let names = vec!["苹果".to_string(), "橘子".to_string()];
        let prompt = build_baby_object_match_visual_theme_prompt(names.as_slice());

        assert!(prompt.contains("寓教于乐"));
        assert!(prompt.contains("卡通绘本"));
        assert!(prompt.contains("果园"));
        assert!(prompt.contains("自然"));
    }

    #[test]
    fn visual_theme_prompt_maps_character_keywords_to_toy_theme() {
        let names = vec!["小猪佩琪".to_string(), "奥特曼".to_string()];
        let prompt = build_baby_object_match_visual_theme_prompt(names.as_slice());

        assert!(prompt.contains("寓教于乐"));
        assert!(prompt.contains("动漫"));
        assert!(prompt.contains("玩具"));
    }

    #[test]
    fn visual_asset_prompt_keeps_background_clear_for_playfield() {
        let names = vec!["苹果".to_string(), "香蕉".to_string()];
        let theme_prompt = build_baby_object_match_visual_theme_prompt(names.as_slice());
        let prompt = build_baby_object_match_visual_asset_prompt(
            BabyObjectMatchVisualAssetKind::Background,
            names.as_slice(),
            theme_prompt.as_str(),
        );

        assert!(prompt.contains("背景环境图"));
        assert!(prompt.contains("中间"));
        assert!(prompt.contains("屏幕中下方"));
        assert!(prompt.contains("无文字"));
    }

    #[test]
    fn normalize_item_names_requires_two_non_empty_names() {
        let names = normalize_item_names(vec![" 苹果 ".to_string(), "香蕉".to_string()])
            .expect("two names should be valid");

        assert_eq!(names, vec!["苹果".to_string(), "香蕉".to_string()]);
        assert!(normalize_item_names(vec!["苹果".to_string()]).is_err());
        assert!(normalize_item_names(vec!["苹果".to_string(), " ".to_string()]).is_err());
    }

    #[test]
    fn baby_object_match_image_timeout_keeps_long_generation_alive() {
        let settings = with_baby_object_match_image_timeout(OpenAiImageSettings {
            base_url: "https://vector.example".to_string(),
            api_key: "secret".to_string(),
            request_timeout_ms: 180_000,
        });

        assert_eq!(
            settings.request_timeout_ms,
            DEFAULT_VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS
        );
    }

    #[test]
    fn slices_two_by_two_sheet_into_transparent_asset_data_urls() {
        let width = 96;
        let height = 96;
        let mut sheet =
            image::RgbaImage::from_pixel(width, height, image::Rgba([255, 255, 255, 255]));
        let slots = [
            (8..40, 8..40, [220, 32, 48, 255]),
            (56..88, 8..40, [250, 210, 70, 255]),
            (8..40, 56..88, [42, 142, 92, 255]),
            (56..88, 56..88, [92, 120, 230, 255]),
        ];
        for (xs, ys, color) in slots {
            for y in ys {
                for x in xs.clone() {
                    sheet.put_pixel(x, y, image::Rgba(color));
                }
            }
        }
        let mut bytes = Vec::new();
        let encoder = PngEncoder::new(&mut bytes);
        encoder
            .write_image(sheet.as_raw(), width, height, ColorType::Rgba8.into())
            .expect("test sheet should encode");

        let sliced = slice_baby_object_match_sheet(&DownloadedOpenAiImage {
            bytes,
            mime_type: "image/png".to_string(),
            extension: "png".to_string(),
        })
        .expect("sheet should slice");

        for slot in BabyObjectMatchSheetSlot::ALL {
            let data_url = sliced.slot_data_url(slot);
            assert!(data_url.starts_with("data:image/png;base64,"));
            let payload = data_url
                .strip_prefix("data:image/png;base64,")
                .expect("data url should include png prefix");
            let png_bytes = BASE64_STANDARD
                .decode(payload)
                .expect("data url should decode");
            let decoded = image::load_from_memory(png_bytes.as_slice())
                .expect("slice should decode")
                .to_rgba8();
            assert!(
                decoded.pixels().any(|pixel| pixel[3] == 0),
                "sheet white background should become transparent"
            );
            assert!(
                decoded.pixels().any(|pixel| pixel[3] > 200),
                "slice should keep foreground pixels"
            );
        }
    }

    #[test]
    fn basket_white_matte_cleanup_removes_enclosed_white_handle_fill() {
        let mut basket = image::RgbaImage::from_pixel(48, 48, image::Rgba([0, 0, 0, 0]));
        for y in 12..36 {
            for x in 8..40 {
                basket.put_pixel(x, y, image::Rgba([186, 92, 24, 255]));
            }
        }
        for y in 4..14 {
            for x in 12..20 {
                basket.put_pixel(x, y, image::Rgba([252, 251, 246, 255]));
            }
        }
        for y in 4..14 {
            for x in 28..36 {
                basket.put_pixel(x, y, image::Rgba([249, 248, 242, 255]));
            }
        }

        assert!(remove_baby_object_match_basket_white_matte(&mut basket));
        assert_eq!(basket.get_pixel(16, 8).0[3], 0);
        assert_eq!(basket.get_pixel(32, 8).0[3], 0);
        assert_eq!(basket.get_pixel(20, 20).0[3], 255);
    }
}