use std::{error::Error, fmt, time::Duration};

use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
use reqwest::header;
use serde_json::{Map, Value, json};

pub const GPT_IMAGE_2_MODEL: &str = "gpt-image-2";
pub const VECTOR_ENGINE_GPT_IMAGE_2_MODEL: &str = GPT_IMAGE_2_MODEL;
pub const VECTOR_ENGINE_PROVIDER: &str = "vector-engine";

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

#[derive(Clone, Debug)]
pub struct GeneratedImages {
    pub task_id: String,
    pub actual_prompt: Option<String>,
    pub images: Vec<DownloadedImage>,
}

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

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

#[derive(Clone, Debug)]
pub struct PlatformImageFailureAudit {
    pub provider: &'static str,
    pub endpoint: String,
    pub operation: String,
    pub failure_stage: &'static str,
    pub status_code: Option<u16>,
    pub status_class: Option<&'static str>,
    pub timeout: bool,
    pub retryable: bool,
    pub error_message: String,
    pub error_source: Option<String>,
    pub raw_excerpt: Option<String>,
    pub latency_ms: Option<u64>,
    pub prompt_chars: Option<usize>,
    pub reference_image_count: Option<usize>,
    pub image_model: Option<&'static str>,
}

#[derive(Clone, Debug)]
pub enum PlatformImageError {
    InvalidConfig {
        provider: &'static str,
        message: String,
    },
    InvalidRequest {
        provider: &'static str,
        message: String,
    },
    Request {
        provider: &'static str,
        message: String,
        endpoint: Option<String>,
        timeout: bool,
        connect: bool,
        request: bool,
        body: bool,
        status_code: Option<u16>,
        source: Option<String>,
        audit: Option<PlatformImageFailureAudit>,
    },
    Upstream {
        provider: &'static str,
        message: String,
        upstream_status: u16,
        raw_excerpt: String,
        audit: Option<PlatformImageFailureAudit>,
    },
    ResponseParse {
        provider: &'static str,
        message: String,
        raw_excerpt: String,
        audit: Option<PlatformImageFailureAudit>,
    },
    MissingImage {
        provider: &'static str,
        message: String,
        audit: Option<PlatformImageFailureAudit>,
    },
}

impl PlatformImageError {
    pub fn provider(&self) -> &'static str {
        match self {
            Self::InvalidConfig { provider, .. }
            | Self::InvalidRequest { provider, .. }
            | Self::Request { provider, .. }
            | Self::Upstream { provider, .. }
            | Self::ResponseParse { provider, .. }
            | Self::MissingImage { provider, .. } => provider,
        }
    }

    pub fn message(&self) -> &str {
        match self {
            Self::InvalidConfig { message, .. }
            | Self::InvalidRequest { message, .. }
            | Self::Request { message, .. }
            | Self::Upstream { message, .. }
            | Self::ResponseParse { message, .. }
            | Self::MissingImage { message, .. } => message,
        }
    }

    pub fn audit(&self) -> Option<&PlatformImageFailureAudit> {
        match self {
            Self::Request { audit, .. }
            | Self::Upstream { audit, .. }
            | Self::ResponseParse { audit, .. }
            | Self::MissingImage { audit, .. } => audit.as_ref(),
            Self::InvalidConfig { .. } | Self::InvalidRequest { .. } => None,
        }
    }

    pub fn status_hint(&self) -> PlatformImageStatusHint {
        match self {
            Self::InvalidConfig { .. } => PlatformImageStatusHint::ServiceUnavailable,
            Self::InvalidRequest { .. } => PlatformImageStatusHint::BadRequest,
            Self::Request { timeout, .. } if *timeout => PlatformImageStatusHint::GatewayTimeout,
            Self::Upstream { message, raw_excerpt, .. }
                if is_timeout_message(message) || is_timeout_message(raw_excerpt) =>
            {
                PlatformImageStatusHint::GatewayTimeout
            }
            Self::Request { .. }
            | Self::Upstream { .. }
            | Self::ResponseParse { .. }
            | Self::MissingImage { .. } => PlatformImageStatusHint::BadGateway,
        }
    }
}

impl fmt::Display for PlatformImageError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.message())
    }
}

impl Error for PlatformImageError {}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PlatformImageStatusHint {
    BadRequest,
    ServiceUnavailable,
    BadGateway,
    GatewayTimeout,
}

pub fn build_vector_engine_image_http_client(
    settings: &VectorEngineImageSettings,
) -> Result<reqwest::Client, PlatformImageError> {
    reqwest::Client::builder()
        .timeout(Duration::from_millis(settings.request_timeout_ms.max(1)))
        .http1_only()
        .build()
        .map_err(|error| PlatformImageError::InvalidConfig {
            provider: VECTOR_ENGINE_PROVIDER,
            message: format!("构造 VectorEngine 图片生成 HTTP 客户端失败：{error}"),
        })
}

