Blame for api/src/image/generate.rs

use std::sync::Arc;

use ab_glyph::FontArc;
use image::codecs::jpeg::JpegEncoder;
use image::{imageops, DynamicImage, ImageDecoder, ImageReader, Limits, RgbaImage};
use tokio::sync::Semaphore;

use crate::cache;
use crate::error::AppError;
use crate::image::badge;
use crate::services::db::{BadgeAppearance, BadgeDirection, BadgeSize, BadgeStyle, LabelStyle, BadgePosition, PosterFit};
use crate::services::ratings::RatingBadge;
use crate::services::tmdb::TmdbClient;

/// Threshold (ms) above which render is logged as slow.
const SLOW_RENDER_MS: u64 = 2000;

const BADGE_SPACING: u32 = 10;
const BADGE_BOTTOM_MARGIN: u32 = 10;
const BADGE_TOP_MARGIN: u32 = 20;
const BADGE_SIDE_MARGIN: u32 = 15;
const BADGE_ROW_SPACING: u32 = 7;
const BADGE_VERT_SPACING: u32 = 7;
const BACKDROP_SIDE_MARGIN: u32 = 20;
const MAX_BADGES_PER_ROW: usize = 3;
const MAX_VERT_BADGES_PER_ROW: usize = 5;

pub struct ImageParams<'a> {
    pub poster_path: &'a str,
    pub badges: &'a [RatingBadge],
    pub tmdb: &'a TmdbClient,

    pub font: &'a FontArc,
    pub quality: u8,
    pub cache_dir: &'a str,
    pub image_stale_secs: u64,
    pub poster_bytes_override: Option<Vec<u8>>,
    pub poster_position: BadgePosition,
    pub badge_style: BadgeStyle,
    pub label_style: LabelStyle,
    pub badge_appearance: BadgeAppearance,
    pub badge_direction: BadgeDirection,
    /// When true, split the badges across two opposite sides of the poster.
    pub poster_badge_split: bool,
    /// How a non-2:3 poster is fit to the standard 2:3 output frame.
    pub poster_fit: PosterFit,
    pub render_semaphore: Arc<Semaphore>,
    /// Target width for the output image. Defaults to 500 for posters.
    pub target_width: u32,
    /// Badge scale factor (1.0 = default size).
    pub badge_scale: f32,
    /// TMDB CDN size string (e.g. "w500", "w780", "original").
    pub tmdb_size: Arc<str>,
    /// Badge size — used to adjust max badges per row.
    pub badge_size: BadgeSize,
    /// When true, skip writing base poster images to disk (CDN handles caching).
    pub external_cache_only: bool,
}

pub async fn generate_poster(params: ImageParams<'_>) -> Result<Vec<u8>, AppError> {
    let ImageParams {
        poster_path,
        badges,
        tmdb,
        font,
        quality,
        cache_dir,
        image_stale_secs,
        poster_bytes_override,
        poster_position,
        badge_style,
        label_style,
        badge_appearance,
        badge_direction,
        poster_badge_split,
        poster_fit,
        render_semaphore,
        target_width,
        badge_scale,
        badge_size,
        tmdb_size,
        external_cache_only,
    } = params;

    let poster_bytes = if let Some(bytes) = poster_bytes_override {
        bytes
    } else if external_cache_only {
        // No filesystem cache — always fetch from TMDB
        tmdb.fetch_poster_bytes(poster_path, &tmdb_size).await?
    } else {
        // Fetch base poster from TMDB, using cache
        let poster_cache = cache::base_poster_path(cache_dir, poster_path, &tmdb_size)?;
        if let Some(entry) = cache::read(&poster_cache, image_stale_secs).await {
            if entry.is_stale {
                // Conditional fetch — send If-Modified-Since to avoid re-downloading unchanged images
                let modified = tokio::fs::metadata(&poster_cache).await.ok()
                    .and_then(|m| m.modified().ok());
                match tmdb.fetch_poster_bytes_conditional(poster_path, &tmdb_size, modified).await? {
                    Some(fresh_bytes) => {
                        cache::write(&poster_cache, &fresh_bytes).await?;
                        fresh_bytes
                    }
                    None => {
                        // 304 Not Modified — touch mtime without rewriting the file
                        if let Ok(f) = tokio::fs::File::open(&poster_cache).await {
                            let _ = f.into_std().await.set_modified(std::time::SystemTime::now());
                        }
                        entry.bytes
                    }
                }
            } else {
                entry.bytes
            }
        } else {
            let bytes = tmdb.fetch_poster_bytes(poster_path, &tmdb_size).await?;
            cache::write(&poster_cache, &bytes).await?;
            bytes
        }
    };

    // Acquire render permit before CPU-bound work — also bounds queue depth
    // so tasks waiting for a blocking thread still count against the limit.
    if render_semaphore.available_permits() == 0 {
        tracing::debug!("render queue full, waiting for permit");
    }
    let _permit = render_semaphore.acquire().await
        .map_err(|_| AppError::Other("render queue closed".into()))?;
    tracing::debug!("poster render started");
    let start = std::time::Instant::now();

    // Move CPU-bound image processing to a blocking thread
    let badges = badges.to_vec();
    let font = font.clone();
    let buf = tokio::task::spawn_blocking(move || {
        render_poster_sync(&poster_bytes, &badges, &font, quality, poster_position, badge_style, label_style, badge_appearance, badge_direction, target_width, badge_scale, badge_size, poster_badge_split, poster_fit)
    })
    .await
    .map_err(|e| AppError::Other(e.to_string()))??;

    let render_ms = start.elapsed().as_millis() as u64;
    tracing::debug!(elapsed_ms = render_ms, "poster render complete");
    if render_ms > SLOW_RENDER_MS {
        tracing::warn!(
            poster_path,
            render_ms,
            "slow generate_poster"
        );
    }
    Ok(buf)
}

/// Overlay badges in a vertical column, positioned according to `position`.
///
/// `extra_x` / `extra_y` are additional edge insets in pixels (already resolved
/// for this canvas) that push the badges further from the anchored edge. They
/// only take effect on the edge the position anchors to: `extra_y` on top/bottom
/// anchors, `extra_x` on left/right anchors. Centered axes ignore their inset.
/// Callers that don't want insets pass `0, 0`.
fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], position: BadgePosition, badge_scale: f32, side_margin_base: u32, extra_x: u32, extra_y: u32) {
    let vert_spacing = (BADGE_VERT_SPACING as f32 * badge_scale).round() as u32;
    let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
    let bottom_margin = (BADGE_BOTTOM_MARGIN as f32 * badge_scale).round() as u32;
    let side_margin = (side_margin_base as f32 * badge_scale).round() as u32;

    let total_badge_height: u32 = badge_images.iter().map(|b| b.height()).sum::<u32>()
        + vert_spacing * (badge_images.len() as u32).saturating_sub(1);
    let max_badge_width: u32 = badge_images.iter().map(|b| b.width()).max().unwrap_or(0);

    // Vertical anchor
    let start_y = if position.is_top() {
        top_margin + extra_y
    } else if position.is_bottom() {
        canvas.height().saturating_sub(total_badge_height + bottom_margin + extra_y)
    } else {
        // "l", "r" — vertically centered
        (canvas.height().saturating_sub(total_badge_height)) / 2
    };

    // Horizontal anchor
    let is_left = position.is_left();
    let is_right = position.is_right();

    let base_x = if is_left {
        side_margin + extra_x
    } else if is_right {
        canvas.width().saturating_sub(max_badge_width + side_margin + extra_x)
    } else {
        // center
        (canvas.width().saturating_sub(max_badge_width)) / 2
    };

    let mut y = start_y;
    for badge_img in badge_images {
        let bx = if is_left {
            base_x
        } else if is_right {
            base_x + max_badge_width.saturating_sub(badge_img.width())
        } else {
            base_x + (max_badge_width.saturating_sub(badge_img.width())) / 2
        };
        imageops::overlay(canvas, badge_img, bx as i64, y as i64);
        y += badge_img.height() + vert_spacing;
    }
}

