use std::time::Duration;

use axum::{
    Json,
    extract::{State, rejection::JsonRejection},
    http::StatusCode,
    response::Response,
};
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
use reqwest::{header, multipart};
use serde_json::{Value, json};
use shared_contracts::hyper3d as contract;

use crate::{
    api_response::json_success_body, http_error::AppError, request_context::RequestContext,
    state::AppState,
};

const HYPER3D_PROVIDER: &str = "hyper3d-rodin";
const RODIN_GEN2_TIER: &str = "Gen-2";
const DEFAULT_GEOMETRY_FILE_FORMAT: &str = "glb";
const DEFAULT_MATERIAL: &str = "PBR";
const DEFAULT_QUALITY: &str = "medium";
const DEFAULT_MESH_MODE: &str = "Quad";
const DEFAULT_CONDITION_MODE: &str = "concat";
const MAX_PROMPT_CHARS: usize = 2_000;
const MAX_NEGATIVE_PROMPT_CHARS: usize = 1_000;
const MAX_IMAGE_COUNT: usize = 5;
const MAX_IMAGE_BYTES: usize = 10 * 1024 * 1024;

#[derive(Clone, Debug)]
struct Hyper3dSettings {
    base_url: String,
    api_key: String,
    request_timeout_ms: u64,
}

#[derive(Clone, Debug)]
struct DecodedImageDataUrl {
    bytes: Vec<u8>,
    mime_type: String,
    file_name: String,
}

#[derive(Clone, Debug)]
struct SubmitOptions {
    seed: Option<u32>,
    geometry_file_format: String,
    material: String,
    quality: String,
    mesh_mode: String,
    addons: Vec<String>,
    bbox_condition: Option<Vec<f32>>,
    preview_render: bool,
}

pub async fn submit_hyper3d_text_to_model(
    State(state): State<AppState>,
    axum::extract::Extension(request_context): axum::extract::Extension<RequestContext>,
    payload: Result<Json<contract::Hyper3dTextToModelRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = parse_json_payload(&request_context, payload)?;
    submit_text_to_model(&state, payload)
        .await
        .map(|payload| json_success_body(Some(&request_context), payload))
        .map_err(|error| error.into_response_with_context(Some(&request_context)))
}

pub async fn submit_hyper3d_image_to_model(
    State(state): State<AppState>,
    axum::extract::Extension(request_context): axum::extract::Extension<RequestContext>,
    payload: Result<Json<contract::Hyper3dImageToModelRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = parse_json_payload(&request_context, payload)?;
    submit_image_to_model(&state, payload)
        .await
        .map(|payload| json_success_body(Some(&request_context), payload))
        .map_err(|error| error.into_response_with_context(Some(&request_context)))
}

pub async fn get_hyper3d_task_status(
    State(state): State<AppState>,
    axum::extract::Extension(request_context): axum::extract::Extension<RequestContext>,
    payload: Result<Json<contract::Hyper3dTaskStatusRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = parse_json_payload(&request_context, payload)?;
    query_task_status(&state, payload)
        .await
        .map(|payload| json_success_body(Some(&request_context), payload))
        .map_err(|error| error.into_response_with_context(Some(&request_context)))
}

pub async fn get_hyper3d_downloads(
    State(state): State<AppState>,
    axum::extract::Extension(request_context): axum::extract::Extension<RequestContext>,
    payload: Result<Json<contract::Hyper3dDownloadRequest>, JsonRejection>,
) -> Result<Json<Value>, Response> {
    let Json(payload) = parse_json_payload(&request_context, payload)?;
    query_downloads(&state, payload)
        .await
        .map(|payload| json_success_body(Some(&request_context), payload))
        .map_err(|error| error.into_response_with_context(Some(&request_context)))
}