pub async fn create_vector_engine_image_generation(
    http_client: &reqwest::Client,
    settings: &VectorEngineImageSettings,
    prompt: &str,
    negative_prompt: Option<&str>,
    size: &str,
    candidate_count: u32,
    reference_images: &[String],
    failure_context: &str,
) -> Result<GeneratedImages, PlatformImageError> {
    if !reference_images.is_empty() {
        let resolved_references =
            resolve_reference_images(http_client, reference_images, failure_context).await?;
        return create_vector_engine_image_edit_with_references(
            http_client,
            settings,
            prompt,
            negative_prompt,
            size,
            candidate_count,
            resolved_references.as_slice(),
            failure_context,
        )
        .await;
    }

    let request_url = vector_engine_images_generation_url(settings);
    let normalized_size = normalize_image_size(size);
    let request_body = build_vector_engine_image_request_body(
        prompt,
        negative_prompt,
        normalized_size.as_str(),
        candidate_count,
        reference_images,
    );
    let started_at = std::time::Instant::now();
    let response = match http_client
        .post(request_url.as_str())
        .header(
            header::AUTHORIZATION,
            format!("Bearer {}", settings.api_key),
        )
        .header(header::ACCEPT, "application/json")
        .header(header::CONTENT_TYPE, "application/json")
        .json(&request_body)
        .send()
        .await
    {
        Ok(response) => response,
        Err(error) => {
            return Err(map_reqwest_error(
                format!("{failure_context}：创建图片生成任务失败").as_str(),
                request_url.as_str(),
                "request_send",
                error,
                started_at.elapsed().as_millis() as u64,
                Some(prompt.chars().count()),
                Some(reference_images.len()),
            ));
        }
    };
    let response_status = response.status();
    tracing::info!(
        provider = VECTOR_ENGINE_PROVIDER,
        endpoint = %request_url,
        status = response_status.as_u16(),
        prompt_chars = prompt.chars().count(),
        size = %normalized_size,
        reference_image_count = reference_images.len(),
        elapsed_ms = started_at.elapsed().as_millis() as u64,
        failure_context,
        "VectorEngine 图片生成 HTTP 返回"
    );
    let response_text = match response.text().await {
        Ok(response_text) => response_text,
        Err(error) => {
            return Err(map_reqwest_error(
                format!("{failure_context}：读取图片生成响应失败").as_str(),
                request_url.as_str(),
                "response_body",
                error,
                started_at.elapsed().as_millis() as u64,
                Some(prompt.chars().count()),
                Some(reference_images.len()),
            ));
        }
    };
    handle_vector_engine_response(
        http_client,
        request_url.as_str(),
        response_status.as_u16(),
        response_text.as_str(),
        failure_context,
        started_at.elapsed().as_millis() as u64,
        Some(prompt.chars().count()),
        Some(reference_images.len()),
        candidate_count,
        "vector-engine",
    )
    .await
}

pub async fn create_vector_engine_image_edit(
    http_client: &reqwest::Client,
    settings: &VectorEngineImageSettings,
    prompt: &str,
    negative_prompt: Option<&str>,
    size: &str,
    reference_image: &ReferenceImage,
    failure_context: &str,
) -> Result<GeneratedImages, PlatformImageError> {
    create_vector_engine_image_edit_with_references(
        http_client,
        settings,
        prompt,
        negative_prompt,
        size,
        1,
        std::slice::from_ref(reference_image),
        failure_context,
    )
    .await
}

pub async fn create_vector_engine_image_edit_with_references(
    http_client: &reqwest::Client,
    settings: &VectorEngineImageSettings,
    prompt: &str,
    negative_prompt: Option<&str>,
    size: &str,
    candidate_count: u32,
    reference_images: &[ReferenceImage],
    failure_context: &str,
) -> Result<GeneratedImages, PlatformImageError> {
    if reference_images.is_empty() {
        return Err(PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: format!("{failure_context}：缺少参考图，图片编辑需要至少一张参考图。"),
        });
    }

    let request_url = vector_engine_images_edit_url(settings);
    let normalized_size = normalize_image_size(size);

    let mut form = reqwest::multipart::Form::new()
        .text("model", GPT_IMAGE_2_MODEL.to_string())
        .text("prompt", build_prompt_with_negative(prompt, negative_prompt))
        .text("n", candidate_count.clamp(1, 4).to_string())
        .text("size", normalized_size.clone());

    for reference_image in reference_images.iter().take(5) {
        let image_part = reqwest::multipart::Part::bytes(reference_image.bytes.clone())
            .file_name(reference_image.file_name.clone())
            .mime_str(reference_image.mime_type.as_str())
            .map_err(|error| PlatformImageError::InvalidRequest {
                provider: VECTOR_ENGINE_PROVIDER,
                message: format!("{failure_context}：构造参考图失败：{error}"),
            })?;
        form = form.part("image", image_part);
    }

    let reference_image_count = reference_images.iter().take(5).count();
    let started_at = std::time::Instant::now();
    let response = match http_client
        .post(request_url.as_str())
        .header(
            header::AUTHORIZATION,
            format!("Bearer {}", settings.api_key),
        )
        .header(header::ACCEPT, "application/json")
        .multipart(form)
        .send()
        .await
    {
        Ok(response) => response,
        Err(error) => {
            return Err(map_reqwest_error(
                format!("{failure_context}：创建图片编辑任务失败").as_str(),
                request_url.as_str(),
                "request_send",
                error,
                started_at.elapsed().as_millis() as u64,
                Some(prompt.chars().count()),
                Some(reference_image_count),
            ));
        }
    };
    let response_status = response.status();
    tracing::info!(
        provider = VECTOR_ENGINE_PROVIDER,
        endpoint = %request_url,
        status = response_status.as_u16(),
        prompt_chars = prompt.chars().count(),
        size = %normalized_size,
        reference_image_count,
        elapsed_ms = started_at.elapsed().as_millis() as u64,
        failure_context,
        "VectorEngine 图片编辑 HTTP 返回"
    );
    let response_text = match response.text().await {
        Ok(response_text) => response_text,
        Err(error) => {
            return Err(map_reqwest_error(
                format!("{failure_context}：读取图片编辑响应失败").as_str(),
                request_url.as_str(),
                "response_body",
                error,
                started_at.elapsed().as_millis() as u64,
                Some(prompt.chars().count()),
                Some(reference_image_count),
            ));
        }
    };
    handle_vector_engine_response(
        http_client,
        request_url.as_str(),
        response_status.as_u16(),
        response_text.as_str(),
        failure_context,
        started_at.elapsed().as_millis() as u64,
        Some(prompt.chars().count()),
        Some(reference_image_count),
        candidate_count,
        "vector-engine-edit",
    )
    .await
}

