jelq

use super::balance::STARTING_ICE_PACKS;

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Item {

    WarmTowel,

    IcePack,

    Ruler,

    DoorLock,

    DndSign,

    Blinds,

    Pump,

    PumpPro,

    Extender,

    Ring,

    Supplement,

    Cage,

    CageKey,

    Spreadsheet,

    TeapotSpout,

}

pub const SHOP: [Item; 11] = [

    Item::Pump,

    Item::PumpPro,

    Item::Extender,

    Item::Ring,

    Item::Supplement,

    Item::DoorLock,

    Item::DndSign,

    Item::Blinds,

    Item::Ruler,

    Item::IcePack,

    Item::CageKey,

];

impl Item {

    const ALL: [Self; 15] = [

        Self::WarmTowel,

        Self::IcePack,

        Self::Ruler,

        Self::DoorLock,

        Self::DndSign,

        Self::Blinds,

        Self::Pump,

        Self::PumpPro,

        Self::Extender,

        Self::Ring,

        Self::Supplement,

        Self::Cage,

        Self::CageKey,

        Self::Spreadsheet,

        Self::TeapotSpout,

    ];

    pub fn slug(self) -> &'static str {

        match self {

            Self::WarmTowel => "warm-towel",

            Self::IcePack => "ice-pack",

            Self::Ruler => "ruler",

            Self::DoorLock => "door-lock",

            Self::DndSign => "do-not-disturb-sign",

            Self::Blinds => "window-blinds",

            Self::Pump => "pump",

            Self::PumpPro => "pump-pro",

            Self::Extender => "extender",

            Self::Ring => "cock-ring",

            Self::Supplement => "supplement",

            Self::Cage => "chastity-cage",

            Self::CageKey => "cage-key",

            Self::Spreadsheet => "spreadsheet",

            Self::TeapotSpout => "teapot-spout",

        }

    }

    pub fn parse(slug: &str) -> Option<Self> {

        Self::ALL.into_iter().find(|item| item.slug() == slug)

    }

    pub fn description(self) -> &'static str {

        match self {

            Self::WarmTowel => {

                "Reusable. Satisfies the warm-up precondition. Use technique=warmup."

            }

            Self::IcePack => "Lowers EQ by 40. Use technique=ice.",

            Self::Ruler => "Measures honestly. The length resource now carries a Content-Length.",

            Self::DoorLock => "Keeps the flatmate out once.",

            Self::DndSign => "Works on housekeeping. Mum does not read signs.",

            Self::Blinds => "The neighbour has a good camera. The blinds are better.",

            Self::Pump => "A pump.",

            Self::PumpPro => "Use technique=pump. Gains are temporary.",

            Self::Extender => "Passive gains each turn. Takes up room. Can be removed with DELETE.",

            Self::Ring => {

                "Girth gains doubled. Rupture risk raised. Responses are compressed if you accept gzip. Can be removed with DELETE."

            }

            Self::Supplement => "Use technique=supplement.",

            Self::Cage => "Locked.",

            Self::CageKey => "Pump-Bro does not ask.",

            Self::Spreadsheet => "Charts your progress. Every line is flat.",

            Self::TeapotSpout => "Does nothing. Cannot be dropped.",

        }

    }

    pub fn pitch(self) -> &'static str {

        match self {

            Self::PumpPro => "A pump, but professional.",

            Self::Extender => "Passive gains every turn. Takes up room.",

            Self::Ring => "Doubles girth gains. Pump-Bro does not discuss the risks.",

            Self::Supplement => "Clinically formulated. Ships from overseas.",

            Self::DndSign => "Housekeeping respects it.",

            Self::Blinds => "The neighbour has a good camera.",

            Self::Ruler => "Pump-Bro does not recommend it.",

            Self::IcePack => "Cold.",

            _ => self.description(),

        }

    }

    pub fn price(self) -> Option<u32> {

        match self {

            Self::Pump => Some(10),

            Self::PumpPro | Self::Extender | Self::CageKey => Some(15),

            Self::Ring => Some(8),

            Self::Supplement | Self::DoorLock | Self::DndSign | Self::Blinds | Self::Ruler => {

                Some(5)

            }

            Self::IcePack => Some(3),

            Self::WarmTowel | Self::Cage | Self::Spreadsheet | Self::TeapotSpout => None,

        }

    }

}

pub struct Items {

    pub ruler: bool,

    pub ice_packs: u32,

    pub door_locks: u32,

    pub dnd_sign: bool,

    pub blinds: bool,

    pub pump_pro: bool,

    pub extender: bool,

    pub ring: bool,

    pub supplements: u32,

    pub cage: bool,

    pub spreadsheet: bool,

    pub teapot_spout: bool,

}

impl Default for Items {

    fn default() -> Self {

        Self {

            ruler: false,

            ice_packs: STARTING_ICE_PACKS,

            door_locks: 0,

            dnd_sign: false,

            blinds: false,

            pump_pro: false,

            extender: false,

            ring: false,

            supplements: 0,

            cage: false,

            spreadsheet: false,

            teapot_spout: false,

        }

    }

}

impl Items {

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

        match item {

            Item::WarmTowel => true,

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

            Item::Ruler => self.ruler,

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

            Item::DndSign => self.dnd_sign,

            Item::Blinds => self.blinds,

            Item::PumpPro => self.pump_pro,

            Item::Extender => self.extender,

            Item::Ring => self.ring,

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

            Item::Cage => self.cage,

            Item::Spreadsheet => self.spreadsheet,

            Item::TeapotSpout => self.teapot_spout,

            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.ice_packs += 1,

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

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

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

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

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

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

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

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

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

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

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

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

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

        }

    }

}