use axum::http::StatusCode;
use platform_image::generated_asset_sheets as generated_asset_sheets_impl;

use crate::{
    http_error::AppError, openai_image_generation::DownloadedOpenAiImage,
    platform_errors::map_oss_error, state::AppState,
};

#[allow(unused_imports)]
pub(crate) use generated_asset_sheets_impl::{
    GeneratedAssetSheetError, GeneratedAssetSheetPersistInput, GeneratedAssetSheetPersistPrompt,
    GeneratedAssetSheetPromptInput, GeneratedAssetSheetSliceImage, GeneratedAssetSheetUpload,
    apply_generated_asset_sheet_green_screen_alpha, crop_generated_asset_sheet_view_edge_matte,
};

pub(crate) fn build_generated_asset_sheet_prompt(
    input: &GeneratedAssetSheetPromptInput<'_>,
) -> Result<String, AppError> {
    generated_asset_sheets_impl::build_generated_asset_sheet_prompt(input)
        .map_err(map_generated_asset_sheet_error)
}

pub(crate) fn slice_generated_asset_sheet(
    image: &DownloadedOpenAiImage,
    item_names: &[String],
    grid_size: usize,
) -> Result<Vec<Vec<GeneratedAssetSheetSliceImage>>, AppError> {
    generated_asset_sheets_impl::slice_generated_asset_sheet(image, item_names, grid_size)
        .map_err(map_generated_asset_sheet_error)
}

pub(crate) fn slice_generated_asset_sheet_two_items_per_row(
    image: &DownloadedOpenAiImage,
    item_names: &[String],
    grid_size: usize,
    views_per_item: usize,
) -> Result<Vec<Vec<GeneratedAssetSheetSliceImage>>, AppError> {
    generated_asset_sheets_impl::slice_generated_asset_sheet_two_items_per_row(
        image,
        item_names,
        grid_size,
        views_per_item,
    )
    .map_err(map_generated_asset_sheet_error)
}

pub(crate) async fn persist_generated_asset_sheet_bytes(
    state: &AppState,
    input: GeneratedAssetSheetPersistInput,
) -> Result<GeneratedAssetSheetUpload, AppError> {
    let oss_client = require_oss_client(state)?;
    generated_asset_sheets_impl::persist_generated_asset_sheet_bytes(oss_client, input)
        .await
        .map_err(map_generated_asset_sheet_error)
}

fn require_oss_client(state: &AppState) -> Result<&platform_oss::OssClient, AppError> {
    state.oss_client().ok_or_else(|| {
        AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(serde_json::json!({
            "provider": "aliyun-oss",
            "reason": "OSS 未完成环境变量配置",
        }))
    })
}

fn map_generated_asset_sheet_error(error: GeneratedAssetSheetError) -> AppError {
    match error {
        GeneratedAssetSheetError::InvalidRequest { message } => {
            AppError::from_status(StatusCode::BAD_REQUEST).with_details(serde_json::json!({
                "provider": "generated-asset-sheets",
                "message": message,
            }))
        }
        GeneratedAssetSheetError::DecodeImage { message }
        | GeneratedAssetSheetError::EncodeImage { message } => {
            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(serde_json::json!({
                "provider": "generated-asset-sheets",
                "message": message,
            }))
        }
        GeneratedAssetSheetError::BuildHttpClient { message } => AppError::from_status(
            StatusCode::INTERNAL_SERVER_ERROR,
        )
        .with_details(serde_json::json!({
            "provider": "generated-asset-sheets",
            "message": message,
        })),
        GeneratedAssetSheetError::Oss(error) => map_oss_error(error, "aliyun-oss"),
    }
}