#[allow(clippy::too_many_arguments)]
async fn handle_vector_engine_response(
    http_client: &reqwest::Client,
    request_url: &str,
    response_status: u16,
    response_text: &str,
    failure_context: &str,
    latency_ms: u64,
    prompt_chars: Option<usize>,
    reference_image_count: Option<usize>,
    candidate_count: u32,
    task_prefix: &str,
) -> Result<GeneratedImages, PlatformImageError> {
    if !(200..=299).contains(&response_status) {
        let message = parse_api_error_message(response_text, failure_context);
        let raw_excerpt = truncate_raw(response_text);
        let audit = build_failure_audit(
            request_url,
            failure_context,
            "upstream_status",
            Some(response_status),
            None,
            false,
            false,
            message.as_str(),
            None,
            Some(raw_excerpt.clone()),
            Some(latency_ms),
            prompt_chars,
            reference_image_count,
        );
        tracing::warn!(
            provider = VECTOR_ENGINE_PROVIDER,
            endpoint = %request_url,
            upstream_status = response_status,
            timeout = is_timeout_message(message.as_str()) || is_timeout_message(raw_excerpt.as_str()),
            retryable = audit.retryable,
            message = %message,
            raw_excerpt = %raw_excerpt,
            "VectorEngine 图片生成上游错误"
        );
        return Err(PlatformImageError::Upstream {
            provider: VECTOR_ENGINE_PROVIDER,
            message,
            upstream_status: response_status,
            raw_excerpt,
            audit: Some(audit),
        });
    }

    let response_json = match parse_json_payload(response_text, failure_context) {
        Ok(response_json) => response_json,
        Err(error) => {
            let audit = build_failure_audit(
                request_url,
                failure_context,
                "response_parse",
                Some(response_status),
                None,
                false,
                false,
                error.message(),
                None,
                Some(truncate_raw(response_text)),
                Some(latency_ms),
                prompt_chars,
                reference_image_count,
            );
            tracing::warn!(
                provider = VECTOR_ENGINE_PROVIDER,
                endpoint = %request_url,
                status = response_status,
                raw_excerpt = %truncate_raw(response_text),
                message = %error.message(),
                "VectorEngine 图片响应解析失败"
            );
            return Err(error.with_audit(audit));
        }
    };
    let task_id = extract_generation_id(&response_json.payload)
        .unwrap_or_else(|| format!("{task_prefix}-{}", current_utc_micros()));
    let actual_prompt = find_first_string_by_key(&response_json.payload, "revised_prompt")
        .or_else(|| find_first_string_by_key(&response_json.payload, "actual_prompt"));
    let image_urls = extract_image_urls(&response_json.payload);
    if !image_urls.is_empty() {
        let download_started_at = std::time::Instant::now();
        let mut generated = match download_images_from_urls(
            http_client,
            task_id,
            image_urls,
            candidate_count,
        )
        .await
        {
            Ok(generated) => generated,
            Err(error) => {
                let audit = build_failure_audit(
                    request_url,
                    failure_context,
                    "image_download",
                    Some(response_status),
                    Some("5xx"),
                    false,
                    false,
                    error.message(),
                    None,
                    None,
                    Some(download_started_at.elapsed().as_millis() as u64),
                    prompt_chars,
                    reference_image_count,
                );
                return Err(error.with_audit(audit));
            }
        };
        generated.actual_prompt = actual_prompt;
        tracing::info!(
            provider = VECTOR_ENGINE_PROVIDER,
            endpoint = %request_url,
            image_count = generated.images.len(),
            elapsed_ms = download_started_at.elapsed().as_millis() as u64,
            failure_context,
            "VectorEngine 图片下载完成"
        );
        return Ok(generated);
    }
    let b64_images = extract_b64_images(&response_json.payload);
    if !b64_images.is_empty() {
        let mut generated = images_from_base64(task_id, b64_images, candidate_count);
        generated.actual_prompt = actual_prompt;
        tracing::info!(
            provider = VECTOR_ENGINE_PROVIDER,
            endpoint = %request_url,
            image_count = generated.images.len(),
            failure_context,
            "VectorEngine 图片 base64 解码完成"
        );
        return Ok(generated);
    }

    let message = format!("{failure_context}：VectorEngine 未返回图片地址");
    let audit = build_failure_audit(
        request_url,
        failure_context,
        "missing_image",
        Some(response_status),
        None,
        false,
        false,
        message.as_str(),
        None,
        Some(truncate_raw(response_text)),
        Some(latency_ms),
        prompt_chars,
        reference_image_count,
    );
    tracing::warn!(
        provider = VECTOR_ENGINE_PROVIDER,
        endpoint = %request_url,
        status = response_status,
        raw_excerpt = %truncate_raw(response_text),
        "VectorEngine 图片响应未返回图片"
    );
    Err(PlatformImageError::MissingImage {
        provider: VECTOR_ENGINE_PROVIDER,
        message,
        audit: Some(audit),
    })
}

