//!
//! A module containing Indexing utilities for 2D and 3D grids with static dimensions
//! The main purpose of this module is to provide a way to index into a 1D array as if it were a 2D or 3D array
//! And not using x, y, z coordinates, but a single index that is transformed.
//! This is useful for implementing cellular automata and other grid-based algorithms
//! The main advantage of this approach is that it is faster than using a 2D or 3D array
//! And it is more flexible than using a 1D array and manually calculating the index

#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct StaticIndex2<const X: usize, const Y: usize> {
    pub i: usize,
}

impl<const X: usize, const Y: usize> StaticIndex2<X, Y> {
    #[inline(always)]
    pub fn new(i: usize) -> Self {
        Self { i }
    }

    /// Returns a new StaticIndex2 from a ratio of the total number of indices
    #[inline(always)]
    pub fn from_ratio(f: f64) -> Self {
        Self::new((f * ((X * Y) as f64)) as usize)
    }

    /// Returns the x coordinate of the index transformed into the L * H 2D grid
    #[inline(always)]
    pub fn x(&self) -> usize {
        self.i % X
    }

    /// Returns the y coordinate of the index transformed into the L * H 2D grid
    #[inline(always)]
    pub fn y(&self) -> usize {
        self.i / X
    }
    #[inline(always)]
    pub fn is_x_max(&self) -> bool {
        self.x() == X - 1
    }

    #[inline(always)]
    pub fn is_x_min(&self) -> bool {
        self.x() == 0
    }

    #[inline(always)]
    pub fn is_y_max(&self) -> bool {
        self.i >= (Y - 1) * X
    }

    #[inline(always)]
    pub fn is_y_min(&self) -> bool {
        self.i < X
    }

    /// Warning: this can overflow the index if is already at the maximum
    fn add_x(&mut self) {
        self.i += 1;
    }

    /// Warning: this can underflow the index if is already at the minimum
    fn sub_x(&mut self) {
        self.i -= 1;
    }

    /// Warning: this can overflow the index if is already at the maximum
    fn add_y(&mut self) {
        self.i += X;
    }

    /// Warning: this can underflow the index if is already at the minimum
    fn sub_y(&mut self) {
        self.i -= X;
    }

    pub fn add_x_periodic(&mut self) {
        if self.is_x_max() {
            self.i += 1 - X
        } else {
            self.add_x()
        }
    }

    pub fn sub_x_periodic(&mut self) {
        if self.is_x_min() {
            self.i += X - 1
        } else {
            self.sub_x()
        }
    }

    pub fn add_y_periodic(&mut self) {
        if self.is_y_max() {
            self.i = self.x() // wraps to y = 0
        } else {
            self.add_y()
        }
    }

    pub fn sub_y_periodic(&mut self) {
        if self.is_y_min() {
            self.i += (Y - 1) * X // wraps to y = H - 1
        } else {
            self.sub_y()
        }
    }

    pub fn add_x_constrained(&mut self) {
        if !self.is_x_max() {
            self.add_x()
        }
    }

    pub fn sub_x_constrained(&mut self) {
        if !self.is_x_min() {
            self.sub_x()
        }
    }

    pub fn add_y_constrained(&mut self) {
        if !self.is_y_max() {
            self.add_y()
        }
    }

    pub fn sub_y_constrained(&mut self) {
        if !self.is_y_min() {
            self.sub_y()
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct StaticIndex3<const X: usize, const Y: usize, const Z: usize> {
    pub i: usize,
}

impl<const X: usize, const Y: usize, const Z: usize> StaticIndex3<X, Y, Z> {
    #[inline(always)]
    pub fn new(i: usize) -> Self {
        Self { i }
    }

    #[inline(always)]
    pub fn from_ratio(f: f64) -> Self {
        Self::new((f * ((X * Y * Z) as f64)) as usize)
    }

    #[inline(always)]
    pub fn x(&self) -> usize {
        self.i % X
    }

    #[inline(always)]
    pub fn y(&self) -> usize {
        (self.i / X) % Y
    }

    #[inline(always)]
    pub fn z(&self) -> usize {
        self.i / (X * Y * Z)
    }

    #[inline(always)]
    pub fn is_x_max(&self) -> bool {
        self.x() == X - 1
    }

    #[inline(always)]
    pub fn is_x_min(&self) -> bool {
        self.x() == 0
    }

    #[inline(always)]
    pub fn is_y_max(&self) -> bool {
        self.y() == Y - 1
    }

    #[inline(always)]
    pub fn is_y_min(&self) -> bool {
        self.y() == 0
    }

    #[inline(always)]
    pub fn is_z_max(&self) -> bool {
        self.z() == Z - 1
    }

    #[inline(always)]
    pub fn is_z_min(&self) -> bool {
        self.z() == 0
    }

    /// Warning: this can overflow the index if is already at the maximum
    pub fn add_x(&mut self) {
        self.i += 1;
    }

    /// Warning: this can underflow the index if is already at the minimum
    pub fn sub_x(&mut self) {
        self.i -= 1;
    }

    /// Warning: this can overflow the index if is already at the maximum
    pub fn add_y(&mut self) {
        self.i += X;
    }

    /// Warning: this can underflow the index if is already at the minimum
    pub fn sub_y(&mut self) {
        self.i -= X;
    }

    /// Warning: this can overflow the index if is already at the maximum
    pub fn add_z(&mut self) {
        self.i += X * Y;
    }

    /// Warning: this can underflow the index if is already at the minimum
    pub fn sub_z(&mut self) {
        self.i -= X * Y;
    }

    pub fn add_x_periodic(&mut self) {
        if self.is_x_max() {
            self.i += 1 - X
        } else {
            self.add_x()
        }
    }

    pub fn sub_x_periodic(&mut self) {
        if self.is_x_min() {
            self.i += X - 1
        } else {
            self.sub_x()
        }
    }

    pub fn add_y_periodic(&mut self) {
        if self.is_y_max() {
            self.i = self.x() + self.z() * X * Y
        } else {
            self.add_y()
        }
    }

    pub fn sub_y_periodic(&mut self) {
        if self.is_y_min() {
            self.i += (Y - 1) * X // wraps to y = H - 1
        } else {
            self.sub_y()
        }
    }

    pub fn add_z_periodic(&mut self) {
        if self.is_z_max() {
            self.i = self.x() + self.y() * X
        } else {
            self.add_z()
        }
    }

    pub fn sub_z_periodic(&mut self) {
        if self.is_z_min() {
            self.i += (Z - 1) * X * Y
        } else {
            self.sub_z()
        }
    }

    pub fn add_x_constrained(&mut self) {
        if !self.is_x_max() {
            self.add_x()
        }
    }

    pub fn sub_x_constrained(&mut self) {
        if !self.is_x_min() {
            self.sub_x()
        }
    }

    pub fn add_y_constrained(&mut self) {
        if !self.is_y_max() {
            self.add_y()
        }
    }

    pub fn sub_y_constrained(&mut self) {
        if !self.is_y_min() {
            self.sub_y()
        }
    }

    pub fn add_z_constrained(&mut self) {
        if !self.is_z_max() {
            self.add_z()
        }
    }

    pub fn sub_z_constrained(&mut self) {
        if !self.is_z_min() {
            self.sub_z()
        }
    }
}