matrixcode_tui/

image_utils.rs

//! Image Search - Real API implementation
//!
//! Calls Unsplash, Pexels, and Pixabay APIs to get actual image URLs

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Unsplash API response
#[derive(Debug, Deserialize)]
struct UnsplashResponse {
    results: Vec<UnsplashPhoto>,
}

#[derive(Debug, Deserialize)]
struct UnsplashPhoto {
    id: String,
    urls: UnsplashUrls,
    description: Option<String>,
    alt_description: Option<String>,
    user: UnsplashUser,
    width: u32,
    height: u32,
}

#[derive(Debug, Deserialize)]
struct UnsplashUrls {
    regular: String,
    full: String,
    thumb: String,
}

#[derive(Debug, Deserialize)]
struct UnsplashUser {
    name: String,
    links: UnsplashLinks,
}

#[derive(Debug, Deserialize)]
struct UnsplashLinks {
    html: String,
}

/// Pexels API response
#[derive(Debug, Deserialize)]
struct PexelsResponse {
    photos: Vec<PexelsPhoto>,
}

#[derive(Debug, Deserialize)]
struct PexelsPhoto {
    id: u32,
    src: PexelsSrc,
    alt: Option<String>,
    photographer: String,
    photographer_url: String,
    width: u32,
    height: u32,
}

#[derive(Debug, Deserialize)]
struct PexelsSrc {
    large: String,
    original: String,
    medium: String,
}

/// Pixabay API response
#[derive(Debug, Deserialize)]
struct PixabayResponse {
    hits: Vec<PixabayHit>,
}

#[derive(Debug, Deserialize)]
struct PixabayHit {
    id: u32,
    #[serde(rename = "webformatURL")]
    webformat_url: String,
    #[serde(rename = "largeImageURL")]
    large_image_url: String,
    #[serde(rename = "previewURL")]
    preview_url: String,
    tags: Option<String>,
    user: String,
    user_id: u32,
    #[serde(rename = "webformatWidth")]
    webformat_width: u32,
    #[serde(rename = "webformatHeight")]
    webformat_height: u32,
}

/// Normalized image result
#[derive(Debug, Serialize, Clone)]
pub struct ImageResult {
    pub id: String,
    pub url: String,
    pub full_url: String,
    pub thumb_url: String,
    pub description: String,
    pub photographer: String,
    pub photographer_url: String,
    pub width: u32,
    pub height: u32,
    pub platform: String,
    /// URL availability validated
    pub validated: bool,
}

/// Get API keys from environment variables (secure approach)
/// Keys should be set in .env or config file, never hardcoded
fn get_unsplash_key() -> Option<String> {
    std::env::var("UNSPLASH_ACCESS_KEY").ok()
}

fn get_pexels_key() -> Option<String> {
    std::env::var("PEXELS_API_KEY").ok()
}

fn get_pixabay_key() -> Option<String> {
    std::env::var("PIXABAY_API_KEY").ok()
}

/// Validate image URL accessibility (HEAD request)
async fn validate_image_url(client: &reqwest::Client, url: &str) -> bool {
    if url.is_empty() {
        return false;
    }

    match client.head(url).send().await {
        Ok(resp) => {
            let status = resp.status();
            if status.is_success() || status.as_u16() == 302 {
                // Check content-type if available
                if let Some(content_type) = resp.headers().get("content-type")
                    && let Ok(ct) = content_type.to_str()
                {
                    return ct.starts_with("image/");
                }
                // Some servers don't return content-type for HEAD, assume valid
                return status.is_success();
            }
            false
        }
        Err(e) => {
            log::debug!("URL validation failed for {}: {}", url, e);
            false
        }
    }
}

/// Validate image URL with GET request (fallback when HEAD fails)
async fn validate_image_url_get(client: &reqwest::Client, url: &str) -> bool {
    if url.is_empty() {
        return false;
    }

    // Only fetch first 1KB to verify it's accessible
    match client
        .get(url)
        .header("Range", "bytes=0-1023")
        .timeout(Duration::from_secs(5))
        .send()
        .await
    {
        Ok(resp) => {
            let status = resp.status();
            status.is_success() || status.as_u16() == 206 // Partial Content
        }
        Err(_) => false,
    }
}