async fn submit_text_to_model(
    state: &AppState,
    payload: contract::Hyper3dTextToModelRequest,
) -> Result<contract::Hyper3dTaskSubmitResponse, AppError> {
    let settings = require_hyper3d_settings(state)?;
    let http_client = build_hyper3d_http_client(&settings)?;
    let prompt = normalize_required_text(&payload.prompt, "prompt", MAX_PROMPT_CHARS)?;
    let options = SubmitOptions::from_text_request(&payload)?;
    let mut form = multipart::Form::new()
        .text("tier", RODIN_GEN2_TIER.to_string())
        .text("prompt", prompt);
    form = append_common_submit_fields(form, &options)?;
    if let Some(negative_prompt) = normalize_optional_limited_text(
        payload.negative_prompt.as_deref(),
        MAX_NEGATIVE_PROMPT_CHARS,
    )? {
        form = form.text("negative_prompt", negative_prompt);
    }

    let response = post_hyper3d_multipart(
        &http_client,
        &settings,
        "/rodin",
        form,
        "提交 Hyper3D 文生模型任务失败",
    )
    .await?;

    Ok(build_submit_response(
        contract::Hyper3dGenerationMode::TextToModel,
        response,
    )?)
}

pub(crate) async fn submit_image_to_model(
    state: &AppState,
    payload: contract::Hyper3dImageToModelRequest,
) -> Result<contract::Hyper3dTaskSubmitResponse, AppError> {
    let settings = require_hyper3d_settings(state)?;
    let http_client = build_hyper3d_http_client(&settings)?;
    let options = SubmitOptions::from_image_request(&payload)?;
    let mut form = multipart::Form::new().text("tier", RODIN_GEN2_TIER.to_string());
    form = append_common_submit_fields(form, &options)?;
    let condition_mode = normalize_enum(
        payload.condition_mode.as_deref(),
        DEFAULT_CONDITION_MODE,
        &["concat", "fuse"],
        "conditionMode",
    )?;
    form = form.text("condition_mode", condition_mode);
    if let Some(prompt) =
        normalize_optional_limited_text(payload.prompt.as_deref(), MAX_PROMPT_CHARS)?
    {
        form = form.text("prompt", prompt);
    }
    for image_url in payload
        .image_urls
        .iter()
        .map(|value| value.trim())
        .filter(|value| !value.is_empty())
    {
        form = form.text("image_urls", image_url.to_string());
    }
    for image in decode_image_data_urls(&payload.image_data_urls)? {
        let part = multipart::Part::bytes(image.bytes)
            .file_name(image.file_name)
            .mime_str(&image.mime_type)
            .map_err(|error| {
                AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                    "provider": HYPER3D_PROVIDER,
                    "message": format!("构造图生模型图片字段失败：{error}"),
                }))
            })?;
        form = form.part("images", part);
    }

    if payload.image_data_urls.is_empty() && payload.image_urls.is_empty() {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "field": "imageDataUrls",
                "message": "图生模型至少需要一张参考图",
            })),
        );
    }
    if payload.image_data_urls.len() + payload.image_urls.len() > MAX_IMAGE_COUNT {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "field": "imageDataUrls",
                "message": format!("图生模型最多支持 {} 张参考图", MAX_IMAGE_COUNT),
            })),
        );
    }

    let response = post_hyper3d_multipart(
        &http_client,
        &settings,
        "/rodin",
        form,
        "提交 Hyper3D 图生模型任务失败",
    )
    .await?;

    Ok(build_submit_response(
        contract::Hyper3dGenerationMode::ImageToModel,
        response,
    )?)
}

pub(crate) async fn query_task_status(
    state: &AppState,
    payload: contract::Hyper3dTaskStatusRequest,
) -> Result<contract::Hyper3dTaskStatusResponse, AppError> {
    let settings = require_hyper3d_settings(state)?;
    let http_client = build_hyper3d_http_client(&settings)?;
    // 中文注释：Hyper3D 返回的 subscriptionKey 是上游 opaque token，只做非空校验，不做人为 256 字符截断。
    let subscription_key =
        normalize_required_opaque_text(&payload.subscription_key, "subscriptionKey")?;
    let response = post_hyper3d_json(
        &http_client,
        &settings,
        "/status",
        json!({ "subscription_key": subscription_key }),
        "查询 Hyper3D 模型任务状态失败",
    )
    .await?;

    let jobs = extract_job_statuses(&response);
    let status = normalize_task_status(
        find_first_string_by_key(&response, "status")
            .or_else(|| jobs.first().map(|job| job.status.clone()))
            .as_deref()
            .unwrap_or("unknown"),
    );

    Ok(contract::Hyper3dTaskStatusResponse {
        ok: true,
        provider: HYPER3D_PROVIDER.to_string(),
        status,
        jobs,
        raw: response,
    })
}

