use std::ops;

use bevy::{
    ecs::component::Component,
    math::{IVec3, UVec3},
};
use overload::overload;

use super::{BlockRegion, ChunkPos, CHUNK_MAX};

#[derive(Component, Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct ChunkRegion {
    min: ChunkPos,
    max: ChunkPos,
}

impl ChunkRegion {
    pub fn new_unchecked(min: ChunkPos, max: ChunkPos) -> Self {
        Self { min, max }
    }

    pub fn new_checked(min: ChunkPos, max: ChunkPos) -> Result<Self, ()> {
        if min.x <= max.x && min.y <= max.y && min.z <= max.z {
            Ok(Self::new_unchecked(min, max))
        } else {
            Err(())
        }
    }

    pub fn new(a: ChunkPos, b: ChunkPos) -> Self {
        let min = ChunkPos::new(a.x.min(b.x), a.y.min(b.y), a.z.min(b.z));
        let max = ChunkPos::new(a.x.max(b.x), a.y.max(b.y), a.z.max(b.z));
        Self::new_unchecked(min, max)
    }

    pub fn size(&self) -> UVec3 {
        (self.max - self.min + IVec3::ONE).as_uvec3()
    }

    pub fn contains(&self, pos: ChunkPos) -> bool {
        (pos.x >= self.min.x && pos.x <= self.max.x)
            && (pos.y >= self.min.y && pos.y <= self.max.y)
            && (pos.z >= self.min.z && pos.z <= self.max.z)
    }

    pub fn intersects(&self, other: Self) -> bool {
        (other.max.x > self.min.x && other.min.x < self.max.x)
            && (other.max.y > self.min.y && other.min.y < self.max.y)
            && (other.max.z > self.min.z && other.min.z < self.max.z)
    }

    pub fn distance_to(&self, pos: ChunkPos) -> f32 {
        (self.distance_to_squared(pos) as f32).sqrt()
    }

    pub fn distance_to_squared(&self, pos: ChunkPos) -> i32 {
        let clamped = pos.max(self.min).min(self.max);
        pos.distance_to_squared(clamped)
    }

    pub fn offset(&self, x: i32, y: i32, z: i32) -> Self {
        Self {
            min: self.min.offset(x, y, z),
            max: self.max.offset(x, y, z),
        }
    }

    pub fn expand(&self, amount: i32) -> Result<Self, ()> {
        Self::new_checked(
            self.min - IVec3::splat(amount),
            self.max + IVec3::splat(amount),
        )
    }

    pub fn to_block_region(&self) -> BlockRegion {
        BlockRegion::new_unchecked(
            self.min.to_block_pos(IVec3::ZERO),
            self.min.to_block_pos(CHUNK_MAX),
        )
    }
}

impl std::fmt::Display for ChunkRegion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} to {}", self.min, self.max)
    }
}

// Offsetting

overload!((l: ?ChunkRegion) + (r: IVec3) -> ChunkRegion { ChunkRegion::new_unchecked(l.min + r, l.max + r) });
overload!((l: ?ChunkRegion) - (r: IVec3) -> ChunkRegion { ChunkRegion::new_unchecked(l.min - r, l.max - r) });
overload!((s: &mut ChunkRegion) += (v: IVec3) { s.min += v; s.max += v; });
overload!((s: &mut ChunkRegion) -= (v: IVec3) { s.min -= v; s.max -= v; });

// Conversion

impl From<ChunkRegion> for (ChunkPos, ChunkPos) {
    fn from(ChunkRegion { min, max }: ChunkRegion) -> Self {
        (min, max)
    }
}