jelq

use super::{Item, Lube, balance::STARTING_ICE_PACKS};

#[derive(Default)]

pub struct Items {

    pub(crate) kit: Kit,

    pub(crate) stores: Stores,

    pub(crate) lubes: LubeStock,

}

#[derive(Default)]

pub struct Kit {

    pub(crate) ruler: bool,

    pub(crate) dnd_sign: bool,

    pub(crate) blinds: bool,

    pub(crate) pump_pro: bool,

    pub(crate) extender: bool,

    pub(crate) ring: bool,

    pub(crate) cage: bool,

    pub(crate) spreadsheet: bool,

    pub(crate) teapot_spout: bool,

}

pub struct Stores {

    pub(crate) ice_packs: u32,

    pub(crate) door_locks: u32,

    pub(crate) supplements: u32,

    pub(crate) energy_drinks: u32,

}

impl Default for Stores {

    fn default() -> Self {

        Self {

            ice_packs: STARTING_ICE_PACKS,

            door_locks: 0,

            supplements: 0,

            energy_drinks: 0,

        }

    }

}

pub struct LubeStock {

    pub(crate) baby_oil: u32,

    pub(crate) coconut_oil: u32,

    pub(crate) lotion: u32,

    pub(crate) vaseline: u32,

}

impl Default for LubeStock {

    fn default() -> Self {

        Self {

            baby_oil: 1,

            coconut_oil: 0,

            lotion: 1,

            vaseline: 0,

        }

    }

}

impl LubeStock {

    /// Spit is the only lubricant that never runs out, so it has no count.

    fn bottle(&mut self, lube: Lube) -> Option<&mut u32> {

        match lube {

            Lube::Spit => None,

            Lube::BabyOil => Some(&mut self.baby_oil),

            Lube::CoconutOil => Some(&mut self.coconut_oil),

            Lube::Lotion => Some(&mut self.lotion),

            Lube::Vaseline => Some(&mut self.vaseline),

        }

    }

    pub fn has(&self, lube: Lube) -> bool {

        match lube {

            Lube::Spit => true,

            Lube::BabyOil => self.baby_oil > 0,

            Lube::CoconutOil => self.coconut_oil > 0,

            Lube::Lotion => self.lotion > 0,

            Lube::Vaseline => self.vaseline > 0,

        }

    }

    pub fn take(&mut self, lube: Lube) {

        if let Some(bottle) = self.bottle(lube) {

            *bottle = bottle.saturating_sub(1);

        }

    }

    fn add(&mut self, lube: Lube) {

        if let Some(bottle) = self.bottle(lube) {

            *bottle += 1;

        }

    }

}

impl Items {

    pub fn has(&self, item: Item) -> bool {

        match item {

            Item::WarmTowel => true,

            Item::IcePack => self.stores.ice_packs > 0,

            Item::Ruler => self.kit.ruler,

            Item::DoorLock => self.stores.door_locks > 0,

            Item::DndSign => self.kit.dnd_sign,

            Item::Blinds => self.kit.blinds,

            Item::PumpPro => self.kit.pump_pro,

            Item::Extender => self.kit.extender,

            Item::Ring => self.kit.ring,

            Item::Supplement => self.stores.supplements > 0,

            Item::Cage => self.kit.cage,

            Item::Spreadsheet => self.kit.spreadsheet,

            Item::TeapotSpout => self.kit.teapot_spout,

            Item::EnergyDrink => self.stores.energy_drinks > 0,

            Item::BabyOil => self.lubes.has(Lube::BabyOil),

            Item::CoconutOil => self.lubes.has(Lube::CoconutOil),

            Item::Lotion => self.lubes.has(Lube::Lotion),

            Item::Vaseline => self.lubes.has(Lube::Vaseline),

            Item::Pump | Item::CageKey => false,

        }

    }

    pub fn owned(&self) -> Vec<Item> {

        Item::ALL

            .into_iter()

            .filter(|&item| self.has(item))

            .collect()

    }

    pub fn grant(&mut self, item: Item) {

        match item {

            Item::IcePack => self.stores.ice_packs += 1,

            Item::Ruler => self.kit.ruler = true,

            Item::DoorLock => self.stores.door_locks += 1,

            Item::DndSign => self.kit.dnd_sign = true,

            Item::Blinds => self.kit.blinds = true,

            Item::PumpPro => self.kit.pump_pro = true,

            Item::Extender => self.kit.extender = true,

            Item::Ring => self.kit.ring = true,

            Item::Supplement => self.stores.supplements += 1,

            Item::Cage => self.kit.cage = true,

            Item::CageKey => self.kit.cage = false,

            Item::Spreadsheet => self.kit.spreadsheet = true,

            Item::TeapotSpout => self.kit.teapot_spout = true,

            Item::EnergyDrink => self.stores.energy_drinks += 1,

            Item::BabyOil => self.lubes.add(Lube::BabyOil),

            Item::CoconutOil => self.lubes.add(Lube::CoconutOil),

            Item::Lotion => self.lubes.add(Lube::Lotion),

            Item::Vaseline => self.lubes.add(Lube::Vaseline),

            Item::WarmTowel | Item::Pump => {}

        }

    }

}