pub(crate) async fn query_downloads(
    state: &AppState,
    payload: contract::Hyper3dDownloadRequest,
) -> Result<contract::Hyper3dDownloadResponse, AppError> {
    let settings = require_hyper3d_settings(state)?;
    let http_client = build_hyper3d_http_client(&settings)?;
    let task_uuid = normalize_required_text(&payload.task_uuid, "taskUuid", 256)?;
    let response = post_hyper3d_json(
        &http_client,
        &settings,
        "/download",
        json!({ "task_uuid": task_uuid }),
        "获取 Hyper3D 模型下载列表失败",
    )
    .await?;

    Ok(contract::Hyper3dDownloadResponse {
        ok: true,
        provider: HYPER3D_PROVIDER.to_string(),
        files: extract_download_files(&response),
        raw: response,
    })
}

impl SubmitOptions {
    fn from_text_request(payload: &contract::Hyper3dTextToModelRequest) -> Result<Self, AppError> {
        Self::new(
            payload.seed,
            payload.geometry_file_format.as_deref(),
            payload.material.as_deref(),
            payload.quality.as_deref(),
            payload.mesh_mode.as_deref(),
            payload.addons.clone(),
            payload.bbox_condition.clone(),
            payload.preview_render,
        )
    }

    fn from_image_request(
        payload: &contract::Hyper3dImageToModelRequest,
    ) -> Result<Self, AppError> {
        Self::new(
            payload.seed,
            payload.geometry_file_format.as_deref(),
            payload.material.as_deref(),
            payload.quality.as_deref(),
            payload.mesh_mode.as_deref(),
            payload.addons.clone(),
            payload.bbox_condition.clone(),
            payload.preview_render,
        )
    }

    #[allow(clippy::too_many_arguments)]
    fn new(
        seed: Option<u32>,
        geometry_file_format: Option<&str>,
        material: Option<&str>,
        quality: Option<&str>,
        mesh_mode: Option<&str>,
        addons: Vec<String>,
        bbox_condition: Option<Vec<f32>>,
        preview_render: Option<bool>,
    ) -> Result<Self, AppError> {
        Ok(Self {
            seed,
            geometry_file_format: normalize_enum(
                geometry_file_format,
                DEFAULT_GEOMETRY_FILE_FORMAT,
                &["glb", "usdz", "fbx", "obj", "stl"],
                "geometryFileFormat",
            )?,
            material: normalize_enum(
                material,
                DEFAULT_MATERIAL,
                &["PBR", "Shaded", "All"],
                "material",
            )?,
            quality: normalize_enum(
                quality,
                DEFAULT_QUALITY,
                &["high", "medium", "low", "extra-low"],
                "quality",
            )?,
            mesh_mode: normalize_enum(mesh_mode, DEFAULT_MESH_MODE, &["Quad", "Raw"], "meshMode")?,
            addons: normalize_addons(addons)?,
            bbox_condition: normalize_bbox_condition(bbox_condition)?,
            preview_render: preview_render.unwrap_or(true),
        })
    }
}

fn append_common_submit_fields(
    mut form: multipart::Form,
    options: &SubmitOptions,
) -> Result<multipart::Form, AppError> {
    form = form
        .text(
            "geometry_file_format",
            options.geometry_file_format.to_string(),
        )
        .text("material", options.material.to_string())
        .text("quality", options.quality.to_string())
        .text("mesh_mode", options.mesh_mode.to_string())
        .text("preview_render", options.preview_render.to_string());
    if let Some(seed) = options.seed {
        form = form.text("seed", seed.to_string());
    }
    for addon in &options.addons {
        form = form.text("addons", addon.to_string());
    }
    if let Some(bbox_condition) = &options.bbox_condition {
        form = form.text(
            "bbox_condition",
            serde_json::to_string(bbox_condition).map_err(|error| {
                AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                    "provider": HYPER3D_PROVIDER,
                    "field": "bboxCondition",
                    "message": format!("bboxCondition 序列化失败：{error}"),
                }))
            })?,
        );
    }

    Ok(form)
}

