use std::{marker::PhantomData, num::NonZeroU32};

use crate::Image;

/// A smaller part of a larger image.
///
/// ```text
/// ┏━━━━━━━━━━━━━━┓ hard borders represent the full image
/// ┃ 1   2  3   1 ┃                 vvvv the top left of the new image
/// ┃   ┌──────┐   ┃ crop(2, 2).from(1, 1)
/// ┃ 4 │ 5  6 │ 2 ┃      ^^^^ width and height
/// ┃   │      │   ┃
/// ┃ 7 │ 8  9 │ 3 ┃
/// ┗━━━┷━━━━━━┷━━━┛ soft borders represent the new image
/// ```
#[derive(Clone)]
pub struct SubImage<T, const CHANNELS: usize> {
    inner: Image<T, CHANNELS>,
    /// in pixels
    offset_x: u32,
    real_width: NonZeroU32,
    real_height: NonZeroU32,
}

/// Trait for cropping a image.
pub trait Cropper<T, const C: usize> {
    /// # Panics
    ///
    /// if w - y == 0
    fn from(self, x: u32, y: u32) -> SubImage<T, C>;
}

impl<T: Clone, const N: usize> Copy for SubImage<T, N> where Image<T, N>: Copy {}

macro_rules! def {
    ($t:ty, $($what:ident)?) => {
        struct Crop<'a, T, const C: usize> {
            dimensions: (NonZeroU32, NonZeroU32),
            _d: PhantomData<SubImage<$t, C>>,
            image: Image<$t, C>,
        }

        impl<'a, T, const C: usize> Cropper<$t, C> for Crop<'a, T, C> {
            fn from(self, x: u32, y: u32) -> SubImage<$t, C> {
                let w = self.image.width();
                // SAFETY: ctor
                let i = unsafe {
                    Image::new(
                        self.image.width,
                        NonZeroU32::new(self.image.height() - y).unwrap(),
                        &$($what)?(self.image.take_buffer()[(y as usize * C) * w as usize..]),
                    )
                };
                SubImage {
                    offset_x: x,
                    inner: i,
                    real_width: self.dimensions.0,
                    real_height: self.dimensions.1,
                }
            }
        }
    };
}

impl<T, const C: usize> Image<T, C> {
    /// Crop a image.
    ///
    /// The signature looks something like: `i.crop(width, height).from(top_left_x, top_left_y)`, which gives you a <code>[SubImage]<&\[T\], _></code>
    ///
    /// If you want a owned image, `i.crop(w, h).from(x, y).own()` gets you a <code>[`Image`]<[Box]<\[T\], _>></code> back.
    ///
    /// ```
    /// # use fimg::{Image, Cropper};
    /// let mut i = Image::<_, 1>::build(4, 3).buf([
    ///    1, 2, 3, 1,
    ///    4, 5, 6, 2,
    ///    7, 8, 9, 3,
    /// ]);
    /// let c = i.crop(2, 2).from(1, 1);
    /// # unsafe {
    /// assert_eq!(c.pixel(0, 0), [5]);
    /// assert_eq!(c.pixel(1, 1), [9]);
    /// assert_eq!(
    ///   c.own().bytes(),
    ///   &[5, 6,
    ///     8, 9]
    /// );
    /// # }
    /// ```
    ///
    /// # Panics
    ///
    /// if width == 0 || height == 0
    pub fn crop<'a, U: 'a>(&'a self, width: u32, height: u32) -> impl Cropper<&'a [U], C>
    where
        T: AsRef<[U]>,
    {
        def!(&'a [T],);
        Crop {
            dimensions: (
                NonZeroU32::new(width).expect("Image::crop panics when width == 0"),
                NonZeroU32::new(height).expect("Image::crop panics when height == 0"),
            ),
            _d: PhantomData,
            image: self.as_ref(),
        }
    }

    /// Like [`Image::crop`], but returns a mutable [`SubImage`].
    pub fn crop_mut<'a, U: 'a>(
        &'a mut self,
        width: u32,
        height: u32,
    ) -> impl Cropper<&'a mut [U], C>
    where
        T: AsMut<[U]> + AsRef<[U]>,
    {
        def!(&'a mut [T], mut);
        Crop {
            dimensions: (
                NonZeroU32::new(width).expect("Image::crop panics when width == 0"),
                NonZeroU32::new(height).expect("Image::crop panics when height == 0"),
            ),
            _d: PhantomData,
            image: self.as_mut(),
        }
    }
}

impl<T: Clone, const C: usize> SubImage<&[T], C> {
    /// Clones this [`SubImage`] into its own [`Image`]
    pub fn own(&self) -> Image<Box<[T]>, C> {
        let mut out =
            Vec::with_capacity(self.real_width.get() as usize * self.inner.height() as usize * C);
        for row in self
            .inner
            .buffer
            .chunks_exact(self.inner.width.get() as usize)
            .take(self.real_height.get() as usize)
        {
            out.extend_from_slice(
                &row[self.offset_x as usize
                    ..self.offset_x as usize + self.real_width.get() as usize],
            );
        }
        // SAFETY: ctor
        unsafe { Image::new(self.real_width, self.real_height, out.into()) }
    }
}

// TODO crop()
impl<W, const C: usize> SubImage<W, C> {
    /// Get a pixel.
    ///
    /// # Safety
    ///
    /// this pixel must be in bounds.
    pub unsafe fn pixel<U: Copy>(&self, x: u32, y: u32) -> [U; C]
    where
        W: AsRef<[U]>,
    {
        // note: if you get a pixel, in release mode, that is in bounds of the outer image, but not the sub image, that would be library-ub.
        debug_assert!(x < self.real_width.get());
        debug_assert!(y < self.real_height.get());
        // SAFETY: caller
        unsafe { self.inner.pixel(x + self.offset_x, y) }
    }

    /// Get a pixel, mutably.
    ///
    /// # Safety
    ///
    /// this pixel must be in bounds.
    pub unsafe fn pixel_mut<U: Copy>(&mut self, x: u32, y: u32) -> &mut [U]
    where
        W: AsMut<[U]> + AsRef<[U]>,
    {
        debug_assert!(x < self.real_width.get());
        debug_assert!(y < self.real_height.get());
        // SAFETY: caller
        unsafe { self.inner.pixel_mut(x, y) }
    }
}