/// Search Unsplash API
pub async fn search_unsplash(query: &str, per_page: u32) -> Result<Vec<ImageResult>> {
    let key = get_unsplash_key()
        .ok_or_else(|| anyhow::anyhow!("UNSPLASH_ACCESS_KEY not set in environment"))?;

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(10))
        .user_agent("Mozilla/5.0 (compatible; MatrixCode/1.0)")
        .build()?;

    let url = format!(
        "https://api.unsplash.com/search/photos?query={}&per_page={}&page=1",
        query, per_page
    );
    let response = client
        .get(&url)
        .header("Authorization", format!("Client-ID {}", key))
        .send()
        .await?;

    if !response.status().is_success() {
        log::warn!("Unsplash API error: {}", response.status());
        return Ok(vec![]);
    }

    let data: UnsplashResponse = response.json().await?;

    Ok(data
        .results
        .into_iter()
        .map(|photo| ImageResult {
            id: photo.id,
            url: photo.urls.regular,
            full_url: photo.urls.full,
            thumb_url: photo.urls.thumb,
            description: photo
                .description
                .or(photo.alt_description)
                .unwrap_or_else(|| "无描述".to_string()),
            photographer: photo.user.name,
            photographer_url: photo.user.links.html,
            width: photo.width,
            height: photo.height,
            platform: "Unsplash".to_string(),
            validated: false, // Will be validated later
        })
        .collect())
}

/// Search Pexels API
pub async fn search_pexels(query: &str, per_page: u32) -> Result<Vec<ImageResult>> {
    let key =
        get_pexels_key().ok_or_else(|| anyhow::anyhow!("PEXELS_API_KEY not set in environment"))?;

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(10))
        .user_agent("Mozilla/5.0 (compatible; MatrixCode/1.0)")
        .build()?;

    let url = format!(
        "https://api.pexels.com/v1/search?query={}&per_page={}&page=1&locale=zh-CN",
        query, per_page
    );
    let response = client.get(&url).header("Authorization", key).send().await?;

    if !response.status().is_success() {
        log::warn!("Pexels API error: {}", response.status());
        return Ok(vec![]);
    }

    let data: PexelsResponse = response.json().await?;

    Ok(data
        .photos
        .into_iter()
        .map(|photo| ImageResult {
            id: photo.id.to_string(),
            url: photo.src.large,
            full_url: photo.src.original,
            thumb_url: photo.src.medium,
            description: photo.alt.unwrap_or_else(|| "无描述".to_string()),
            photographer: photo.photographer,
            photographer_url: photo.photographer_url,
            width: photo.width,
            height: photo.height,
            platform: "Pexels".to_string(),
            validated: false,
        })
        .collect())
}

/// Search Pixabay API
pub async fn search_pixabay(query: &str, per_page: u32) -> Result<Vec<ImageResult>> {
    let key = get_pixabay_key()
        .ok_or_else(|| anyhow::anyhow!("PIXABAY_API_KEY not set in environment"))?;

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(10))
        .user_agent("Mozilla/5.0 (compatible; MatrixCode/1.0)")
        .build()?;

    let url = format!(
        "https://pixabay.com/api/?key={}&q={}&per_page={}&page=1&image_type=photo&safesearch=true",
        key, query, per_page
    );
    let response = client.get(&url).send().await?;

    if !response.status().is_success() {
        log::warn!("Pixabay API error: {}", response.status());
        return Ok(vec![]);
    }

    let data: PixabayResponse = response.json().await?;

    Ok(data
        .hits
        .into_iter()
        .map(|hit| {
            let user = hit.user.clone();
            ImageResult {
                id: hit.id.to_string(),
                url: hit.webformat_url,
                full_url: hit.large_image_url,
                thumb_url: hit.preview_url,
                description: hit.tags.unwrap_or_else(|| "无描述".to_string()),
                photographer: user.clone(),
                photographer_url: format!("https://pixabay.com/users/{}/{}", user, hit.user_id),
                width: hit.webformat_width,
                height: hit.webformat_height,
                platform: "Pixabay".to_string(),
                validated: false,
            }
        })
        .collect())
}