fn require_hyper3d_settings(state: &AppState) -> Result<Hyper3dSettings, AppError> {
    let base_url = state.config.hyper3d_base_url.trim().trim_end_matches('/');
    if base_url.is_empty() {
        return Err(
            AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "reason": "HYPER3D_BASE_URL 未配置",
                "message": "Hyper3D Rodin 服务地址未配置，请设置 HYPER3D_BASE_URL 或 RODIN_BASE_URL 后重启 api-server。",
            })),
        );
    }

    let api_key = state
        .config
        .hyper3d_api_key
        .as_deref()
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .ok_or_else(|| {
            AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "reason": "HYPER3D_API_KEY 未配置",
                "message": "Hyper3D Rodin API Key 未配置，请在本地私密环境设置 HYPER3D_API_KEY 或 RODIN_API_KEY 后重启 api-server。",
            }))
        })?;

    Ok(Hyper3dSettings {
        base_url: base_url.to_string(),
        api_key: api_key.to_string(),
        request_timeout_ms: state.config.hyper3d_model_request_timeout_ms.max(1),
    })
}

fn build_hyper3d_http_client(settings: &Hyper3dSettings) -> Result<reqwest::Client, AppError> {
    reqwest::Client::builder()
        .timeout(Duration::from_millis(settings.request_timeout_ms))
        .build()
        .map_err(|error| {
            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "message": format!("构造 Hyper3D HTTP 客户端失败：{error}"),
            }))
        })
}

async fn post_hyper3d_multipart(
    http_client: &reqwest::Client,
    settings: &Hyper3dSettings,
    path: &str,
    form: multipart::Form,
    failure_context: &str,
) -> Result<Value, AppError> {
    let response = http_client
        .post(format!("{}{}", settings.base_url, path))
        .header(
            header::AUTHORIZATION,
            format!("Bearer {}", settings.api_key),
        )
        .header(header::ACCEPT, "application/json")
        .multipart(form)
        .send()
        .await
        .map_err(|error| hyper3d_bad_gateway(format!("{failure_context}：{error}")))?;
    parse_hyper3d_response(response, failure_context).await
}

async fn post_hyper3d_json(
    http_client: &reqwest::Client,
    settings: &Hyper3dSettings,
    path: &str,
    body: Value,
    failure_context: &str,
) -> Result<Value, AppError> {
    let response = http_client
        .post(format!("{}{}", settings.base_url, path))
        .header(
            header::AUTHORIZATION,
            format!("Bearer {}", settings.api_key),
        )
        .header(header::ACCEPT, "application/json")
        .header(header::CONTENT_TYPE, "application/json")
        .json(&body)
        .send()
        .await
        .map_err(|error| hyper3d_bad_gateway(format!("{failure_context}：{error}")))?;
    parse_hyper3d_response(response, failure_context).await
}

async fn parse_hyper3d_response(
    response: reqwest::Response,
    failure_context: &str,
) -> Result<Value, AppError> {
    let status = response.status();
    let raw_text = response.text().await.map_err(|error| {
        hyper3d_bad_gateway(format!("{failure_context}：读取上游响应失败：{error}"))
    })?;
    if !status.is_success() {
        return Err(
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "message": parse_api_error_message(&raw_text, failure_context),
                "status": status.as_u16(),
                "rawExcerpt": truncate_raw(&raw_text),
            })),
        );
    }

    serde_json::from_str::<Value>(&raw_text).map_err(|error| {
        AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
            "provider": HYPER3D_PROVIDER,
            "message": format!("{failure_context}：解析上游 JSON 失败：{error}"),
            "rawExcerpt": truncate_raw(&raw_text),
        }))
    })
}