pub fn build_vector_engine_image_request_body(
    prompt: &str,
    negative_prompt: Option<&str>,
    size: &str,
    candidate_count: u32,
    _reference_images: &[String],
) -> Value {
    let body = Map::from_iter([
        (
            "model".to_string(),
            Value::String(GPT_IMAGE_2_MODEL.to_string()),
        ),
        (
            "prompt".to_string(),
            Value::String(build_prompt_with_negative(prompt, negative_prompt)),
        ),
        ("n".to_string(), json!(candidate_count.clamp(1, 4))),
        (
            "size".to_string(),
            Value::String(normalize_image_size(size)),
        ),
    ]);

    Value::Object(body)
}

pub fn normalize_image_size(size: &str) -> String {
    match size.trim() {
        "1024*1024" | "1024x1024" | "1:1" => "1024x1024",
        "1280*720" | "1280x720" | "1600*900" | "1600x900" | "16:9" | "1536x1024" | "2048x1152"
        | "2k" => "1536x1024",
        "1024*1536" | "1024x1536" | "9:16" => "1024x1536",
        value if !value.is_empty() => value,
        _ => "1024x1024",
    }
    .to_string()
}

pub fn vector_engine_images_generation_url(settings: &VectorEngineImageSettings) -> String {
    if settings.base_url.ends_with("/v1") {
        format!("{}/images/generations", settings.base_url)
    } else {
        format!("{}/v1/images/generations", settings.base_url)
    }
}

pub fn vector_engine_images_edit_url(settings: &VectorEngineImageSettings) -> String {
    if settings.base_url.ends_with("/v1") {
        format!("{}/images/edits", settings.base_url)
    } else {
        format!("{}/v1/images/edits", settings.base_url)
    }
}

pub async fn download_remote_image(
    http_client: &reqwest::Client,
    image_url: &str,
) -> Result<DownloadedImage, PlatformImageError> {
    let response = http_client.get(image_url).send().await.map_err(|error| {
        map_simple_request_error(format!("下载生成图片失败：{error}"), Some(image_url.to_string()))
    })?;
    let status = response.status();
    let content_type = response
        .headers()
        .get(header::CONTENT_TYPE)
        .and_then(|value| value.to_str().ok())
        .unwrap_or("image/jpeg")
        .to_string();
    let body = response.bytes().await.map_err(|error| {
        map_simple_request_error(format!("读取生成图片内容失败：{error}"), Some(image_url.to_string()))
    })?;
    if !status.is_success() {
        return Err(PlatformImageError::Request {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "下载生成图片失败".to_string(),
            endpoint: Some(image_url.to_string()),
            timeout: false,
            connect: false,
            request: false,
            body: false,
            status_code: Some(status.as_u16()),
            source: None,
            audit: None,
        });
    }

    let normalized_mime_type = normalize_downloaded_image_mime_type(content_type.as_str());
    Ok(DownloadedImage {
        extension: mime_to_extension(normalized_mime_type.as_str()).to_string(),
        mime_type: normalized_mime_type,
        bytes: body.to_vec(),
    })
}

async fn download_images_from_urls(
    http_client: &reqwest::Client,
    task_id: String,
    image_urls: Vec<String>,
    candidate_count: u32,
) -> Result<GeneratedImages, PlatformImageError> {
    let mut images = Vec::with_capacity(candidate_count.clamp(1, 4) as usize);
    for image_url in image_urls
        .into_iter()
        .take(candidate_count.clamp(1, 4) as usize)
    {
        images.push(download_remote_image(http_client, image_url.as_str()).await?);
    }
    Ok(GeneratedImages {
        task_id,
        actual_prompt: None,
        images,
    })
}