/// Validate all image URLs concurrently and filter out invalid ones
/// Returns only images with validated URLs
async fn validate_images(images: Vec<ImageResult>) -> Vec<ImageResult> {
    if images.is_empty() {
        return images;
    }

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(5))
        .user_agent("Mozilla/5.0 (compatible; MatrixCode/1.0)")
        .danger_accept_invalid_certs(true) // Some CDNs may have cert issues
        .build()
        .unwrap_or_else(|_| reqwest::Client::new());

    log::info!("Validating {} image URLs...", images.len());

    // Validate all images concurrently
    let mut tasks = Vec::new();
    for img in images {
        let client = client.clone();
        let url = img.url.clone();

        let task = tokio::spawn(async move {
            // Try HEAD first (faster)
            let valid = validate_image_url(&client, &url).await;

            // If HEAD fails (some servers don't support HEAD), try GET
            let valid = if !valid {
                log::debug!("HEAD failed for {}, trying GET...", url);
                validate_image_url_get(&client, &url).await
            } else {
                true
            };

            if valid {
                log::debug!("URL validated: {}", url);
            } else {
                log::debug!("URL invalid: {}", url);
            }

            (img, valid)
        });

        tasks.push(task);
    }

    // Execute all validations concurrently
    let results = futures_util::future::join_all(tasks).await;

    // Filter and return only validated images
    let mut validated = Vec::new();
    let total_count = results.len();

    for result in results {
        if let Ok((mut img, valid)) = result
            && valid
        {
            img.validated = true;
            validated.push(img);
        }
    }

    log::info!("Validated {}/{} images", validated.len(), total_count);
    validated
}

/// Search all platforms and return combined results
/// Only searches platforms that have API keys configured
/// Validates all image URLs before returning
pub async fn search_all(query: &str, per_page: u32) -> Result<Vec<ImageResult>> {
    let mut all_results = Vec::new();
    let mut errors = Vec::new();

    // Search each platform (only if key is available)
    if get_unsplash_key().is_some() {
        match search_unsplash(query, per_page).await {
            Ok(results) => all_results.extend(results),
            Err(e) => errors.push(format!("Unsplash: {}", e)),
        }
    }

    if get_pexels_key().is_some() {
        match search_pexels(query, per_page).await {
            Ok(results) => all_results.extend(results),
            Err(e) => errors.push(format!("Pexels: {}", e)),
        }
    }

    if get_pixabay_key().is_some() {
        match search_pixabay(query, per_page).await {
            Ok(results) => all_results.extend(results),
            Err(e) => errors.push(format!("Pixabay: {}", e)),
        }
    }

    // If no keys configured, return error
    if all_results.is_empty() && errors.is_empty() {
        return Err(anyhow::anyhow!(
            "No image search API keys configured. Set UNSPLASH_ACCESS_KEY, PEXELS_API_KEY, or PIXABAY_API_KEY in environment."
        ));
    }

    // Log errors but return results if any succeeded
    if !errors.is_empty() && all_results.is_empty() {
        return Err(anyhow::anyhow!(
            "All searches failed: {}",
            errors.join("; ")
        ));
    }

    for e in &errors {
        log::warn!("Image search partial error: {}", e);
    }

    // Validate all image URLs
    let total_count = all_results.len();
    let validated_results = validate_images(all_results).await;

    // Return error if all images failed validation
    if validated_results.is_empty() && !errors.is_empty() {
        return Err(anyhow::anyhow!(
            "All {} images failed URL validation. Errors: {}",
            total_count,
            errors.join("; ")
        ));
    }

    Ok(validated_results)
}