use integral_geometry::{Rect, Size};

use itertools::Itertools;

use std::{

    cmp::{max, min, Ordering},

    ops::Index,

};

#[derive(PartialEq, Eq, PartialOrd, Ord, Clone)]

struct Fit {

    short_side: u32,

    long_side: u32,

}

impl Fit {

    fn new() -> Self {

        Self {

            short_side: u32::max_value(),

            long_side: u32::max_value(),

        }

    }

    fn measure(container: Size, size: Size) -> Option<Self> {

        if container.contains(size) {

            let x_leftover = container.width - size.width;

            let y_leftover = container.height - size.height;

            Some(Self {

                short_side: min(x_leftover, y_leftover) as u32,

                long_side: max(x_leftover, y_leftover) as u32,

            })

        } else {

            None

        }

    }

}

#[derive(PartialEq, Eq)]

pub struct UsedSpace {

    used_area: usize,

    total_area: usize,

}

impl UsedSpace {

    const fn new(used_area: usize, total_area: usize) -> Self {

        Self {

            used_area,

            total_area,

        }

    }

    const fn used(&self) -> usize {

        self.used_area

    }

    const fn total(&self) -> usize {

        self.total_area

    }

    const fn free(&self) -> usize {

        self.total_area - self.used_area

    }

}

impl std::fmt::Debug for UsedSpace {

    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {

        write!(

            f,

            "{:.2}%",

            self.used() as f32 / self.total() as f32 * 100.0

        )?;

        Ok(())

    }

}

pub struct Atlas<T> {

    size: Size,

    free_rects: Vec<Rect>,

    used_rects: Vec<(Rect, T)>,

    splits: Vec<Rect>,

}

impl<T: Copy> Atlas<T> {

    pub fn new(size: Size) -> Self {

        Self {

            size,

            free_rects: vec![Rect::at_origin(size)],

            used_rects: vec![],

            splits: vec![],

        }

    }

    pub fn size(&self) -> Size {

        self.size

    }

    pub fn used_space(&self) -> UsedSpace {

        let used = self.used_rects.iter().map(|(r, _)| r.size().area()).sum();

        UsedSpace::new(used, self.size.area())

    }

    fn find_position(&self, size: Size) -> Option<(Rect, Fit)> {

        let mut best_rect = Rect::EMPTY;

        let mut best_fit = Fit::new();

        for rect in &self.free_rects {

            if let Some(fit) = Fit::measure(rect.size(), size) {

                if fit < best_fit {

                    best_fit = fit;

                    best_rect = Rect::from_size(rect.top_left(), size);

                }

            }

            if let Some(fit) = Fit::measure(rect.size(), size.transpose()) {

                if fit < best_fit {

                    best_fit = fit;

                    best_rect = Rect::from_size(rect.top_left(), size.transpose());

                }

            }

        }

        if best_rect == Rect::EMPTY {

            None

        } else {

            Some((best_rect, best_fit))

        }

    }

    fn split_insert(&mut self, rect: Rect, value: T) {

        let mut splits = std::mem::replace(&mut self.splits, vec![]);

        let mut buffer = [Rect::EMPTY; 4];

        for i in (0..self.free_rects.len()).rev() {

            if let Some(count) = split_rect(self.free_rects[i], rect, &mut splits, &mut buffer) {

                self.free_rects.swap_remove(i as usize);

                splits.extend_from_slice(&buffer[0..count]);

            }

        }

        filter_swap_remove(&mut splits, |s| {

            self.free_rects.iter().any(|r| r.contains_rect(s))

        });

        self.free_rects.extend(splits.drain(..));

        std::mem::replace(&mut self.splits, splits);

        self.used_rects.push((rect, value));

    }

    pub fn insert(&mut self, size: Size, value: T) -> Option<Rect> {

        let (rect, _) = self.find_position(size)?;

        self.split_insert(rect, value);

        Some(rect)

    }

    pub fn insert_set<Iter>(&mut self, sizes: Iter) -> Vec<(Rect, T)>

    where

        Iter: Iterator<Item = (Size, T)>,

    {

        let mut sizes: Vec<_> = sizes.collect();

        let mut result = Vec::with_capacity(sizes.len());

        while let Some((index, (rect, _), value)) = sizes

            .iter()

            .enumerate()

            .filter_map(|(i, (s, v))| self.find_position(*s).map(|res| (i, res, v)))

            .min_by_key(|(_, (_, fit), _)| fit.clone())

        {

            self.split_insert(rect, *value);

            result.push((rect, *value));

            sizes.swap_remove(index);

        }

        result

    }

