use super::{CornerRadius, Element, Point};
use crate::{
    assets::asset_cache::{AssetCache, AssetSource, AssetState},
    event::DispatchedEvent,
    image_cache::{AnimatedImage, AnimatedImageBehavior, FitType, ImageCache, StaticImage},
    AfterLayoutContext, AppContext, EventContext, LayoutContext, PaintContext, SingletonEntity,
    SizeConstraint,
};

pub use crate::image_cache::CacheOption;
use instant::Instant;
use pathfinder_geometry::rect::RectF;
use pathfinder_geometry::vector::{vec2f, Vector2F, Vector2I};
use std::sync::Arc;
use std::time::Duration;

pub struct Image {
    source: AssetSource,
    opacity: f32,
    size: Option<Vector2F>,
    origin: Option<Point>,
    fit_type: FitType,
    animated_image_behavior: AnimatedImageBehavior,
    cache_option: CacheOption,
    started_at: Option<Instant>,
    corner_radius: CornerRadius,
    top_aligned: bool,
    right_aligned: bool,

    /// The "back up" element to render when an asset is not ready or encountered an error.
    /// This could be None in two situations: (1) the caller does not provide a before_load_element
    /// or (2) the caller provided one but it's no longer needed due to the image having loaded.
    before_load_element: Option<Box<dyn Element>>,

    /// To avoid duplicating delayed repaint, we store whether or not we've requested a
    /// repaint on behalf of this element.
    ///
    /// Note: we use this for asset loading but not for animation repaint. An animated image
    /// may request several repaints in its lifetime.
    requested_repaint_after_load: bool,
    #[cfg(debug_assertions)]
    /// Captures the location of the constructor call site. This is used for debugging purposes.
    constructor_location: Option<&'static std::panic::Location<'static>>,
}

impl Image {
    /// Creates an image element with an explicit [`CacheOption`].
    ///
    /// Use [`CacheOption::BySize`] for images rendered at a fixed size (icons, thumbnails);
    /// a CPU-resized copy is cached per size.
    /// Use [`CacheOption::Original`] for images whose display size changes continuously
    /// (e.g. background images); only the original asset is cached and the GPU scales it.
    #[cfg_attr(debug_assertions, track_caller)]
    pub fn new(source: AssetSource, cache_option: CacheOption) -> Self {
        Self {
            source,
            opacity: 1.,
            size: None,
            origin: None,
            fit_type: FitType::Contain,
            animated_image_behavior: AnimatedImageBehavior::default(),
            cache_option,
            started_at: None,
            corner_radius: CornerRadius::default(),
            top_aligned: false,
            right_aligned: false,
            before_load_element: None,
            requested_repaint_after_load: false,
            #[cfg(debug_assertions)]
            constructor_location: Some(std::panic::Location::caller()),
        }
    }

    pub fn with_corner_radius(mut self, radius: CornerRadius) -> Self {
        self.corner_radius = radius;
        self
    }

    pub fn with_opacity(mut self, opacity: f32) -> Self {
        self.opacity = opacity;
        self
    }

    pub fn cover(mut self) -> Self {
        self.fit_type = FitType::Cover;
        self
    }

    pub fn contain(mut self) -> Self {
        self.fit_type = FitType::Contain;
        self
    }

    /// Stretches the image to fill the element bounds without preserving the aspect ratio.
    pub fn stretch(mut self) -> Self {
        self.fit_type = FitType::Stretch;
        self
    }

    /// Renders animated image sources as a static preview of their first frame.
    pub fn first_frame_preview(mut self) -> Self {
        self.animated_image_behavior = AnimatedImageBehavior::FirstFramePreview;
        self
    }

    /// Aligns the image to the top of the element bounds instead of centering vertically.
    /// Useful for cover-fit images where the bottom should be clipped rather than
    /// cropping equally from top and bottom.
    pub fn top_aligned(mut self) -> Self {
        self.top_aligned = true;
        self
    }

    /// Aligns the image to the right of the element bounds and pins it to the top.
    /// Useful for contain-fit images where the image is narrower than the element
    /// and the empty space should appear on the left rather than being split on both sides.
    pub fn right_aligned(mut self) -> Self {
        self.right_aligned = true;
        self
    }