fn build_submit_response(
    mode: contract::Hyper3dGenerationMode,
    response: Value,
) -> Result<contract::Hyper3dTaskSubmitResponse, AppError> {
    let task_uuid = find_root_string_by_keys(&response, &["uuid", "task_uuid", "taskUuid"])
        .or_else(|| find_first_string_by_keys(&response, &["task_uuid", "taskUuid"]))
        .ok_or_else(|| hyper3d_bad_gateway("Hyper3D 已响应，但未返回任务 uuid"))?;
    let subscription_key =
        find_root_string_by_keys(&response, &["subscription_key", "subscriptionKey"])
            .or_else(|| {
                find_first_string_by_keys(&response, &["subscription_key", "subscriptionKey"])
            })
            .ok_or_else(|| hyper3d_bad_gateway("Hyper3D 已响应，但未返回 subscription_key"))?;
    let job_uuids = extract_job_uuids(&response);
    let message = find_first_string_by_keys(&response, &["message", "detail"]);

    Ok(contract::Hyper3dTaskSubmitResponse {
        ok: true,
        provider: HYPER3D_PROVIDER.to_string(),
        mode,
        task_uuid,
        subscription_key,
        job_uuids,
        message,
        tier: RODIN_GEN2_TIER.to_string(),
    })
}

fn extract_job_statuses(payload: &Value) -> Vec<contract::Hyper3dJobStatusPayload> {
    let Some(array) = find_first_array_by_keys(payload, &["jobs", "tasks"]) else {
        return Vec::new();
    };

    array
        .iter()
        .filter_map(|value| {
            let status = find_first_string_by_keys(value, &["status", "state"])
                .map(|value| normalize_task_status(&value))?;
            Some(contract::Hyper3dJobStatusPayload {
                uuid: find_first_string_by_keys(value, &["uuid", "task_uuid", "taskUuid"]),
                progress: find_first_f64_by_keys(value, &["progress", "percentage"])
                    .map(|value| value as f32),
                message: find_first_string_by_keys(value, &["message", "detail", "error"]),
                status,
            })
        })
        .collect()
}

fn extract_job_uuids(payload: &Value) -> Vec<String> {
    let mut job_uuids = Vec::new();
    if let Some(jobs) = find_first_array_by_keys(payload, &["jobs"]) {
        for job in jobs {
            if let Some(uuid) = find_first_string_by_keys(job, &["uuid", "task_uuid", "taskUuid"])
                && !job_uuids.contains(&uuid)
            {
                job_uuids.push(uuid);
            }
        }
    }
    for uuid in collect_strings_by_keys(payload, &["job_uuids", "jobUuids", "uuids"]) {
        if !job_uuids.contains(&uuid) {
            job_uuids.push(uuid);
        }
    }
    job_uuids
}

fn extract_download_files(payload: &Value) -> Vec<contract::Hyper3dDownloadFilePayload> {
    let mut files = Vec::new();
    collect_download_files(payload, &mut files);
    let mut deduped = Vec::new();
    for file in files {
        if !deduped
            .iter()
            .any(|entry: &contract::Hyper3dDownloadFilePayload| entry.url == file.url)
        {
            deduped.push(file);
        }
    }
    deduped
}

fn collect_download_files(value: &Value, output: &mut Vec<contract::Hyper3dDownloadFilePayload>) {
    match value {
        Value::Object(object) => {
            let maybe_url = object
                .get("url")
                .or_else(|| object.get("download_url"))
                .or_else(|| object.get("downloadUrl"))
                .and_then(Value::as_str)
                .map(str::trim)
                .filter(|value| value.starts_with("http://") || value.starts_with("https://"));
            if let Some(url) = maybe_url {
                let name = object
                    .get("name")
                    .or_else(|| object.get("file_name"))
                    .or_else(|| object.get("filename"))
                    .and_then(Value::as_str)
                    .map(str::trim)
                    .filter(|value| !value.is_empty())
                    .unwrap_or("model")
                    .to_string();
                output.push(contract::Hyper3dDownloadFilePayload {
                    name,
                    url: url.to_string(),
                });
            }
            for nested in object.values() {
                collect_download_files(nested, output);
            }
        }
        Value::Array(items) => {
            for item in items {
                collect_download_files(item, output);
            }
        }
        _ => {}
    }
}

fn decode_image_data_urls(values: &[String]) -> Result<Vec<DecodedImageDataUrl>, AppError> {
    values
        .iter()
        .enumerate()
        .map(|(index, value)| decode_image_data_url(value, index + 1))
        .collect()
}