    pub fn reset(&mut self) {

        self.free_rects.clear();

        self.used_rects.clear();

        self.free_rects.push(Rect::at_origin(self.size));

    }

}

pub type SpriteIndex = u32;

pub type SpriteLocation = (u32, Rect);

pub struct AtlasCollection {

    next_index: SpriteIndex,

    texture_size: Size,

    atlases: Vec<Atlas<SpriteIndex>>,

    rects: Vec<SpriteLocation>,

}

impl AtlasCollection {

    pub fn new(texture_size: Size) -> Self {

        Self {

            next_index: 0,

            texture_size,

            atlases: vec![],

            rects: vec![],

        }

    }

    fn repack(&mut self, size: Size) -> bool {

        for (atlas_index, atlas) in self.atlases.iter_mut().enumerate() {

            if atlas.used_space().free() >= size.area() {

                let mut temp_atlas = Atlas::new(atlas.size());

                let sizes = atlas

                    .used_rects

                    .iter()

                    .map(|(r, v)| (r.size(), *v))

                    .chain(std::iter::once((size, self.next_index)));

                let inserts = temp_atlas.insert_set(sizes);

                if inserts.len() > atlas.used_rects.len() {

                    self.rects.push((0, Rect::EMPTY));

                    for (rect, index) in inserts {

                        self.rects[index as usize] = (atlas_index as u32, rect);

                    }

                    std::mem::swap(atlas, &mut temp_atlas);

                    return true;

                }

            }

        }

        false

    }

    #[inline]

    fn consume_index(&mut self) -> Option<SpriteIndex> {

        let result = Some(self.next_index);

        self.next_index += 1;

        result

    }

    pub fn insert_sprite(&mut self, size: Size) -> Option<SpriteIndex> {

        if !self.texture_size.contains(size) {

            None

        } else {

            let index = self.next_index;

            if let Some(index_rect) = self

                .atlases

                .iter_mut()

                .enumerate()

                .find_map(|(i, a)| a.insert(size, index).map(|r| (i as u32, r)))

            {

                self.rects.push(index_rect);

            } else if !self.repack(size) {

                let mut atlas = Atlas::new(self.texture_size);

                let rect = atlas.insert(size, index)?;

                self.atlases.push(atlas);

                self.rects.push(((self.atlases.len() - 1) as u32, rect))

            }

            self.consume_index()

        }

    }

    pub fn get_rect(&self, index: SpriteIndex) -> Option<(u32, Rect)> {

        self.rects.get(index as usize).cloned()

    }

    pub fn used_space(&self) -> String {

        self.atlases

            .iter()

            .enumerate()

            .map(|(i, a)| format!("{}: {:?}", i, a.used_space()))

            .join("\n")

    }

}

impl Index<SpriteIndex> for AtlasCollection {

    type Output = SpriteLocation;

    #[inline]

    fn index(&self, index: SpriteIndex) -> &Self::Output {

        &self.rects[index as usize]

    }

}

#[inline]

fn filter_swap_remove<T, F>(vec: &mut Vec<T>, predicate: F)

where

    F: Fn(&T) -> bool,

{

    let mut i = 0;

    while i < vec.len() {

        if predicate(&vec[i]) {

            vec.swap_remove(i);

        } else {

            i += 1;

        }

    }

}

#[inline]

fn prune_push(

    previous_splits: &mut Vec<Rect>,

    buffer: &mut [Rect; 4],

    buffer_size: &mut usize,

    rect: Rect,

) {

    if !previous_splits.iter().any(|r| r.contains_rect(&rect)) {

        filter_swap_remove(previous_splits, |s| rect.contains_rect(s));

        buffer[*buffer_size] = rect;

        *buffer_size += 1;

    }

}