/// Overlay badges in horizontal rows, positioned according to `position`.
///
/// `extra_x` / `extra_y` behave as in [`overlay_vertical_stack`]: edge insets in
/// resolved pixels that only apply to the anchored edge (centered axes ignore
/// them). Callers that don't want insets pass `0, 0`.
fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], position: BadgePosition, max_per_row: usize, badge_scale: f32, side_margin_base: u32, extra_x: u32, extra_y: u32) {
    let spacing = (BADGE_SPACING as f32 * badge_scale).round() as u32;
    let row_spacing = (BADGE_ROW_SPACING as f32 * badge_scale).round() as u32;
    let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
    let bottom_margin = (BADGE_BOTTOM_MARGIN as f32 * badge_scale).round() as u32;
    let side_margin = (side_margin_base as f32 * badge_scale).round() as u32;

    let rows: Vec<&[RgbaImage]> = badge_images.chunks(max_per_row).collect();
    let badge_height = badge_images.iter().map(|b| b.height()).max().unwrap_or(0);
    let total_height = badge_height * rows.len() as u32
        + row_spacing * (rows.len() as u32).saturating_sub(1);

    // Vertical anchor
    let base_y = if position.is_top() {
        top_margin + extra_y
    } else if position.is_bottom() {
        canvas.height().saturating_sub(total_height + bottom_margin + extra_y)
    } else {
        // "l", "r" — vertically centered
        (canvas.height().saturating_sub(total_height)) / 2
    };

    // Horizontal alignment
    let is_left = position.is_left();
    let is_right = position.is_right();

    for (row_idx, row) in rows.iter().enumerate() {
        let row_width: u32 = row.iter().map(|b| b.width()).sum::<u32>()
            + spacing * (row.len() as u32).saturating_sub(1);
        let y = base_y + row_idx as u32 * (badge_height + row_spacing);

        let start_x = if is_left {
            side_margin + extra_x
        } else if is_right {
            canvas.width().saturating_sub(row_width + side_margin + extra_x)
        } else {
            (canvas.width().saturating_sub(row_width)) / 2
        };

        let mut x = start_x;
        for badge_img in *row {
            let by = y + (badge_height.saturating_sub(badge_img.height())) / 2;
            imageops::overlay(canvas, badge_img, x as i64, by as i64);
            x += badge_img.width() + spacing;
        }
    }
}

/// Maximum total pixels allowed for a decoded source image (width * height).
/// 8192x8192 = 67M pixels (~256 MB as RGBA) is generous for poster/backdrop art
/// while preventing OOM from crafted images with extreme dimensions.
const MAX_IMAGE_PIXELS: u64 = 8192 * 8192;

/// Decode an image from bytes, rejecting oversized images *before* full decode
/// to avoid OOM from crafted inputs (e.g. PNG bombs).
fn load_image_with_limits(bytes: &[u8]) -> Result<image::DynamicImage, AppError> {
    let reader = ImageReader::new(std::io::Cursor::new(bytes))
        .with_guessed_format()
        .map_err(|e| AppError::Other(format!("image format detection failed: {e}")))?;

    let mut limits = Limits::default();
    limits.max_alloc = Some(MAX_IMAGE_PIXELS * 4); // RGBA = 4 bytes/pixel
    let mut decoder = reader.into_decoder().map_err(AppError::Image)?;
    decoder.set_limits(limits).map_err(AppError::Image)?;

    image::DynamicImage::from_decoder(decoder).map_err(AppError::Image)
}

/// Standard movie-poster aspect ratio is 2:3 (width:height), so the output
/// height for a given width is `width * 3 / 2`.
fn poster_target_height(target_width: u32) -> u32 {
    ((target_width as f64) * 1.5).round() as u32
}

/// Blur strength for `PosterFit::Blur` scales with output width so the effect
/// looks consistent across image sizes. `fast_blur` approximates a Gaussian
/// blur cheaply enough for the largest (2000px) posters.
const BLUR_SIGMA_DIVISOR: f32 = 32.0;

/// Normalize a decoded source poster to the output frame per `fit`, returning
/// the RGBA canvas the badges are then composited onto.
///
/// Every mode except `Native` produces an exact 2:3 frame
/// (`target_width × target_width*3/2`) so downstream apps that place posters in
/// fixed 2:3 containers never crop the art (issue #15).
fn fit_poster(base: DynamicImage, target_width: u32, fit: PosterFit) -> RgbaImage {
    use image::imageops::FilterType::Lanczos3;
    match fit {
        // Preserve the source aspect ratio: scale to target_width only.
        PosterFit::Native => {
            if base.width() == target_width {
                base.to_rgba8()
            } else {
                let scale = target_width as f64 / base.width() as f64;
                let target_height = ((base.height() as f64 * scale).round() as u32).max(1);
                base.resize_exact(target_width, target_height, Lanczos3).to_rgba8()
            }
        }
        // Scale to fill the 2:3 frame, center-cropping the overflow.
        PosterFit::Cover => {
            let th = poster_target_height(target_width);
            base.resize_to_fill(target_width, th, Lanczos3).to_rgba8()
        }
        // Fit the whole poster inside 2:3, padding with solid black bars.
        PosterFit::Pad => {
            let th = poster_target_height(target_width);
            let fitted = base.resize(target_width, th, Lanczos3).to_rgba8();
            let mut canvas = RgbaImage::from_pixel(target_width, th, image::Rgba([0, 0, 0, 255]));
            let x = ((target_width.saturating_sub(fitted.width())) / 2) as i64;
            let y = ((th.saturating_sub(fitted.height())) / 2) as i64;
            imageops::overlay(&mut canvas, &fitted, x, y);
            canvas
        }
        // Fit the whole poster inside 2:3, filling the bars with a blurred,
        // zoomed copy of the poster.
        PosterFit::Blur => {
            let th = poster_target_height(target_width);
            let bg = base.resize_to_fill(target_width, th, Lanczos3).to_rgba8();
            let sigma = (target_width as f32 / BLUR_SIGMA_DIVISOR).max(1.0);
            let mut canvas = imageops::fast_blur(&bg, sigma);
            let fitted = base.resize(target_width, th, Lanczos3).to_rgba8();
            let x = ((target_width.saturating_sub(fitted.width())) / 2) as i64;
            let y = ((th.saturating_sub(fitted.height())) / 2) as i64;
            imageops::overlay(&mut canvas, &fitted, x, y);
            canvas
        }
    }
}