    /// Enables animated images for the current image element. The start time indicates
    /// the timestamp at which the animated image started rendering. The element uses
    /// this timestamp to calculate which frame of the animation to display at a given
    /// moment.
    /// Animations are still fairly experimental, so you should do extensive testing to
    /// make sure there's no performance degradation from using an animation.
    pub fn enable_animation_with_start_time(mut self, started_at: Instant) -> Self {
        self.started_at = Some(started_at);
        self
    }

    pub fn before_load(mut self, element: Box<dyn Element>) -> Self {
        self.before_load_element = Some(element);
        self
    }

    fn paint_static_image(
        &mut self,
        image: Arc<StaticImage>,
        size: Vector2F,
        origin: Vector2F,
        bounds: Vector2I,
        ctx: &mut PaintContext,
    ) {
        let desired_image_size = match self.cache_option {
            CacheOption::Original => {
                dimensions(image.size().to_f32(), bounds.to_f32(), self.fit_type)
            }
            _ => image.size().to_f32(),
        };
        let logical_image_size = desired_image_size / ctx.scene.scale_factor();
        let Some(rect) = image_rect(
            size,
            origin,
            logical_image_size,
            self.top_aligned,
            self.right_aligned,
        ) else {
            self.origin = None;
            log::error!(
                "invalid image rect before draw_image source={:?} element_size=({}, {}) image_size=({}, {}) desired_image_size=({}, {}) logical_image_size=({}, {}) origin=({}, {}) bounds=({}, {}) fit_type={:?} cache_option={:?}",
                self.source,
                size.x(),
                size.y(),
                image.width(),
                image.height(),
                desired_image_size.x(),
                desired_image_size.y(),
                logical_image_size.x(),
                logical_image_size.y(),
                origin.x(),
                origin.y(),
                bounds.x(),
                bounds.y(),
                self.fit_type,
                self.cache_option,
            );
            return;
        };

        self.origin = Some(Point::from_vec2f(rect.origin(), ctx.scene.z_index()));

        #[cfg(debug_assertions)]
        ctx.scene
            .set_location_for_panic_logging(self.constructor_location);

        ctx.scene
            .draw_image(rect, image, self.opacity, self.corner_radius);
    }

    fn paint_animated_image(
        &mut self,
        animated_image: Arc<AnimatedImage>,
        size: Vector2F,
        origin: Vector2F,
        bounds: Vector2I,
        ctx: &mut PaintContext,
    ) {
        // If self.started_at is not provided, we set it to current time
        // so only the first frame is shown.
        let started_at = self.started_at.unwrap_or_else(Instant::now);
        let elapsed_time = started_at.elapsed().as_millis();
        // After about ~50 days, casting `elapsed_time` to a u32 will
        // silently overflow. The gif may jump and start playing from a
        // different frame.
        match animated_image.get_current_frame(elapsed_time as u32) {
            Ok((frame, remaining_delay)) => {
                self.paint_static_image(frame.clone(), size, origin, bounds, ctx);
                // Only repaint if self.started_at is set. Otherwise
                // enable_animation_with_start_time has not been called
                // and we shouldn't animate.
                if self.started_at.is_some() {
                    ctx.repaint_after(Duration::from_millis(remaining_delay as u64));
                }
            }
            Err(e) => {
                log::error!("Unable to retrieve current frame from image: {e:?}");
            }
        }
    }
}

fn image_rect(
    size: Vector2F,
    origin: Vector2F,
    logical_image_size: Vector2F,
    top_aligned: bool,
    right_aligned: bool,
) -> Option<RectF> {
    let offset = if right_aligned {
        vec2f(size.x() - logical_image_size.x(), 0.0)
    } else if top_aligned {
        vec2f((size.x() - logical_image_size.x()) / 2.0, 0.0)
    } else {
        (size - logical_image_size) / 2.0
    };
    let origin = origin + offset;
    let rect = RectF::new(origin, logical_image_size);
    if rect.origin().x().is_finite()
        && rect.origin().y().is_finite()
        && rect.size().x().is_finite()
        && rect.size().y().is_finite()
    {
        Some(rect)
    } else {
        None
    }
}