fn split_rect(

    free_rect: Rect,

    rect: Rect,

    previous_splits: &mut Vec<Rect>,

    buffer: &mut [Rect; 4],

) -> Option<usize> {

    let mut buffer_size = 0usize;

    let split = free_rect.intersects(&rect);

    if split {

        if rect.left() > free_rect.left() {

            let trim = free_rect.right() - rect.left() + 1;

            prune_push(

                previous_splits,

                buffer,

                &mut buffer_size,

                free_rect.with_margins(0, -trim, 0, 0),

            );

        }

        if rect.right() < free_rect.right() {

            let trim = rect.right() - free_rect.left() + 1;

            prune_push(

                previous_splits,

                buffer,

                &mut buffer_size,

                free_rect.with_margins(-trim, 0, 0, 0),

            );

        }

        if rect.top() > free_rect.top() {

            let trim = free_rect.bottom() - rect.top() + 1;

            prune_push(

                previous_splits,

                buffer,

                &mut buffer_size,

                free_rect.with_margins(0, 0, 0, -trim),

            );

        }

        if rect.bottom() < free_rect.bottom() {

            let trim = rect.bottom() - free_rect.top() + 1;

            prune_push(

                previous_splits,

                buffer,

                &mut buffer_size,

                free_rect.with_margins(0, 0, -trim, 0),

            );

        }

    }

    if split {

        Some(buffer_size)

    } else {

        None

    }

}

#[cfg(test)]

mod tests {

    use super::Atlas;

    use integral_geometry::{Rect, Size};

    use itertools::Itertools as _;

    use proptest::prelude::*;

    #[test]

    fn insert() {

        let atlas_size = Size::square(16);

        let mut atlas = Atlas::new(atlas_size);

        assert_eq!(None, atlas.insert(Size::square(20), ()));

        let rect_size = Size::new(11, 3);

        let rect = atlas.insert(rect_size, ()).unwrap();

        assert_eq!(rect, Rect::at_origin(rect_size));

        assert_eq!(2, atlas.free_rects.len());

    }

    #[derive(Debug, Clone)]

    struct TestRect(Size);

    struct TestRectParameters(Size);

    impl Default for TestRectParameters {

        fn default() -> Self {

            Self(Size::square(64))

        }

    }

    impl Arbitrary for TestRect {

        type Parameters = TestRectParameters;

        fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {

            (1..=args.0.width, 1..=args.0.height)

                .prop_map(|(w, h)| TestRect(Size::new(w, h)))

                .boxed()

        }

        type Strategy = BoxedStrategy<TestRect>;

    }

    trait HasSize {

        fn size(&self) -> Size;

    }

    impl HasSize for TestRect {

        fn size(&self) -> Size {

            self.0

        }

    }

    impl HasSize for Rect {

        fn size(&self) -> Size {

            self.size()

        }

    }

    impl HasSize for (Rect, ()) {

        fn size(&self) -> Size {

            self.0.size()

        }

    }

    fn sum_area<S: HasSize>(items: &[S]) -> usize {

        items.iter().map(|s| s.size().area()).sum()

    }

    proptest! {

        #[test]

        fn prop_insert(rects in Vec::<TestRect>::arbitrary()) {

            let container = Rect::at_origin(Size::square(2048));

            let mut atlas = Atlas::new(container.size());

            let inserted: Vec<_> = rects.iter().filter_map(|TestRect(size)| atlas.insert(*size, ())).collect();

            let mut inserted_pairs = inserted.iter().cartesian_product(inserted.iter());

            assert!(inserted.iter().all(|r| container.contains_rect(r)));

            assert!(inserted_pairs.all(|(r1, r2)| r1 == r2 || r1 != r2 && !r1.intersects(r2)));

            assert_eq!(inserted.len(), rects.len());

            assert_eq!(sum_area(&inserted), sum_area(&rects));

        }

    }

    proptest! {

        #[test]

        fn prop_insert_set(rects in Vec::<TestRect>::arbitrary()) {

            let container = Rect::at_origin(Size::square(2048));

            let mut atlas = Atlas::new(container.size());

            let mut set_atlas = Atlas::new(container.size());

            let inserted: Vec<_> = rects.iter().filter_map(|TestRect(size)| atlas.insert(*size, ())).collect();

            let set_inserted: Vec<_> = set_atlas.insert_set(rects.iter().map(|TestRect(size)| (*size, ())));

            let mut set_inserted_pairs = set_inserted.iter().cartesian_product(set_inserted.iter());

            assert!(set_inserted_pairs.all(|((r1, _), (r2, _))| r1 == r2 || r1 != r2 && !r1.intersects(r2)));

            assert!(set_atlas.used_space().used() <= atlas.used_space().used());

            assert_eq!(sum_area(&set_inserted), sum_area(&inserted));

        }

    }

}