use super::errors::GridError;
use crate::prelude::*;

#[derive(Component)]
pub struct Tile {
    pub x: u32,
    pub y: u32,
}

#[derive(Component)]
pub struct CropVisual;

#[derive(Component, Default, Serialize, Deserialize, Clone, Debug)]
pub enum TileState {
    #[default]
    Unclaimed,
    Empty,
    Occupied {
        seed: ItemType,
    },
}

impl TileState {
    pub fn is_blocking(&self) -> bool {
        match self {
            TileState::Occupied { .. } => true,
            _ => false,
        }
    }
}

#[derive(Resource)]
pub struct Grid {
    pub width: u32,
    pub height: u32,
    pub tiles: Vec<Vec<Entity>>,
}

impl Grid {
    pub fn get_tile(&self, pos: (u32, u32)) -> Result<Entity, GridError> {
        if pos.0 >= self.width || pos.1 >= self.height {
            return Err(GridError::OutOfBounds {
                x: pos.0 as i32,
                y: pos.1 as i32,
            });
        }
        Ok(self.tiles[pos.0 as usize][pos.1 as usize])
    }

    pub fn map_tile_state<F>(
        &self,
        pos: (u32, u32),
        mapper: F,
        mut tile_query: Query<&mut TileState>,
    ) -> Result<(), GridError>
    where
        F: FnOnce(&TileState) -> TileState,
    {
        let tile_entity = self.get_tile(pos)?;

        let mut tile_state = tile_query
            .get_mut(tile_entity)
            .map_err(|_| GridError::UnknownError)?;

        *tile_state = mapper(&*tile_state);
        Ok(())
    }
}