/// Returns desired dimensions of the image given the original size (x, y), desired container size
/// (dest_x, dest_y) and fit_type.
/// Returns a vector with new dimensions maintaining the original aspect ratio,
/// unless the FitType is `Stretch`.
fn dimensions(original: Vector2F, dest: Vector2F, fit_type: FitType) -> Vector2F {
    let ratio_x = dest.x() / original.x();
    let ratio_y = dest.y() / original.y();

    let ratio = match fit_type {
        FitType::Contain => ratio_x.min(ratio_y),
        FitType::Cover => ratio_x.max(ratio_y),
        FitType::Stretch => {
            // Stretch doesn't maintain aspect ratio
            return dest;
        }
    };

    let x = original.x() * ratio;
    let y = original.y() * ratio;

    vec2f(x.max(1.), y.max(1.)).round()
}

impl Element for Image {
    fn layout(
        &mut self,
        constraint: SizeConstraint,
        ctx: &mut LayoutContext,
        app: &AppContext,
    ) -> Vector2F {
        let size = constraint.max;
        self.size = Some(size);

        if let Some(before_load_element) = self.before_load_element.as_mut() {
            before_load_element.layout(constraint, ctx, app);
        }

        size
    }

    fn after_layout(&mut self, ctx: &mut AfterLayoutContext, app: &AppContext) {
        if let Some(before_load_element) = self.before_load_element.as_mut() {
            before_load_element.after_layout(ctx, app);
        }
    }

    fn paint(&mut self, origin: Vector2F, ctx: &mut PaintContext, app: &AppContext) {
        let Some(size) = self.size else {
            return;
        };

        let bounds = (size * ctx.scene.scale_factor()).to_i32();
        if !size.x().is_finite()
            || !size.y().is_finite()
            || size.x() <= 0.0
            || size.y() <= 0.0
            || bounds.x() <= 0
            || bounds.y() <= 0
        {
            log::warn!(
                "image paint with suspicious size source={:?} element_size=({}, {}) bounds=({}, {}) fit_type={:?} cache_option={:?}",
                self.source,
                size.x(),
                size.y(),
                bounds.x(),
                bounds.y(),
                self.fit_type,
                self.cache_option,
            );
        }
        let assert_cache = AssetCache::as_ref(app);
        let image = ImageCache::as_ref(app).image(
            self.source.clone(),
            bounds,
            self.fit_type,
            self.animated_image_behavior,
            self.cache_option,
            ctx.max_texture_dimension_2d,
            assert_cache,
        );

        match image {
            AssetState::Loading { handle } => {
                if !self.requested_repaint_after_load {
                    ctx.repaint_after_load(handle);
                    self.requested_repaint_after_load = true;
                }

                if let Some(before_load_element) = self.before_load_element.as_mut() {
                    before_load_element.paint(origin, ctx, app);
                }
            }
            AssetState::Evicted => {
                if let Some(before_load_element) = self.before_load_element.as_mut() {
                    before_load_element.paint(origin, ctx, app);
                }
            }
            AssetState::FailedToLoad(_) => {
                if let Some(before_load_element) = self.before_load_element.as_mut() {
                    before_load_element.paint(origin, ctx, app);
                }
            }
            AssetState::Loaded { data } => {
                // Don't waste time calling layout() and after_layout() on the backup element once the main
                // one has loaded.
                self.before_load_element = None;

                match data.as_ref() {
                    crate::image_cache::Image::Static(static_image) => {
                        self.paint_static_image(static_image.clone(), size, origin, bounds, ctx)
                    }
                    crate::image_cache::Image::Animated(animated_image) => {
                        self.paint_animated_image(animated_image.clone(), size, origin, bounds, ctx)
                    }
                }
            }
        }
    }

    fn size(&self) -> Option<Vector2F> {
        self.size
    }

    fn dispatch_event(
        &mut self,
        _: &DispatchedEvent,
        _: &mut EventContext,
        _: &AppContext,
    ) -> bool {
        false
    }

    fn origin(&self) -> Option<Point> {
        self.origin
    }
}

#[cfg(test)]
#[path = "image_tests.rs"]
mod tests;