async fn resolve_reference_images(
    http_client: &reqwest::Client,
    reference_images: &[String],
    failure_context: &str,
) -> Result<Vec<ReferenceImage>, PlatformImageError> {
    let mut resolved = Vec::new();
    for (index, source) in reference_images.iter().take(5).enumerate() {
        let source = source.trim();
        if source.is_empty() {
            continue;
        }
        if let Some(reference_image) = parse_reference_image_data_url(source, index)? {
            resolved.push(reference_image);
            continue;
        }
        if source.starts_with("http://") || source.starts_with("https://") {
            let downloaded = download_remote_image(http_client, source)
                .await
                .map_err(|error| PlatformImageError::Request {
                    provider: VECTOR_ENGINE_PROVIDER,
                    message: format!("{failure_context}：下载参考图失败：{error}"),
                    endpoint: Some(source.to_string()),
                    timeout: false,
                    connect: false,
                    request: false,
                    body: false,
                    status_code: None,
                    source: None,
                    audit: None,
                })?;
            resolved.push(ReferenceImage {
                bytes: downloaded.bytes,
                mime_type: downloaded.mime_type.clone(),
                file_name: format!(
                    "reference-{index}.{}",
                    mime_to_extension(downloaded.mime_type.as_str())
                ),
            });
            continue;
        }
        return Err(PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: format!("{failure_context}：参考图必须是图片 Data URL 或 HTTP(S) URL。"),
        });
    }

    if resolved.is_empty() {
        return Err(PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: format!("{failure_context}：图片编辑需要至少一张参考图。"),
        });
    }

    Ok(resolved)
}

fn parse_reference_image_data_url(
    source: &str,
    index: usize,
) -> Result<Option<ReferenceImage>, PlatformImageError> {
    let Some(body) = source.strip_prefix("data:") else {
        return Ok(None);
    };
    let Some((mime_type, data)) = body.split_once(";base64,") else {
        return Err(PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "参考图 Data URL 必须是 base64 图片。".to_string(),
        });
    };
    if !mime_type.starts_with("image/") {
        return Err(PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "参考图 Data URL 必须是图片类型。".to_string(),
        });
    }
    let bytes = BASE64_STANDARD
        .decode(data.trim())
        .map_err(|error| PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: format!("参考图 Data URL 解码失败：{error}"),
        })?;
    let mime_type = normalize_downloaded_image_mime_type(mime_type);
    Ok(Some(ReferenceImage {
        bytes,
        file_name: format!(
            "reference-{index}.{}",
            mime_to_extension(mime_type.as_str())
        ),
        mime_type,
    }))
}

fn images_from_base64(
    task_id: String,
    b64_images: Vec<String>,
    candidate_count: u32,
) -> GeneratedImages {
    let images = b64_images
        .into_iter()
        .take(candidate_count.clamp(1, 4) as usize)
        .filter_map(|raw| decode_generated_image_base64(raw.as_str()))
        .collect();

    GeneratedImages {
        task_id,
        actual_prompt: None,
        images,
    }
}

fn decode_generated_image_base64(raw: &str) -> Option<DownloadedImage> {
    let bytes = BASE64_STANDARD.decode(raw.trim()).ok()?;
    let mime_type = infer_image_mime_type(bytes.as_slice());
    Some(DownloadedImage {
        extension: mime_to_extension(mime_type.as_str()).to_string(),
        mime_type,
        bytes,
    })
}

fn parse_json_payload(
    raw_text: &str,
    failure_context: &str,
) -> Result<ParsedJsonPayload, PlatformImageError> {
    serde_json::from_str::<Value>(raw_text)
        .map(|payload| ParsedJsonPayload { payload })
        .map_err(|error| PlatformImageError::ResponseParse {
            provider: VECTOR_ENGINE_PROVIDER,
            message: format!("{failure_context}：解析响应失败：{error}"),
            raw_excerpt: truncate_raw(raw_text),
            audit: None,
        })
}