pub fn render_poster_sync(
    poster_bytes: &[u8],
    badges: &[RatingBadge],
    font: &FontArc,
    quality: u8,
    poster_position: BadgePosition,
    badge_style: BadgeStyle,
    label_style: LabelStyle,
    badge_appearance: BadgeAppearance,
    badge_direction: BadgeDirection,
    target_width: u32,
    badge_scale: f32,
    badge_size: BadgeSize,
    poster_badge_split: bool,
    poster_fit: PosterFit,
) -> Result<Vec<u8>, AppError> {
    // A pill is a horizontal lozenge (icon/label left, value right) — never a
    // vertical stacked badge, even when the configured style is vertical.
    let badge_style = badge_style.for_shape(badge_appearance.shape);
    let base = load_image_with_limits(poster_bytes)?;

    // Normalize to the output frame (2:3 for every mode except Native) before
    // overlaying badges, so badges anchor to the final frame corners.
    let mut canvas: RgbaImage = fit_poster(base, target_width, poster_fit);

    if !badges.is_empty() {
        let badge_images: Vec<RgbaImage> = if badge_style.is_vertical() {
            badges.iter().map(|b| badge::render_vertical_badge(b, font, label_style, badge_appearance, badge_scale)).collect()
        } else {
            badge::render_badges_uniform(badges, font, label_style, badge_appearance, badge_scale)
        };

        let max_per_row = match badge_size {
            BadgeSize::Large | BadgeSize::ExtraLarge => {
                if badge_style == BadgeStyle::Horizontal { 2 } else { 4 }
            }
            _ => {
                if badge_style.is_vertical() { MAX_VERT_BADGES_PER_ROW } else { MAX_BADGES_PER_ROW }
            }
        };

        if poster_badge_split && badge_images.len() >= 2 {
            // Split the badges across two opposite sides. A vertical badge layout
            // splits left/right; horizontal rows split top/bottom. The first
            // (higher-priority) half keeps the configured anchor side.
            let split_top_bottom = !badge_direction.is_vertical();
            let (primary, opposite) = poster_position.split_anchors(split_top_bottom);
            let mid = badge_images.len().div_ceil(2);
            let (first, second) = badge_images.split_at(mid);
            overlay_poster_group(&mut canvas, first, primary, badge_direction, max_per_row, badge_scale);
            overlay_poster_group(&mut canvas, second, opposite, badge_direction, max_per_row, badge_scale);
        } else {
            overlay_poster_group(&mut canvas, &badge_images, poster_position, badge_direction, max_per_row, badge_scale);
        }
    }

    // Encode as JPEG
    let dynamic = DynamicImage::ImageRgba8(canvas);
    let rgb = dynamic.to_rgb8();
    let mut buf = Vec::new();
    let encoder = JpegEncoder::new_with_quality(&mut buf, quality);
    rgb.write_with_encoder(encoder)?;

    Ok(buf)
}