fn decode_image_data_url(value: &str, index: usize) -> Result<DecodedImageDataUrl, AppError> {
    let value = value.trim();
    let Some((metadata, encoded)) = value.split_once(',') else {
        return Err(invalid_image_data_url("参考图必须是 data URL"));
    };
    if !metadata.starts_with("data:image/") || !metadata.ends_with(";base64") {
        return Err(invalid_image_data_url(
            "参考图只支持 image/png、image/jpeg 或 image/webp 的 base64 data URL",
        ));
    }
    let mime_type = metadata
        .trim_start_matches("data:")
        .trim_end_matches(";base64")
        .to_string();
    let extension = match mime_type.as_str() {
        "image/png" => "png",
        "image/jpeg" | "image/jpg" => "jpg",
        "image/webp" => "webp",
        _ => {
            return Err(invalid_image_data_url(
                "参考图只支持 image/png、image/jpeg 或 image/webp",
            ));
        }
    };
    let bytes = BASE64_STANDARD
        .decode(encoded)
        .map_err(|_| invalid_image_data_url("参考图 base64 解码失败"))?;
    if bytes.is_empty() || bytes.len() > MAX_IMAGE_BYTES {
        return Err(invalid_image_data_url("参考图为空或超过 10MB"));
    }

    Ok(DecodedImageDataUrl {
        bytes,
        mime_type,
        file_name: format!("reference-{index:02}.{extension}"),
    })
}

fn invalid_image_data_url(message: &str) -> AppError {
    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
        "provider": HYPER3D_PROVIDER,
        "field": "imageDataUrls",
        "message": message,
    }))
}

fn normalize_required_text(
    value: &str,
    field: &'static str,
    max_chars: usize,
) -> Result<String, AppError> {
    let normalized = value.trim().to_string();
    if normalized.is_empty() {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "field": field,
                "message": format!("{field} 不能为空"),
            })),
        );
    }
    if normalized.chars().count() > max_chars {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "field": field,
                "message": format!("{field} 超过 {} 字符", max_chars),
            })),
        );
    }
    Ok(normalized)
}

fn normalize_required_opaque_text(value: &str, field: &'static str) -> Result<String, AppError> {
    let normalized = value.trim().to_string();
    if normalized.is_empty() {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "field": field,
                "message": format!("{field} 不能为空"),
            })),
        );
    }

    Ok(normalized)
}

fn normalize_optional_limited_text(
    value: Option<&str>,
    max_chars: usize,
) -> Result<Option<String>, AppError> {
    let Some(normalized) = value.map(str::trim).filter(|value| !value.is_empty()) else {
        return Ok(None);
    };
    if normalized.chars().count() > max_chars {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "message": format!("文本超过 {} 字符", max_chars),
            })),
        );
    }
    Ok(Some(normalized.to_string()))
}

fn normalize_enum(
    value: Option<&str>,
    default_value: &str,
    allowed_values: &[&str],
    field: &'static str,
) -> Result<String, AppError> {
    let value = value
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .unwrap_or(default_value);
    if let Some(allowed) = allowed_values
        .iter()
        .find(|allowed| allowed.eq_ignore_ascii_case(value))
    {
        return Ok((*allowed).to_string());
    }

    Err(
        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
            "provider": HYPER3D_PROVIDER,
            "field": field,
            "message": format!("{} 取值非法", field),
            "allowed": allowed_values,
        })),
    )
}

fn normalize_addons(values: Vec<String>) -> Result<Vec<String>, AppError> {
    let mut addons = Vec::new();
    for value in values {
        let value = value.trim();
        if value.is_empty() {
            continue;
        }
        if value != "HighPack" {
            return Err(
                AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                    "provider": HYPER3D_PROVIDER,
                    "field": "addons",
                    "message": "addons 首版只支持 HighPack",
                })),
            );
        }
        if !addons.iter().any(|addon| addon == value) {
            addons.push(value.to_string());
        }
    }
    Ok(addons)
}

fn normalize_bbox_condition(value: Option<Vec<f32>>) -> Result<Option<Vec<f32>>, AppError> {
    let Some(value) = value else {
        return Ok(None);
    };
    if value.len() != 3 || value.iter().any(|item| !item.is_finite() || *item <= 0.0) {
        return Err(
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
                "provider": HYPER3D_PROVIDER,
                "field": "bboxCondition",
                "message": "bboxCondition 必须包含 3 个正数",
            })),
        );
    }
    Ok(Some(value))
}