fn map_reqwest_error(
    context: &str,
    request_url: &str,
    failure_stage: &'static str,
    error: reqwest::Error,
    latency_ms: u64,
    prompt_chars: Option<usize>,
    reference_image_count: Option<usize>,
) -> PlatformImageError {
    let is_timeout = error.is_timeout();
    let is_connect = error.is_connect();
    let source = error.source().map(ToString::to_string);
    let message = format!("{context}：{error}");
    let audit = build_failure_audit(
        request_url,
        context,
        failure_stage,
        error.status().map(|status| status.as_u16()),
        None,
        is_timeout,
        is_connect,
        message.as_str(),
        source.clone(),
        None,
        Some(latency_ms),
        prompt_chars,
        reference_image_count,
    );
    tracing::warn!(
        provider = VECTOR_ENGINE_PROVIDER,
        endpoint = %request_url,
        failure_stage,
        timeout = is_timeout,
        connect = is_connect,
        request = error.is_request(),
        body = error.is_body(),
        status = error.status().map(|status| status.as_u16()).unwrap_or_default(),
        source = %source.clone().unwrap_or_default(),
        message = %message,
        elapsed_ms = latency_ms,
        prompt_chars,
        reference_image_count,
        "VectorEngine 图片请求发送失败"
    );

    PlatformImageError::Request {
        provider: VECTOR_ENGINE_PROVIDER,
        message,
        endpoint: Some(request_url.to_string()),
        timeout: is_timeout,
        connect: is_connect,
        request: error.is_request(),
        body: error.is_body(),
        status_code: error.status().map(|status| status.as_u16()),
        source,
        audit: Some(audit),
    }
}

fn map_simple_request_error(message: String, endpoint: Option<String>) -> PlatformImageError {
    PlatformImageError::Request {
        provider: VECTOR_ENGINE_PROVIDER,
        message,
        endpoint,
        timeout: false,
        connect: false,
        request: true,
        body: false,
        status_code: None,
        source: None,
        audit: None,
    }
}

#[allow(clippy::too_many_arguments)]
fn build_failure_audit(
    request_url: &str,
    operation: &str,
    failure_stage: &'static str,
    status_code: Option<u16>,
    status_class: Option<&'static str>,
    timeout: bool,
    connect: bool,
    error_message: &str,
    error_source: Option<String>,
    raw_excerpt: Option<String>,
    latency_ms: Option<u64>,
    prompt_chars: Option<usize>,
    reference_image_count: Option<usize>,
) -> PlatformImageFailureAudit {
    PlatformImageFailureAudit {
        provider: VECTOR_ENGINE_PROVIDER,
        endpoint: request_url.to_string(),
        operation: operation.to_string(),
        failure_stage,
        status_code,
        status_class,
        timeout,
        retryable: is_retryable_external_api_failure(status_code, timeout, connect),
        error_message: error_message.to_string(),
        error_source,
        raw_excerpt,
        latency_ms,
        prompt_chars,
        reference_image_count,
        image_model: Some(VECTOR_ENGINE_GPT_IMAGE_2_MODEL),
    }
}

fn is_retryable_external_api_failure(
    status_code: Option<u16>,
    timeout: bool,
    connect: bool,
) -> bool {
    timeout || connect || status_code.is_some_and(|status| status == 429 || status == 408 || status >= 500)
}

fn build_prompt_with_negative(prompt: &str, negative_prompt: Option<&str>) -> String {
    let prompt = prompt.trim();
    let Some(negative_prompt) = negative_prompt
        .map(str::trim)
        .filter(|value| !value.is_empty())
    else {
        return prompt.to_string();
    };

    format!("{prompt}\n避免：{negative_prompt}")
}

fn parse_api_error_message(raw_text: &str, fallback_message: &str) -> String {
    if raw_text.trim().is_empty() {
        return fallback_message.to_string();
    }

    if let Ok(parsed) = serde_json::from_str::<Value>(raw_text) {
        for pointer in [
            "/error/message",
            "/message",
            "/output/message",
            "/data/message",
        ] {
            if let Some(message) = parsed
                .pointer(pointer)
                .and_then(Value::as_str)
                .map(str::trim)
                .filter(|value| !value.is_empty())
            {
                return message.to_string();
            }
        }
        for pointer in ["/error/code", "/code", "/output/code", "/data/code"] {
            if let Some(code) = parsed
                .pointer(pointer)
                .and_then(Value::as_str)
                .map(str::trim)
                .filter(|value| !value.is_empty())
            {
                return format!("{fallback_message}（{code}）");
            }
        }
    }

    raw_text.trim().to_string()
}

fn collect_strings_by_key(value: &Value, target_key: &str, results: &mut Vec<String>) {
    match value {
        Value::Array(entries) => {
            for entry in entries {
                collect_strings_by_key(entry, target_key, results);
            }
        }
        Value::Object(object) => {
            for (key, nested_value) in object {
                if key == target_key {
                    match nested_value {
                        Value::String(text) => {
                            let text = text.trim();
                            if !text.is_empty() {
                                results.push(text.to_string());
                                continue;
                            }
                        }
                        Value::Array(entries) => {
                            for entry in entries {
                                if let Some(text) = entry
                                    .as_str()
                                    .map(str::trim)
                                    .filter(|value| !value.is_empty())
                                {
                                    results.push(text.to_string());
                                }
                            }
                        }
                        _ => {}
                    }
                }
                collect_strings_by_key(nested_value, target_key, results);
            }
        }
        _ => {}
    }
}

fn find_first_string_by_key(value: &Value, target_key: &str) -> Option<String> {
    let mut results = Vec::new();
    collect_strings_by_key(value, target_key, &mut results);
    results.into_iter().next()
}

