use bevy::prelude::*;

#[derive(Component, Debug, Clone, PartialEq, Eq, Hash)]
pub enum Material {
    NA,
    Wood(WoodType),
    Stone(StoneType),
    Metal(MetalType),
    Cloth(ClothType),
    Leather(LeatherType),
    Bone,
    Shell,
    Glass,
    Ceramic,
    Gem(GemType),
    Wax,
}

impl Material {
    // Weight per unit volume (arbitrary units - TODO: Adjust later)
    pub fn density(&self) -> f32 {
        match self {
            Material::NA => 1.0,
            Material::Wood(wood) => match wood {
                WoodType::Oak => 0.7,
                WoodType::Pine => 0.5,
                WoodType::Birch => 0.6,
                WoodType::Ironwood => 1.2,
            },
            Material::Stone(stone) => match stone {
                StoneType::Granite => 2.7,
                StoneType::Marble => 2.6,
                StoneType::Sandstone => 2.2,
                StoneType::Obsidian => 2.4,
            },
            Material::Metal(metal) => match metal {
                MetalType::Iron => 7.9,
                MetalType::Steel => 7.8,
                MetalType::Copper => 8.9,
                MetalType::Silver => 10.5,
                MetalType::Gold => 19.3,
                MetalType::Platinum => 21.5,
            },
            Material::Cloth(_) => 0.3,
            Material::Leather(_) => 0.8,
            Material::Bone => 1.8,
            Material::Shell => 2.0,
            Material::Glass => 2.5,
            Material::Ceramic => 2.3,
            Material::Gem(gem) => match gem {
                GemType::Diamond => 3.5,
                GemType::Ruby => 4.0,
                GemType::Emerald => 2.7,
                GemType::Sapphire => 4.0,
            },
            Material::Wax => 0.1,
        }
    }

    // Base value per unit (before quality modifiers)
    pub fn base_value(&self) -> u32 {
        match self {
            Material::NA => 1,
            Material::Wood(_) => 1,
            Material::Stone(_) => 2,
            Material::Metal(metal) => match metal {
                MetalType::Iron => 5,
                MetalType::Steel => 8,
                MetalType::Copper => 3,
                MetalType::Silver => 15,
                MetalType::Gold => 30,
                MetalType::Platinum => 40,
            },
            Material::Cloth(_) => 2,
            Material::Leather(_) => 3,
            Material::Bone => 1,
            Material::Shell => 2,
            Material::Glass => 4,
            Material::Ceramic => 3,
            Material::Gem(gem) => match gem {
                GemType::Diamond => 200,
                GemType::Ruby => 150,
                GemType::Emerald => 100,
                GemType::Sapphire => 120,
            },
            Material::Wax => 3,
        }
    }

    pub fn name(&self) -> String {
        match self {
            Material::NA => "N/A".to_string(),
            Material::Wood(wood) => format!("{:?}", wood).to_lowercase(),
            Material::Stone(stone) => format!("{:?}", stone).to_lowercase(),
            Material::Metal(metal) => format!("{:?}", metal).to_lowercase(),
            Material::Cloth(cloth) => format!("{:?}", cloth).to_lowercase(),
            Material::Leather(leather) => {
                format!("{} leather", format!("{:?}", leather).to_lowercase())
            }
            Material::Bone => "bone".to_string(),
            Material::Shell => "shell".to_string(),
            Material::Glass => "glass".to_string(),
            Material::Ceramic => "ceramic".to_string(),
            Material::Gem(gem) => format!("{:?}", gem).to_lowercase(),
            Material::Wax => "wax".to_string(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum WoodType {
    Oak,
    Pine,
    Birch,
    Ironwood,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum StoneType {
    Granite,
    Marble,
    Sandstone,
    Obsidian,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum MetalType {
    Iron,
    Steel,
    Copper,
    Silver,
    Gold,
    Platinum,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ClothType {
    Cotton,
    Silk,
    Wool,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum LeatherType {
    Cow,
    Pig,
    Dragon,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GemType {
    Diamond,
    Ruby,
    Emerald,
    Sapphire,
}