fn normalize_task_status(status: &str) -> String {
    match status.trim().to_ascii_lowercase().as_str() {
        "waiting" | "pending" | "queued" => "waiting".to_string(),
        "generating" | "running" | "processing" => "generating".to_string(),
        "done" | "finished" | "completed" | "success" | "succeeded" => "done".to_string(),
        "failed" | "error" | "canceled" | "cancelled" => "failed".to_string(),
        _ => "unknown".to_string(),
    }
}

fn parse_api_error_message(raw_text: &str, fallback_message: &str) -> String {
    if let Ok(parsed) = serde_json::from_str::<Value>(raw_text) {
        for key in ["message", "detail", "error"] {
            if let Some(message) = find_first_string_by_key(&parsed, key)
                && !message.trim().is_empty()
            {
                return message;
            }
        }
    }
    raw_text
        .trim()
        .chars()
        .take(240)
        .collect::<String>()
        .trim()
        .to_string()
        .chars()
        .next()
        .map(|_| raw_text.trim().chars().take(240).collect())
        .unwrap_or_else(|| fallback_message.to_string())
}

fn find_first_array_by_keys<'a>(value: &'a Value, keys: &[&str]) -> Option<&'a Vec<Value>> {
    match value {
        Value::Object(object) => {
            for (key, value) in object {
                if keys.iter().any(|target| key.eq_ignore_ascii_case(target))
                    && let Some(array) = value.as_array()
                {
                    return Some(array);
                }
                if let Some(found) = find_first_array_by_keys(value, keys) {
                    return Some(found);
                }
            }
            None
        }
        Value::Array(items) => items
            .iter()
            .find_map(|item| find_first_array_by_keys(item, keys)),
        _ => None,
    }
}

fn find_first_string_by_keys(value: &Value, keys: &[&str]) -> Option<String> {
    keys.iter()
        .find_map(|key| find_first_string_by_key(value, key))
}

fn find_root_string_by_keys(value: &Value, keys: &[&str]) -> Option<String> {
    let object = value.as_object()?;
    for key in keys {
        if let Some(text) = object
            .iter()
            .find(|(candidate, _)| candidate.eq_ignore_ascii_case(key))
            .and_then(|(_, value)| value.as_str())
            .map(str::trim)
            .filter(|value| !value.is_empty())
        {
            return Some(text.to_string());
        }
    }
    None
}

fn find_first_string_by_key(value: &Value, target_key: &str) -> Option<String> {
    match value {
        Value::Object(object) => {
            for (key, value) in object {
                if key.eq_ignore_ascii_case(target_key)
                    && let Some(text) = value.as_str()
                {
                    return Some(text.trim().to_string());
                }
                if let Some(found) = find_first_string_by_key(value, target_key) {
                    return Some(found);
                }
            }
            None
        }
        Value::Array(items) => items
            .iter()
            .find_map(|item| find_first_string_by_key(item, target_key)),
        _ => None,
    }
}

fn find_first_f64_by_keys(value: &Value, keys: &[&str]) -> Option<f64> {
    match value {
        Value::Object(object) => {
            for (key, value) in object {
                if keys.iter().any(|target| key.eq_ignore_ascii_case(target))
                    && let Some(number) = value.as_f64()
                {
                    return Some(number);
                }
                if let Some(found) = find_first_f64_by_keys(value, keys) {
                    return Some(found);
                }
            }
            None
        }
        Value::Array(items) => items
            .iter()
            .find_map(|item| find_first_f64_by_keys(item, keys)),
        _ => None,
    }
}

fn collect_strings_by_keys(value: &Value, keys: &[&str]) -> Vec<String> {
    let mut results = Vec::new();
    collect_strings(value, keys, &mut results);
    let mut deduped = Vec::new();
    for result in results {
        if !deduped.contains(&result) {
            deduped.push(result);
        }
    }
    deduped
}

fn collect_strings(value: &Value, keys: &[&str], output: &mut Vec<String>) {
    match value {
        Value::Object(object) => {
            for (key, value) in object {
                if keys.iter().any(|target| key.eq_ignore_ascii_case(target)) {
                    match value {
                        Value::String(text) if !text.trim().is_empty() => {
                            output.push(text.trim().to_string());
                        }
                        Value::Array(items) => {
                            for item in items {
                                if let Some(text) = item.as_str().map(str::trim)
                                    && !text.is_empty()
                                {
                                    output.push(text.to_string());
                                }
                            }
                        }
                        _ => {}
                    }
                }
                collect_strings(value, keys, output);
            }
        }
        Value::Array(items) => {
            for item in items {
                collect_strings(item, keys, output);
            }
        }
        _ => {}
    }
}