fn extract_generation_id(payload: &Value) -> Option<String> {
    find_first_string_by_key(payload, "id")
        .or_else(|| find_first_string_by_key(payload, "created"))
        .or_else(|| find_first_string_by_key(payload, "request_id"))
}

fn extract_image_urls(payload: &Value) -> Vec<String> {
    let mut urls = Vec::new();
    collect_strings_by_key(payload, "url", &mut urls);
    collect_strings_by_key(payload, "image", &mut urls);
    collect_strings_by_key(payload, "image_url", &mut urls);
    let mut deduped = Vec::new();
    for url in urls {
        if (url.starts_with("http://") || url.starts_with("https://")) && !deduped.contains(&url) {
            deduped.push(url);
        }
    }
    deduped
}

fn extract_b64_images(payload: &Value) -> Vec<String> {
    let mut values = Vec::new();
    collect_strings_by_key(payload, "b64_json", &mut values);
    values
}

fn normalize_downloaded_image_mime_type(content_type: &str) -> String {
    let mime_type = content_type
        .split(';')
        .next()
        .map(str::trim)
        .unwrap_or("image/jpeg");
    match mime_type {
        "image/png" | "image/webp" | "image/jpeg" | "image/jpg" | "image/gif" => {
            mime_type.to_string()
        }
        _ => "image/jpeg".to_string(),
    }
}

fn mime_to_extension(mime_type: &str) -> &str {
    match mime_type {
        "image/png" => "png",
        "image/webp" => "webp",
        "image/gif" => "gif",
        _ => "jpg",
    }
}

fn infer_image_mime_type(bytes: &[u8]) -> String {
    if bytes.starts_with(b"\x89PNG\r\n\x1A\n") {
        return "image/png".to_string();
    }
    if bytes.starts_with(b"\xFF\xD8\xFF") {
        return "image/jpeg".to_string();
    }
    if bytes.starts_with(b"RIFF") && bytes.get(8..12) == Some(b"WEBP") {
        return "image/webp".to_string();
    }
    if bytes.starts_with(b"GIF87a") || bytes.starts_with(b"GIF89a") {
        return "image/gif".to_string();
    }
    "image/png".to_string()
}

fn is_timeout_message(message: &str) -> bool {
    let lower = message.to_ascii_lowercase();
    lower.contains("timed out")
        || lower.contains("timeout")
        || lower.contains("operation timed out")
        || lower.contains("deadline has elapsed")
}

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

fn current_utc_micros() -> i64 {
    use std::time::{SystemTime, UNIX_EPOCH};
    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("system time should be after unix epoch");
    i64::try_from(duration.as_micros()).expect("current unix micros should fit in i64")
}

impl PlatformImageError {
    fn with_audit(self, audit: PlatformImageFailureAudit) -> Self {
        match self {
            Self::Request {
                provider,
                message,
                endpoint,
                timeout,
                connect,
                request,
                body,
                status_code,
                source,
                ..
            } => Self::Request {
                provider,
                message,
                endpoint,
                timeout,
                connect,
                request,
                body,
                status_code,
                source,
                audit: Some(audit),
            },
            Self::Upstream {
                provider,
                message,
                upstream_status,
                raw_excerpt,
                ..
            } => Self::Upstream {
                provider,
                message,
                upstream_status,
                raw_excerpt,
                audit: Some(audit),
            },
            Self::ResponseParse {
                provider,
                message,
                raw_excerpt,
                ..
            } => Self::ResponseParse {
                provider,
                message,
                raw_excerpt,
                audit: Some(audit),
            },
            Self::MissingImage {
                provider, message, ..
            } => Self::MissingImage {
                provider,
                message,
                audit: Some(audit),
            },
            Self::InvalidConfig { .. } | Self::InvalidRequest { .. } => self,
        }
    }
}

struct ParsedJsonPayload {
    payload: Value,
}

#[cfg(test)]
mod tests {
    use super::*;
    use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
    use serde_json::json;

    #[test]
    fn request_body_normalizes_size_prompt_and_candidate_count() {
        let body = build_vector_engine_image_request_body(
            "  风雨夜里的街道  ",
            Some("  低清，水印  "),
            " 1:1 ",
            10,
            &["data:image/png;base64,AAAA".to_string()],
        );

        assert_eq!(body["model"], GPT_IMAGE_2_MODEL);
        assert_eq!(body["size"], "1024x1024");
        assert_eq!(body["n"], 4);
        assert_eq!(body["prompt"], "风雨夜里的街道\n避免：低清，水印");
        assert!(body.get("image").is_none());
    }

    #[test]
    fn provider_urls_normalize_root_and_v1_base_urls() {
        let root_settings = VectorEngineImageSettings {
            base_url: "https://vector.example".to_string(),
            api_key: "test-key".to_string(),
            request_timeout_ms: 1_000,
        };
        let v1_settings = VectorEngineImageSettings {
            base_url: "https://vector.example/v1".to_string(),
            api_key: "test-key".to_string(),
            request_timeout_ms: 1_000,
        };

        assert_eq!(
            vector_engine_images_generation_url(&root_settings),
            "https://vector.example/v1/images/generations"
        );
        assert_eq!(
            vector_engine_images_generation_url(&v1_settings),
            "https://vector.example/v1/images/generations"
        );
        assert_eq!(
            vector_engine_images_edit_url(&root_settings),
            "https://vector.example/v1/images/edits"
        );
        assert_eq!(
            vector_engine_images_edit_url(&v1_settings),
            "https://vector.example/v1/images/edits"
        );
    }

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