/// Overlay one group of poster badges at `position`, using the configured
/// stacking direction. Vertical direction stacks a column; horizontal direction
/// lays out rows of up to `max_per_row` badges.
fn overlay_poster_group(
    canvas: &mut RgbaImage,
    badge_images: &[RgbaImage],
    position: BadgePosition,
    badge_direction: BadgeDirection,
    max_per_row: usize,
    badge_scale: f32,
) {
    if badge_direction.is_vertical() {
        overlay_vertical_stack(canvas, badge_images, position, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
    } else {
        overlay_horizontal_rows(canvas, badge_images, position, max_per_row, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
    }
}

/// Fixed vertical space (px, at badge_scale = 1.0) reserved for the logo artwork.
/// TMDB logo assets vary wildly in native aspect ratio — some are short/wide
/// wordmarks, others are tall vertical scripts. Previously the logo was resized to
/// a fixed *width* only, letting height float with the source shape, which made the
/// total composite a different overall size per title — so Stremio's own image-fit
/// scaling applied a different effective zoom to the embedded badges depending on
/// each logo's shape. Reserving a fixed box and "contain"-fitting every logo into it
/// (centered, never cropped) keeps the composite's overall dimensions — and
/// therefore the badges' on-screen size — constant across all titles.
const LOGO_AREA_HEIGHT: u32 = 150;

/// Resize `img` to fit entirely within `box_width` x `box_height` (preserving aspect
/// ratio, never upscaling, never cropping), then center it on a transparent canvas
/// of exactly `box_width` x `box_height`.
fn fit_and_pad(img: &RgbaImage, box_width: u32, box_height: u32) -> RgbaImage {
    let scale = (box_width as f64 / img.width() as f64)
        .min(box_height as f64 / img.height() as f64);
    let new_w = ((img.width() as f64 * scale).round() as u32).max(1);
    let new_h = ((img.height() as f64 * scale).round() as u32).max(1);

    let resized = if new_w == img.width() && new_h == img.height() {
        img.clone()
    } else {
        imageops::resize(img, new_w, new_h, image::imageops::FilterType::Lanczos3)
    };

    let mut canvas = RgbaImage::new(box_width, box_height);
    let x = (box_width.saturating_sub(new_w)) / 2;
    let y = (box_height.saturating_sub(new_h)) / 2;
    imageops::overlay(&mut canvas, &resized, x as i64, y as i64);
    canvas
}

const LOGO_BADGE_ROW_SPACING: u32 = 7;
const LOGO_BADGE_SPACING: u32 = 10;
const LOGO_MAX_BADGES_PER_ROW: usize = 3;
const LOGO_SPACING_BELOW: u32 = 15;

pub fn render_logo_sync(
    logo_bytes: &[u8],
    badges: &[RatingBadge],
    font: &FontArc,
    badge_style: BadgeStyle,
    label_style: LabelStyle,
    badge_appearance: BadgeAppearance,
    target_width: u32,
    badge_scale: f32,
) -> Result<Vec<u8>, AppError> {
    // A pill is a horizontal lozenge (icon/label left, value right) — never a
    // vertical stacked badge, even when the configured style is vertical.
    let badge_style = badge_style.for_shape(badge_appearance.shape);
    let base = load_image_with_limits(logo_bytes)?;

    let base = if base.width() != target_width {
        let scale = target_width as f64 / base.width() as f64;
        let target_height = (base.height() as f64 * scale).round() as u32;
        base.resize_exact(target_width, target_height, image::imageops::FilterType::Lanczos3)
    } else {
        base
    };

    if badges.is_empty() {
        // No badges — just encode the logo as PNG
        let logo_img = base.to_rgba8();
        let mut buf = Vec::new();
        let encoder = image::codecs::png::PngEncoder::new(&mut buf);
        image::ImageEncoder::write_image(
            encoder,
            logo_img.as_raw(),
            logo_img.width(),
            logo_img.height(),
            image::ExtendedColorType::Rgba8,
        )?;
        return Ok(buf);
    }

    let logo_area_height = (LOGO_AREA_HEIGHT as f32 * badge_scale).round().max(1.0) as u32;
    let logo_img = fit_and_pad(&base.to_rgba8(), target_width, logo_area_height);

    let logo_badge_spacing = (LOGO_BADGE_SPACING as f32 * badge_scale).round() as u32;
    let logo_badge_row_spacing = (LOGO_BADGE_ROW_SPACING as f32 * badge_scale).round() as u32;
    let logo_spacing_below = (LOGO_SPACING_BELOW as f32 * badge_scale).round() as u32;

    if badge_style.is_vertical() {
        // Vertical badge shapes arranged in rows below the logo
        let badge_images: Vec<RgbaImage> = badges
                .iter()
                .map(|b| badge::render_vertical_badge(b, font, label_style, badge_appearance, badge_scale))
                .collect();

            let rows: Vec<&[RgbaImage]> = badge_images.chunks(MAX_VERT_BADGES_PER_ROW).collect();
            let max_badge_height: u32 = badge_images.iter().map(|b| b.height()).max().unwrap_or(0);
            let total_badge_height = max_badge_height * rows.len() as u32
                + logo_badge_row_spacing * (rows.len() as u32).saturating_sub(1);

            let max_row_width: u32 = rows
                .iter()
                .map(|row| {
                    row.iter().map(|b| b.width()).sum::<u32>()
                        + logo_badge_spacing * (row.len() as u32).saturating_sub(1)
                })
                .max()
                .unwrap_or(0);

            let canvas_width = target_width.max(max_row_width);
            let canvas_height = logo_area_height + logo_spacing_below + total_badge_height;

            let mut canvas = RgbaImage::new(canvas_width, canvas_height);

            let logo_x = (canvas_width.saturating_sub(logo_img.width())) / 2;
            imageops::overlay(&mut canvas, &logo_img, logo_x as i64, 0);

            let badges_start_y = logo_area_height + logo_spacing_below;
            for (row_idx, row) in rows.iter().enumerate() {
                let row_width: u32 = row.iter().map(|b| b.width()).sum::<u32>()
                    + logo_badge_spacing * (row.len() as u32).saturating_sub(1);
                let start_x = (canvas_width.saturating_sub(row_width)) / 2;
                let y = badges_start_y + row_idx as u32 * (max_badge_height + logo_badge_row_spacing);

                let mut x = start_x;
                for badge_img in *row {
                    let by = y + (max_badge_height.saturating_sub(badge_img.height())) / 2;
                    imageops::overlay(&mut canvas, badge_img, x as i64, by as i64);
                    x += badge_img.width() + logo_badge_spacing;
                }
            }

            // Encode as PNG
            let mut buf = Vec::new();
            let encoder = image::codecs::png::PngEncoder::new(&mut buf);
            image::ImageEncoder::write_image(
                encoder,
                canvas.as_raw(),
                canvas.width(),
                canvas.height(),
                image::ExtendedColorType::Rgba8,
            )?;
            Ok(buf)
    } else {
        // Horizontal badge images (default) — uniform widths, arranged in rows below the logo
            let badge_images = badge::render_badges_uniform(badges, font, label_style, badge_appearance, badge_scale);

            let rows: Vec<&[RgbaImage]> = badge_images.chunks(LOGO_MAX_BADGES_PER_ROW).collect();
            let badge_height = badge_images[0].height();
            let total_badge_height =
                badge_height * rows.len() as u32 + logo_badge_row_spacing * (rows.len() as u32).saturating_sub(1);

            // Compute row widths to determine canvas width
            let max_row_width: u32 = rows
                .iter()
                .map(|row| {
                    row.iter().map(|b| b.width()).sum::<u32>()
                        + logo_badge_spacing * (row.len() as u32).saturating_sub(1)
                })
                .max()
                .unwrap_or(0);

            let canvas_width = target_width.max(max_row_width);
            let canvas_height = logo_area_height + logo_spacing_below + total_badge_height;

            let mut canvas = RgbaImage::new(canvas_width, canvas_height);

            // Center logo at top
            let logo_x = (canvas_width.saturating_sub(logo_img.width())) / 2;
            imageops::overlay(&mut canvas, &logo_img, logo_x as i64, 0);

            // Center badge rows below logo
            let badges_start_y = logo_area_height + logo_spacing_below;
            for (row_idx, row) in rows.iter().enumerate() {
                let row_width: u32 = row.iter().map(|b| b.width()).sum::<u32>()
                    + logo_badge_spacing * (row.len() as u32).saturating_sub(1);
                let start_x = (canvas_width.saturating_sub(row_width)) / 2;
                let y = badges_start_y + row_idx as u32 * (badge_height + logo_badge_row_spacing);

                let mut x = start_x;
                for badge_img in *row {
                    imageops::overlay(&mut canvas, badge_img, x as i64, y as i64);
                    x += badge_img.width() + logo_badge_spacing;
                }
            }

            // Encode as PNG (preserves transparency)
            let mut buf = Vec::new();
            let encoder = image::codecs::png::PngEncoder::new(&mut buf);
            image::ImageEncoder::write_image(
                encoder,
                canvas.as_raw(),
                canvas.width(),
                canvas.height(),
                image::ExtendedColorType::Rgba8,
            )?;
            Ok(buf)
    }
}

pub async fn generate_logo(
    logo_bytes: Vec<u8>,
    badges: Vec<RatingBadge>,
    font: FontArc,
    badge_style: BadgeStyle,
    label_style: LabelStyle,
    badge_appearance: BadgeAppearance,
    render_semaphore: Arc<Semaphore>,
    target_width: u32,
    badge_scale: f32,
) -> Result<Vec<u8>, AppError> {
    if render_semaphore.available_permits() == 0 {
        tracing::debug!("render queue full, waiting for permit");
    }
    let _permit = render_semaphore.acquire().await
        .map_err(|_| AppError::Other("render queue closed".into()))?;
    tracing::debug!("logo render started");
    let start = std::time::Instant::now();

    let buf = tokio::task::spawn_blocking(move || render_logo_sync(&logo_bytes, &badges, &font, badge_style, label_style, badge_appearance, target_width, badge_scale))
        .await
        .map_err(|e| AppError::Other(e.to_string()))??;

    tracing::debug!(elapsed_ms = start.elapsed().as_millis() as u64, "logo render complete");
    Ok(buf)
}

pub fn render_backdrop_sync(
    backdrop_bytes: &[u8],
    badges: &[RatingBadge],
    font: &FontArc,
    quality: u8,
    position: BadgePosition,
    badge_style: BadgeStyle,
    label_style: LabelStyle,
    badge_appearance: BadgeAppearance,
    badge_direction: BadgeDirection,
    target_width: u32,
    badge_scale: f32,
    _badge_size: BadgeSize,
    edge_inset_x: i32,
    edge_inset_y: i32,
) -> Result<Vec<u8>, AppError> {
    // A pill is a horizontal lozenge (icon/label left, value right) — never a
    // vertical stacked badge, even when the configured style is vertical.
    let badge_style = badge_style.for_shape(badge_appearance.shape);
    let base = load_image_with_limits(backdrop_bytes)?;

    let base = if base.width() != target_width {
        let scale = target_width as f64 / base.width() as f64;
        let target_height = (base.height() as f64 * scale).round() as u32;
        base.resize_exact(target_width, target_height, image::imageops::FilterType::Lanczos3)
    } else {
        base
    };

    let mut canvas: RgbaImage = base.to_rgba8();

    if !badges.is_empty() {
        let badge_images: Vec<RgbaImage> = if badge_style.is_vertical() {
            badges.iter().map(|b| badge::render_vertical_badge(b, font, label_style, badge_appearance, badge_scale)).collect()
        } else {
            badge::render_badges_uniform(badges, font, label_style, badge_appearance, badge_scale)
        };

        // Edge insets are a percentage of the canvas dimension, so they stay
        // proportional across image sizes (small/medium/large). The overlay
        // functions only apply each axis on the edge the position anchors to.
        // Clamp to the same MAX_EDGE_INSET the settings/cache-key paths use so the
        // rendered inset can never diverge from the value baked into the cache key.
        let inset_pct_x = crate::services::db::clamp_edge_inset(edge_inset_x) as f32 / 100.0;
        let inset_pct_y = crate::services::db::clamp_edge_inset(edge_inset_y) as f32 / 100.0;
        let extra_x = (canvas.width() as f32 * inset_pct_x).round() as u32;
        let extra_y = (canvas.height() as f32 * inset_pct_y).round() as u32;

        if badge_direction.is_vertical() {
            overlay_vertical_stack(&mut canvas, &badge_images, position, badge_scale, BACKDROP_SIDE_MARGIN, extra_x, extra_y);
        } else {
            // Backdrops are wide (16:9) so all badges fit in a single row
            overlay_horizontal_rows(&mut canvas, &badge_images, position, badge_images.len(), badge_scale, BACKDROP_SIDE_MARGIN, extra_x, extra_y);
        }
    }

    // Encode as JPEG
    let dynamic = DynamicImage::ImageRgba8(canvas);
    let rgb = dynamic.to_rgb8();
    let mut buf = Vec::new();
    let encoder = JpegEncoder::new_with_quality(&mut buf, quality);
    rgb.write_with_encoder(encoder)?;
    Ok(buf)
}

pub async fn generate_backdrop(
    backdrop_bytes: Vec<u8>,
    badges: Vec<RatingBadge>,
    font: FontArc,
    quality: u8,
    position: BadgePosition,
    badge_style: BadgeStyle,
    label_style: LabelStyle,
    badge_appearance: BadgeAppearance,
    badge_direction: BadgeDirection,
    render_semaphore: Arc<Semaphore>,
    target_width: u32,
    badge_scale: f32,
    badge_size: BadgeSize,
    edge_inset_x: i32,
    edge_inset_y: i32,
) -> Result<Vec<u8>, AppError> {
    if render_semaphore.available_permits() == 0 {
        tracing::debug!("render queue full, waiting for permit");
    }
    let _permit = render_semaphore.acquire().await
        .map_err(|_| AppError::Other("render queue closed".into()))?;
    tracing::debug!("backdrop render started");
    let start = std::time::Instant::now();

    let buf = tokio::task::spawn_blocking(move || render_backdrop_sync(&backdrop_bytes, &badges, &font, quality, position, badge_style, label_style, badge_appearance, badge_direction, target_width, badge_scale, badge_size, edge_inset_x, edge_inset_y))
        .await
        .map_err(|e| AppError::Other(e.to_string()))??;

    tracing::debug!(elapsed_ms = start.elapsed().as_millis() as u64, "backdrop render complete");
    Ok(buf)
}

/// Episode still rendering with configurable position, direction, and optional blur.
/// Reuses the poster badge overlay functions but with episode-specific settings.
pub fn render_episode_sync(
    image_bytes: &[u8],
    badges: &[RatingBadge],
    font: &FontArc,
    quality: u8,
    position: BadgePosition,
    badge_style: BadgeStyle,
    label_style: LabelStyle,
    badge_appearance: BadgeAppearance,
    badge_direction: BadgeDirection,
    target_width: u32,
    badge_scale: f32,
    badge_size: BadgeSize,
    blur: bool,
) -> Result<Vec<u8>, AppError> {
    // A pill is a horizontal lozenge (icon/label left, value right) — never a
    // vertical stacked badge, even when the configured style is vertical.
    let badge_style = badge_style.for_shape(badge_appearance.shape);
    let base = image::load_from_memory(image_bytes)
        .map_err(AppError::Image)?;

    let base = if base.width() != target_width {
        let scale = target_width as f64 / base.width() as f64;
        let target_height = (base.height() as f64 * scale).round() as u32;
        base.resize_exact(target_width, target_height, image::imageops::FilterType::Lanczos3)
    } else {
        base
    };

    let mut canvas: RgbaImage = base.to_rgba8();

    // Apply blur for spoiler protection (before badge overlay).
    // Downscale → small blur → upscale is much faster than a large-radius Gaussian
    // and visually equivalent for spoiler hiding.
    if blur && canvas.width() >= 8 && canvas.height() >= 8 {
        let (w, h) = (canvas.width(), canvas.height());
        let small = image::imageops::resize(&canvas, w / 8, h / 8, image::imageops::FilterType::Triangle);
        let small = imageproc::filter::gaussian_blur_f32(&small, 3.0);
        canvas = image::imageops::resize(&small, w, h, image::imageops::FilterType::Triangle);
    }

    if !badges.is_empty() {
        let badge_images: Vec<RgbaImage> = if badge_style.is_vertical() {
            badges.iter().map(|b| badge::render_vertical_badge(b, font, label_style, badge_appearance, badge_scale)).collect()
        } else {
            badge::render_badges_uniform(badges, font, label_style, badge_appearance, badge_scale)
        };

        if badge_direction.is_vertical() {
            overlay_vertical_stack(&mut canvas, &badge_images, position, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
        } else {
            let max_per_row = match badge_size {
                BadgeSize::Large | BadgeSize::ExtraLarge => {
                    if badge_style == BadgeStyle::Horizontal { 2 } else { 4 }
                }
                _ => {
                    if badge_style.is_vertical() { MAX_VERT_BADGES_PER_ROW } else { MAX_BADGES_PER_ROW }
                }
            };
            overlay_horizontal_rows(&mut canvas, &badge_images, position, max_per_row, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
        }
    }

    // Encode as JPEG
    let dynamic = DynamicImage::ImageRgba8(canvas);
    let rgb = dynamic.to_rgb8();
    let mut buf = Vec::new();
    let encoder = JpegEncoder::new_with_quality(&mut buf, quality);
    rgb.write_with_encoder(encoder)?;
    Ok(buf)
}

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

    #[test]
    fn render_poster_no_badges() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        // Create a minimal valid PNG in memory
        let img = image::RgbaImage::from_pixel(100, 150, image::Rgba([128, 128, 128, 255]));
        let mut png_bytes = Vec::new();
        let encoder = image::codecs::png::PngEncoder::new(&mut png_bytes);
        image::ImageEncoder::write_image(
            encoder,
            img.as_raw(),
            100,
            150,
            image::ExtendedColorType::Rgba8,
        )
        .unwrap();

        let result = render_poster_sync(&png_bytes, &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert!(!result.is_empty());
        // Should be valid JPEG
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_poster_with_badges() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let img = image::RgbaImage::from_pixel(500, 750, image::Rgba([128, 128, 128, 255]));
        let mut png_bytes = Vec::new();
        let encoder = image::codecs::png::PngEncoder::new(&mut png_bytes);
        image::ImageEncoder::write_image(
            encoder,
            img.as_raw(),
            500,
            750,
            image::ExtendedColorType::Rgba8,
        )
        .unwrap();

        let badges = vec![
            RatingBadge {
                source: RatingSource::Imdb,
                value: "8.5".to_string(),
            },
            RatingBadge {
                source: RatingSource::Tmdb,
                value: "85%".to_string(),
            },
            RatingBadge {
                source: RatingSource::Rt,
                value: "92%".to_string(),
            },
            RatingBadge {
                source: RatingSource::Metacritic,
                value: "78".to_string(),
            },
        ];

        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_poster_invalid_image_bytes() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(b"not an image", &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native);
        assert!(result.is_err());
    }

    /// Helper: create a minimal PNG in memory.
    fn test_png(width: u32, height: u32) -> Vec<u8> {
        let img = image::RgbaImage::from_pixel(width, height, image::Rgba([128, 128, 128, 255]));
        let mut buf = Vec::new();
        let encoder = image::codecs::png::PngEncoder::new(&mut buf);
        image::ImageEncoder::write_image(
            encoder,
            img.as_raw(),
            width,
            height,
            image::ExtendedColorType::Rgba8,
        )
        .unwrap();
        buf
    }

    #[test]
    fn render_logo_no_badges() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(200, 80);
        let result = render_logo_sync(&png, &[], &font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), 500, 1.0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(&result[..4], &[0x89, b'P', b'N', b'G']);
    }

    #[test]
    fn render_logo_with_badges() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(400, 100);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
        ];
        let result = render_logo_sync(&png, &badges, &font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), 500, 1.0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(&result[..4], &[0x89, b'P', b'N', b'G']);
    }

    #[test]
    fn pill_renders_horizontally_regardless_of_style() {
        use crate::services::db::{BadgeBackground, BadgeShape};
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(400, 100);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
        ];
        let pill = BadgeAppearance { shape: BadgeShape::Pill, background: BadgeBackground::Default };
        let rounded = BadgeAppearance::default();

        // A pill ignores the vertical style and always renders horizontally, so
        // vertical+pill and horizontal+pill produce identical output.
        let v_pill = render_logo_sync(&png, &badges, &font, BadgeStyle::Vertical, LabelStyle::Official, pill, 500, 1.0).unwrap();
        let h_pill = render_logo_sync(&png, &badges, &font, BadgeStyle::Horizontal, LabelStyle::Official, pill, 500, 1.0).unwrap();
        assert_eq!(v_pill, h_pill, "pill should render horizontally even when the style is vertical");

        // Rounded badges still honour the style, so the two layouts differ.
        let v_round = render_logo_sync(&png, &badges, &font, BadgeStyle::Vertical, LabelStyle::Official, rounded, 500, 1.0).unwrap();
        let h_round = render_logo_sync(&png, &badges, &font, BadgeStyle::Horizontal, LabelStyle::Official, rounded, 500, 1.0).unwrap();
        assert_ne!(v_round, h_round, "rounded badges should still differ between vertical and horizontal styles");
    }

    #[test]
    fn render_logo_downscales_wide_image() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        // Create a logo wider than TARGET_WIDTH (500)
        let png = test_png(1000, 200);
        let result = render_logo_sync(&png, &[], &font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), 500, 1.0).unwrap();
        assert!(!result.is_empty());
        // Verify the output is valid PNG and was produced (implicitly downscaled)
        assert_eq!(&result[..4], &[0x89, b'P', b'N', b'G']);
    }

    #[test]
    fn render_logo_invalid_bytes() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_logo_sync(b"not an image", &[], &font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), 500, 1.0);
        assert!(result.is_err());
    }

    #[test]
    fn render_backdrop_no_badges() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(640, 360);
        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        // Backdrop outputs JPEG
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_backdrop_with_badges() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
        ];
        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_backdrop_downscales_wide_image() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        // Create a backdrop wider than TARGET_WIDTH (1280)
        let png = test_png(2560, 1440);
        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_backdrop_invalid_bytes() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_backdrop_sync(b"not an image", &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0);
        assert!(result.is_err());
    }

    #[test]
    fn render_backdrop_horizontal_bottom_center() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
        ];
        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_backdrop_horizontal_large_badges() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
            RatingBadge { source: RatingSource::RtAudience, value: "80%".to_string() },
        ];
        // Large + Horizontal style — all badges in a single row on wide backdrop
        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 1.0, BadgeSize::Large, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_backdrop_vertical_bottom_left() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
        ];
        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomLeft, BadgeStyle::Vertical, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_backdrop_edge_inset_shifts_only_active_axis() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
        ];
        let render = |pos: BadgePosition, x: i32, y: i32| {
            render_backdrop_sync(&png, &badges, &font, 85, pos, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, x, y).unwrap()
        };

        // TopRight anchors to both a horizontal and vertical edge, so both insets
        // move the badges (the JPEG encoder is deterministic, so bytes differ).
        assert_ne!(render(BadgePosition::TopRight, 0, 0), render(BadgePosition::TopRight, 10, 0));
        assert_ne!(render(BadgePosition::TopRight, 0, 0), render(BadgePosition::TopRight, 0, 10));

        // TopCenter is horizontally centered → the horizontal inset is a no-op,
        // but the vertical inset still applies.
        assert_eq!(render(BadgePosition::TopCenter, 0, 0), render(BadgePosition::TopCenter, 10, 0));
        assert_ne!(render(BadgePosition::TopCenter, 0, 0), render(BadgePosition::TopCenter, 0, 10));

        // Right is vertically centered → the vertical inset is a no-op, but the
        // horizontal inset still applies.
        assert_eq!(render(BadgePosition::Right, 0, 0), render(BadgePosition::Right, 0, 10));
        assert_ne!(render(BadgePosition::Right, 0, 0), render(BadgePosition::Right, 10, 0));
    }

    // --- Episode rendering tests ---

    #[test]
    fn render_episode_no_badges() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(780, 439);
        let result = render_episode_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 780, 1.0, BadgeSize::Large, false).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_episode_with_badges() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(780, 439);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
        ];
        let result = render_episode_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 780, 1.0, BadgeSize::Large, false).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_episode_with_blur() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(780, 439);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
        ];
        let result = render_episode_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 780, 1.0, BadgeSize::Large, true).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_episode_downscales_wide_image() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1920, 1080);
        let result = render_episode_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 780, 1.0, BadgeSize::Large, false).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_episode_invalid_bytes() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_episode_sync(b"not an image", &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 780, 1.0, BadgeSize::Large, false);
        assert!(result.is_err());
    }

    #[test]
    fn render_poster_top_center_produces_valid_jpeg() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png_bytes = test_png(500, 750);
        let badges = vec![
            RatingBadge {
                source: RatingSource::Imdb,
                value: "8.5".to_string(),
            },
        ];
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::TopCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }



    #[test]
    fn render_poster_left_position_produces_valid_jpeg() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png_bytes = test_png(500, 750);
        let badges = vec![
            RatingBadge {
                source: RatingSource::Imdb,
                value: "8.5".to_string(),
            },
        ];
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::Left, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_poster_right_position_produces_valid_jpeg() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png_bytes = test_png(500, 750);
        let badges = vec![
            RatingBadge {
                source: RatingSource::Imdb,
                value: "8.5".to_string(),
            },
        ];
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::Right, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_poster_with_icon_label_style() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png_bytes = test_png(500, 750);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
        ];
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_poster_vertical_badge_direction() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png_bytes = test_png(500, 750);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
        ];
        // vertical direction at bottom-center
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);

        // vertical direction at top-left corner
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::TopLeft, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);

        // vertical direction at bottom-right corner
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_logo_with_icon_label_style() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(400, 100);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
        ];
        let result = render_logo_sync(&png, &badges, &font, BadgeStyle::Horizontal, LabelStyle::Icon, BadgeAppearance::default(), 500, 1.0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(&result[..4], &[0x89, b'P', b'N', b'G']);
    }

    #[test]
    fn render_backdrop_with_icon_label_style() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
        ];
        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_poster_with_official_label_style() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png_bytes = test_png(500, 750);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
            RatingBadge { source: RatingSource::RtAudience, value: "45%".to_string() },
        ];
        let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    #[test]
    fn render_logo_with_official_label_style() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(400, 100);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
        ];
        let result = render_logo_sync(&png, &badges, &font, BadgeStyle::Horizontal, LabelStyle::Official, BadgeAppearance::default(), 500, 1.0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(&result[..4], &[0x89, b'P', b'N', b'G']);
    }

    #[test]
    fn render_backdrop_with_official_label_style() {
        use crate::services::ratings::{RatingBadge, RatingSource};

        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(1280, 720);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
            RatingBadge { source: RatingSource::RtAudience, value: "40%".to_string() },
        ];
        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    fn dummy_tmdb() -> crate::services::tmdb::TmdbClient {
        crate::services::tmdb::TmdbClient::new("test".to_string(), reqwest::Client::new())
    }

    #[tokio::test]
    async fn generate_poster_acquires_semaphore() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(100, 150);
        let sem = Arc::new(Semaphore::new(2));
        let tmdb = dummy_tmdb();

        let result = generate_poster(ImageParams {
            poster_bytes_override: Some(png),
            poster_path: "",
            badges: &[],
            tmdb: &tmdb,
            font: &font,
            quality: 85,
            cache_dir: "/tmp",
            image_stale_secs: 3600,
            poster_position: BadgePosition::BottomCenter,
            badge_style: BadgeStyle::Horizontal,
            label_style: LabelStyle::Text,
            badge_appearance: BadgeAppearance::default(),
            badge_direction: BadgeDirection::Horizontal,
            poster_badge_split: false,
            poster_fit: PosterFit::Native,
            render_semaphore: sem.clone(),
            target_width: 500,
            badge_scale: 1.0,
            tmdb_size: Arc::from("w500"),
            badge_size: BadgeSize::Medium,
            external_cache_only: false,
        })
        .await;

        assert!(result.is_ok());
        // Permit should be released after render
        assert_eq!(sem.available_permits(), 2);
    }

    #[tokio::test]
    async fn generate_poster_closed_semaphore_returns_error() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(100, 150);
        let sem = Arc::new(Semaphore::new(1));
        sem.close();
        let tmdb = dummy_tmdb();

        let result = generate_poster(ImageParams {
            poster_bytes_override: Some(png),
            poster_path: "",
            badges: &[],
            tmdb: &tmdb,
            font: &font,
            quality: 85,
            cache_dir: "/tmp",
            image_stale_secs: 3600,
            poster_position: BadgePosition::BottomCenter,
            badge_style: BadgeStyle::Horizontal,
            label_style: LabelStyle::Text,
            badge_appearance: BadgeAppearance::default(),
            badge_direction: BadgeDirection::Horizontal,
            poster_badge_split: false,
            poster_fit: PosterFit::Native,
            render_semaphore: sem,
            target_width: 500,
            badge_scale: 1.0,
            tmdb_size: Arc::from("w500"),
            badge_size: BadgeSize::Medium,
            external_cache_only: false,
        })
        .await;

        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(err_msg.contains("render queue closed"), "expected 'render queue closed', got: {err_msg}");
    }

    #[tokio::test]
    async fn generate_logo_acquires_and_releases_semaphore() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(200, 80);
        let sem = Arc::new(Semaphore::new(1));

        let result = generate_logo(png, vec![], font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), sem.clone(), 500, 1.0).await;
        assert!(result.is_ok());
        assert_eq!(sem.available_permits(), 1);
    }

    #[tokio::test]
    async fn generate_logo_closed_semaphore_returns_error() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(200, 80);
        let sem = Arc::new(Semaphore::new(1));
        sem.close();

        let result = generate_logo(png, vec![], font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), sem, 500, 1.0).await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn generate_backdrop_acquires_and_releases_semaphore() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(640, 360);
        let sem = Arc::new(Semaphore::new(1));

        let result = generate_backdrop(png, vec![], font, 85, BadgePosition::TopRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, sem.clone(), 1280, 1.0, BadgeSize::Medium, 0, 0).await;
        assert!(result.is_ok());
        assert_eq!(sem.available_permits(), 1);
    }

    #[tokio::test]
    async fn generate_backdrop_closed_semaphore_returns_error() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(640, 360);
        let sem = Arc::new(Semaphore::new(1));
        sem.close();

        let result = generate_backdrop(png, vec![], font, 85, BadgePosition::TopRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, sem, 1280, 1.0, BadgeSize::Medium, 0, 0).await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn semaphore_bounds_concurrent_logo_renders() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let sem = Arc::new(Semaphore::new(1));

        // Acquire the only permit
        let permit = sem.clone().acquire_owned().await.unwrap();

        let png = test_png(200, 80);
        let sem2 = sem.clone();
        let font2 = font.clone();

        // Spawn a render that should block waiting for the permit
        let handle = tokio::spawn(async move {
            generate_logo(png, vec![], font2, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), sem2, 500, 1.0).await
        });

        // Give the task a moment to start and block
        tokio::task::yield_now().await;
        assert_eq!(sem.available_permits(), 0, "permit should still be held");

        // Release the permit so the render can proceed
        drop(permit);
        let result = handle.await.unwrap();
        assert!(result.is_ok());
        assert_eq!(sem.available_permits(), 1);
    }

    #[test]
    fn render_poster_at_large_target_width() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(500, 750);
        // Render at large size (1280 width, ~2.2x badge scale)
        let result = render_poster_sync(&png, &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 2.2, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
        // Verify the output is wider than a default-size render
        let img = image::load_from_memory(&result).unwrap();
        assert_eq!(img.width(), 1280);
    }

    #[test]
    fn render_poster_with_badges_at_large_scale() {
        use crate::services::ratings::{RatingBadge, RatingSource};
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(500, 750);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
        ];
        let result = render_poster_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 2.2, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let img = image::load_from_memory(&result).unwrap();
        assert_eq!(img.width(), 1280);
    }

    #[test]
    fn render_poster_with_large_badge_size() {
        use crate::services::ratings::{RatingBadge, RatingSource};
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(500, 750);
        let badges = vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
        ];
        // Large badge size with horizontal style — should use max 2 per row
        let result = render_poster_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Large, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);

        // Extra-large badge size with vertical style — should use max 4 per row
        let result = render_poster_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 500, 1.0, BadgeSize::ExtraLarge, false, PosterFit::Native).unwrap();
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }

    /// Compute the centroid (center of mass) of non-background pixels in a
    /// rendered poster JPEG. The base image is uniform gray (128,128,128), so
    /// any pixel that deviates significantly is part of a badge overlay.
    /// Returns (centroid_x, centroid_y) as fractions of image dimensions (0.0–1.0).
    fn badge_centroid(jpeg_bytes: &[u8]) -> (f64, f64) {
        let img = image::load_from_memory(jpeg_bytes).unwrap().to_rgba8();
        let (w, h) = (img.width() as f64, img.height() as f64);
        let (mut sx, mut sy, mut count) = (0u64, 0u64, 0u64);
        for (x, y, px) in img.enumerate_pixels() {
            // JPEG compression blurs edges, so use a generous threshold
            let diff = (px[0] as i32 - 128).abs()
                .max((px[1] as i32 - 128).abs())
                .max((px[2] as i32 - 128).abs());
            if diff > 20 {
                sx += x as u64;
                sy += y as u64;
                count += 1;
            }
        }
        assert!(count > 0, "no badge pixels found");
        (sx as f64 / count as f64 / w, sy as f64 / count as f64 / h)
    }

    fn position_test_badges() -> Vec<crate::services::ratings::RatingBadge> {
        use crate::services::ratings::{RatingBadge, RatingSource};
        vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
        ]
    }

    #[test]
    fn badge_position_top_center_places_badges_in_top_region() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
            BadgePosition::TopCenter, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (cx, cy) = badge_centroid(&result);
        assert!(cy < 0.33, "TopCenter: badge y-centroid {cy:.2} should be in top third");
        assert!(cx > 0.3 && cx < 0.7, "TopCenter: badge x-centroid {cx:.2} should be centered");
    }

    #[test]
    fn badge_position_bottom_center_places_badges_in_bottom_region() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
            BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (cx, cy) = badge_centroid(&result);
        assert!(cy > 0.67, "BottomCenter: badge y-centroid {cy:.2} should be in bottom third");
        assert!(cx > 0.3 && cx < 0.7, "BottomCenter: badge x-centroid {cx:.2} should be centered");
    }

    #[test]
    fn badge_position_left_places_badges_on_left_side() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
            BadgePosition::Left, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (cx, cy) = badge_centroid(&result);
        assert!(cx < 0.5, "Left: badge x-centroid {cx:.2} should be in left half");
        assert!(cy > 0.25 && cy < 0.75, "Left: badge y-centroid {cy:.2} should be vertically centered");
    }

    #[test]
    fn badge_position_right_places_badges_on_right_side() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
            BadgePosition::Right, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (cx, cy) = badge_centroid(&result);
        assert!(cx > 0.5, "Right: badge x-centroid {cx:.2} should be in right half");
        assert!(cy > 0.25 && cy < 0.75, "Right: badge y-centroid {cy:.2} should be vertically centered");
    }

    #[test]
    fn badge_position_top_left_places_badges_in_top_left_quadrant() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
            BadgePosition::TopLeft, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (cx, cy) = badge_centroid(&result);
        assert!(cx < 0.5, "TopLeft: badge x-centroid {cx:.2} should be in left half");
        assert!(cy < 0.5, "TopLeft: badge y-centroid {cy:.2} should be in top half");
    }

    #[test]
    fn badge_position_bottom_right_places_badges_in_bottom_right_quadrant() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
            BadgePosition::BottomRight, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (cx, cy) = badge_centroid(&result);
        assert!(cx > 0.5, "BottomRight: badge x-centroid {cx:.2} should be in right half");
        assert!(cy > 0.5, "BottomRight: badge y-centroid {cy:.2} should be in bottom half");
    }

    /// Count non-background badge pixels in each half of a rendered poster.
    /// Returns (top, bottom, left, right) counts. Base art is uniform gray.
    fn badge_pixel_halves(jpeg_bytes: &[u8]) -> (u64, u64, u64, u64) {
        let img = image::load_from_memory(jpeg_bytes).unwrap().to_rgba8();
        let (w, h) = (img.width(), img.height());
        let (mut top, mut bottom, mut left, mut right) = (0u64, 0u64, 0u64, 0u64);
        for (x, y, px) in img.enumerate_pixels() {
            let diff = (px[0] as i32 - 128).abs()
                .max((px[1] as i32 - 128).abs())
                .max((px[2] as i32 - 128).abs());
            if diff > 20 {
                if y < h / 2 { top += 1; } else { bottom += 1; }
                if x < w / 2 { left += 1; } else { right += 1; }
            }
        }
        (top, bottom, left, right)
    }

    fn split_test_badges() -> Vec<crate::services::ratings::RatingBadge> {
        use crate::services::ratings::{RatingBadge, RatingSource};
        vec![
            RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
            RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
            RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
            RatingBadge { source: RatingSource::Metacritic, value: "78".to_string() },
        ]
    }

    #[test]
    fn split_horizontal_places_badges_top_and_bottom() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        // Horizontal rows at bottom-center, split on → half top, half bottom.
        let result = render_poster_sync(&test_png(500, 750), &split_test_badges(), &font, 85,
            BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, true, PosterFit::Native).unwrap();
        let (top, bottom, _l, _r) = badge_pixel_halves(&result);
        assert!(top > 0, "split: expected badge pixels in the top half, got {top}");
        assert!(bottom > 0, "split: expected badge pixels in the bottom half, got {bottom}");

        // Without split, the same config keeps every badge in the bottom half.
        let unsplit = render_poster_sync(&test_png(500, 750), &split_test_badges(), &font, 85,
            BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, false, PosterFit::Native).unwrap();
        let (top_u, _b, _l, _r) = badge_pixel_halves(&unsplit);
        assert_eq!(top_u, 0, "no-split: expected no badge pixels in the top half, got {top_u}");
    }

    #[test]
    fn split_vertical_places_badges_left_and_right() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        // Vertical column, split on → half left, half right.
        let result = render_poster_sync(&test_png(500, 750), &split_test_badges(), &font, 85,
            BadgePosition::Left, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium, true, PosterFit::Native).unwrap();
        let (_t, _b, left, right) = badge_pixel_halves(&result);
        assert!(left > 0, "split: expected badge pixels in the left half, got {left}");
        assert!(right > 0, "split: expected badge pixels in the right half, got {right}");
    }

    #[test]
    fn split_single_badge_does_not_split() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let badges = vec![crate::services::ratings::RatingBadge {
            source: crate::services::ratings::RatingSource::Imdb,
            value: "8.5".to_string(),
        }];
        // Split requested but only one badge → behaves like no split (bottom only).
        let result = render_poster_sync(&test_png(500, 750), &badges, &font, 85,
            BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text,
            BadgeAppearance::default(),
            BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium, true, PosterFit::Native).unwrap();
        let (top, bottom, _l, _r) = badge_pixel_halves(&result);
        assert_eq!(top, 0, "single badge: nothing should move to the top half, got {top}");
        assert!(bottom > 0, "single badge: badge should remain in the bottom half, got {bottom}");
    }

    /// Decode a rendered poster and return its (width, height).
    fn rendered_dims(bytes: &[u8]) -> (u32, u32) {
        let img = image::load_from_memory(bytes).unwrap();
        (img.width(), img.height())
    }

    fn render_with_fit(src: &[u8], target_width: u32, fit: PosterFit) -> Vec<u8> {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        render_poster_sync(
            src, &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal,
            LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal,
            target_width, 1.0, BadgeSize::Medium, false, fit,
        )
        .unwrap()
    }

    #[test]
    fn poster_fit_cover_normalizes_non_2_3_to_2_3() {
        // A square (1:1) source is the kind of art that downstream apps crop.
        let out = render_with_fit(&test_png(600, 600), 580, PosterFit::Cover);
        assert_eq!(rendered_dims(&out), (580, 870), "cover must produce an exact 2:3 frame");
    }

    #[test]
    fn poster_fit_pad_normalizes_non_2_3_to_2_3() {
        let out = render_with_fit(&test_png(900, 600), 580, PosterFit::Pad);
        assert_eq!(rendered_dims(&out), (580, 870), "pad must produce an exact 2:3 frame");
    }

    #[test]
    fn poster_fit_blur_normalizes_non_2_3_to_2_3() {
        let out = render_with_fit(&test_png(600, 600), 580, PosterFit::Blur);
        assert_eq!(rendered_dims(&out), (580, 870), "blur must produce an exact 2:3 frame");
    }

    #[test]
    fn poster_fit_native_preserves_source_ratio() {
        // Native keeps the legacy behavior: scale to width, keep the source ratio.
        let square = render_with_fit(&test_png(600, 600), 580, PosterFit::Native);
        assert_eq!(rendered_dims(&square), (580, 580), "native keeps a 1:1 source 1:1");
        let wide = render_with_fit(&test_png(900, 600), 580, PosterFit::Native);
        // round(600 * 580 / 900) = 387
        assert_eq!(rendered_dims(&wide), (580, 387), "native keeps a 3:2 source ratio");
    }

    #[test]
    fn poster_fit_already_2_3_unchanged_dims_across_modes() {
        for fit in [PosterFit::Native, PosterFit::Cover, PosterFit::Pad, PosterFit::Blur] {
            let out = render_with_fit(&test_png(500, 750), 580, fit);
            assert_eq!(rendered_dims(&out), (580, 870), "2:3 source stays 2:3 for {fit:?}");
        }
    }

    #[test]
    fn render_logo_at_large_target_width() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(200, 80);
        let result = render_logo_sync(&png, &[], &font, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), 1722, 2.2).unwrap();
        assert!(!result.is_empty());
        assert_eq!(&result[..4], &[0x89, b'P', b'N', b'G']);
    }

    #[test]
    fn render_backdrop_at_large_target_width() {
        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
        let png = test_png(640, 360);
        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 3840, 2.0, BadgeSize::Medium, 0, 0).unwrap();
        assert!(!result.is_empty());
        assert_eq!(result[0], 0xFF);
        assert_eq!(result[1], 0xD8);
    }
}