fn truncate_raw(raw_text: &str) -> String {
    raw_text.chars().take(800).collect()
}

fn hyper3d_bad_gateway(message: impl Into<String>) -> AppError {
    AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
        "provider": HYPER3D_PROVIDER,
        "message": message.into(),
    }))
}

fn parse_json_payload<T>(
    request_context: &RequestContext,
    payload: Result<Json<T>, JsonRejection>,
) -> Result<Json<T>, Response> {
    payload.map_err(|rejection| {
        AppError::from_status(StatusCode::BAD_REQUEST)
            .with_message(format!("请求体 JSON 不合法：{rejection}"))
            .into_response_with_context(Some(request_context))
    })
}

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

    #[test]
    fn validates_and_defaults_submit_options() {
        let payload = contract::Hyper3dTextToModelRequest {
            prompt: "宝箱".to_string(),
            negative_prompt: None,
            seed: Some(7),
            geometry_file_format: None,
            material: None,
            quality: None,
            mesh_mode: None,
            addons: vec!["HighPack".to_string()],
            bbox_condition: Some(vec![1.0, 2.0, 3.0]),
            preview_render: None,
        };

        let options = SubmitOptions::from_text_request(&payload).expect("options should build");

        assert_eq!(options.geometry_file_format, "glb");
        assert_eq!(options.material, "PBR");
        assert_eq!(options.quality, "medium");
        assert_eq!(options.mesh_mode, "Quad");
        assert_eq!(options.addons, vec!["HighPack"]);
        assert!(options.preview_render);
    }

    #[test]
    fn rejects_invalid_bbox_condition() {
        let error = normalize_bbox_condition(Some(vec![1.0, 0.0, 3.0]))
            .expect_err("invalid bbox should fail");

        assert_eq!(error.status_code(), StatusCode::BAD_REQUEST);
    }

    #[test]
    fn accepts_opaque_subscription_key_without_length_cap() {
        let long_key = "a".repeat(300);
        let normalized =
            normalize_required_opaque_text(&format!("  {long_key}  "), "subscriptionKey")
                .expect("subscription key should be accepted");

        assert_eq!(normalized, long_key);
    }

    #[test]
    fn decodes_png_data_url() {
        let data_url = format!(
            "data:image/png;base64,{}",
            BASE64_STANDARD.encode(b"\x89PNG\r\n\x1A\nrest")
        );

        let image = decode_image_data_url(&data_url, 1).expect("image should decode");

        assert_eq!(image.mime_type, "image/png");
        assert_eq!(image.file_name, "reference-01.png");
        assert!(!image.bytes.is_empty());
    }

    #[test]
    fn extracts_submit_response_from_nested_payload() {
        let response = build_submit_response(
            contract::Hyper3dGenerationMode::TextToModel,
            json!({
                "uuid": "task-1",
                "subscription_key": "sub-1",
                "jobs": [{ "uuid": "job-1" }],
                "message": "submitted"
            }),
        )
        .expect("submit response should build");

        assert_eq!(response.task_uuid, "task-1");
        assert_eq!(response.subscription_key, "sub-1");
        assert_eq!(response.job_uuids, vec!["job-1"]);
    }

    #[test]
    fn extracts_download_files_from_list() {
        let files = extract_download_files(&json!({
            "list": [
                { "name": "model.glb", "url": "https://cdn.example/model.glb" },
                { "name": "preview.png", "url": "https://cdn.example/preview.png" }
            ]
        }));

        assert_eq!(files.len(), 2);
        assert_eq!(files[0].name, "model.glb");
    }

    #[test]
    fn normalizes_status_values() {
        assert_eq!(normalize_task_status("Waiting"), "waiting");
        assert_eq!(normalize_task_status("Generating"), "generating");
        assert_eq!(normalize_task_status("Done"), "done");
        assert_eq!(normalize_task_status("Failed"), "failed");
    }
}