        let reference = parse_reference_image_data_url(&data_url, 2)
            .expect("data url should parse")
            .expect("image data url should be accepted");
        assert_eq!(reference.file_name, "reference-2.png");
        assert_eq!(reference.mime_type, "image/png");
        assert_eq!(reference.bytes, b"\x89PNG\r\n\x1A\nrest");

        let image = decode_generated_image_base64(BASE64_STANDARD.encode(b"\x89PNG\r\n\x1A\nrest").as_str())
            .expect("base64 image should decode");
        assert_eq!(image.extension, "png");
        assert_eq!(image.mime_type, "image/png");
        assert_eq!(image.bytes, b"\x89PNG\r\n\x1A\nrest");
    }

    #[test]
    fn error_status_hints_and_audit_fields_are_structured() {
        let audit = PlatformImageFailureAudit {
            provider: VECTOR_ENGINE_PROVIDER,
            endpoint: "https://vector.example/v1/images/generations".to_string(),
            operation: "图片生成失败".to_string(),
            failure_stage: "upstream_status",
            status_code: Some(504),
            status_class: Some("5xx"),
            timeout: true,
            retryable: true,
            error_message: "上游超时".to_string(),
            error_source: Some("read timeout".to_string()),
            raw_excerpt: Some("{\"error\":\"timeout\"}".to_string()),
            latency_ms: Some(987),
            prompt_chars: Some(64),
            reference_image_count: Some(2),
            image_model: Some(VECTOR_ENGINE_GPT_IMAGE_2_MODEL),
        };

        let request_error = PlatformImageError::Request {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "请求发送失败".to_string(),
            endpoint: Some("https://vector.example/v1/images/generations".to_string()),
            timeout: true,
            connect: false,
            request: true,
            body: false,
            status_code: None,
            source: None,
            audit: None,
        };
        let invalid_config = PlatformImageError::InvalidConfig {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "缺少配置".to_string(),
        };
        let invalid_request = PlatformImageError::InvalidRequest {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "请求不合法".to_string(),
        };
        let upstream_timeout = PlatformImageError::Upstream {
            provider: VECTOR_ENGINE_PROVIDER,
            message: "upstream timeout".to_string(),
            upstream_status: 502,
            raw_excerpt: "deadline has elapsed".to_string(),
            audit: Some(audit.clone()),
        };

        assert_eq!(invalid_config.status_hint(), PlatformImageStatusHint::ServiceUnavailable);
        assert_eq!(invalid_request.status_hint(), PlatformImageStatusHint::BadRequest);
        assert_eq!(request_error.status_hint(), PlatformImageStatusHint::GatewayTimeout);
        assert_eq!(upstream_timeout.status_hint(), PlatformImageStatusHint::GatewayTimeout);
        assert_eq!(
            PlatformImageError::MissingImage {
                provider: VECTOR_ENGINE_PROVIDER,
                message: "缺图".to_string(),
                audit: Some(audit.clone()),
            }
            .status_hint(),
            PlatformImageStatusHint::BadGateway
        );

        let audit_ref = upstream_timeout.audit().expect("audit should be preserved");
        assert_eq!(audit_ref.provider, VECTOR_ENGINE_PROVIDER);
        assert_eq!(audit_ref.endpoint, "https://vector.example/v1/images/generations");
        assert_eq!(audit_ref.status_code, Some(504));
        assert_eq!(audit_ref.status_class, Some("5xx"));
        assert!(audit_ref.timeout);
        assert!(audit_ref.retryable);
        assert_eq!(audit_ref.reference_image_count, Some(2));
        assert_eq!(audit_ref.image_model, Some(VECTOR_ENGINE_GPT_IMAGE_2_MODEL));
        assert!(invalid_config.audit().is_none());
        assert!(invalid_request.audit().is_none());
    }

    #[test]
    fn extract_image_urls_and_b64_values_are_deduped() {
        let payload = json!({
            "data": [
                {"image": "https://example.com/a.png"},
                {"url": "https://example.com/a.png"},
                {"image_url": "ftp://example.com/b.png"},
                {"url": "https://example.com/b.png"}
            ],
            "nested": {
                "b64_json": ["YWJj", "ZGVm"]
            }
        });

        assert_eq!(
            extract_image_urls(&payload),
            vec![
                "https://example.com/a.png".to_string(),
                "https://example.com/b.png".to_string()
            ]
        );
        assert_eq!(
            extract_b64_images(&payload),
            vec!["YWJj".to_string(), "ZGVm".to_string()]
        );
    }
}