jelq

use axum::http::StatusCode;

use serde_json::json;

use super::{

    Cause, Choice, Floor, Item, Notice, Outcome, Run, Story,

    balance::{

        CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KETTLE_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TOLD,

        MELON_SHAME, RAID_NOISE, RUPTURE_LINE, WATERMELON,

    },

};

use crate::problem::Problem;

#[derive(Clone, Copy)]

enum Loot {

    CoconutOil,

    EnergyDrink,

    IcePack,

    Kettle,

    Nothing,

}

impl Loot {

    const ALL: [Self; 5] = [

        Self::CoconutOil,

        Self::EnergyDrink,

        Self::IcePack,

        Self::Kettle,

        Self::Nothing,

    ];

    /// Out of 120, so one draw keeps the marginals at the documented 1 in 3, 1 in 5, 1 in 8 and 1 in 6.

    fn weight(self) -> u32 {

        match self {

            Self::CoconutOil => 120 / COCONUT_ODDS,

            Self::EnergyDrink => 120 / ENERGY_ODDS,

            Self::IcePack => 120 / KITCHEN_ICE_ODDS,

            Self::Kettle => 120 / KETTLE_ODDS,

            Self::Nothing => 120 - Self::ALL[..4].iter().map(|l| l.weight()).sum::<u32>(),

        }

    }

    fn sight(self) -> &'static str {

        match self {

            Self::CoconutOil => "A jar of coconut oil, half of it already gone.",

            Self::EnergyDrink => "An energy drink, cold and faintly alarming.",

            Self::IcePack => "An ice pack, buried under the peas.",

            Self::Kettle => "The kettle has just boiled.",

            Self::Nothing => "Nothing. The fridge is ordinary.",

        }

    }

}

impl Run {

    /// The household keeps count, so every raid makes noise and the noise makes the next telling likelier.

    pub fn raid_kitchen(&mut self) -> Result<Outcome, Problem> {

        if !self.floor.has_kitchen() {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "no-kitchen",

                "There is no kitchen on this floor.",

            ));

        }

        if self.here.kitchen.closed {

            return Err(self.off_limits());

        }

        if self.online.story == Story::Pending {

            return Ok(self.branch_offer());

        }

        self.begin_turn()?;

        if self.chance(

            self.decision("rupture", "Does this raid of the fridge rupture something?"),

            self.rupture_odds(),

        ) {

            return Err(self.rupture());

        }

        self.make_noise(RAID_NOISE);

        let loot = Loot::ALL[self.oracle.pick(

            self.decision("loot", "What does the fridge give up on this raid?"),

            &Loot::ALL.map(Loot::weight),

            &Loot::ALL.map(Loot::sight),

        )];

        let melon = self.body.eq > RUPTURE_LINE

            && self.oracle.ratio(

                self.decision(

                    "watermelon",

                    "Is there a watermelon in the fridge, exactly the right shape?",

                ),

                WATERMELON.0,

                WATERMELON.1,

            );

        self.settle();

        if self.oracle.ratio(

            self.decision(

                "kitchen-told",

                "Has the household had enough of the raiding?",

            ),

            u32::from(self.standing.suspicion) + 1,

            KITCHEN_TOLD,

        ) {

            self.here.kitchen.closed = true;

            self.end_kitchen_visit();

            self.notices.push(if self.floor == Floor::Nans {

                Notice::StopRaidingTheFridge

            } else {

                Notice::StopRaidingTheKitchen

            });

            return Err(self.off_limits());

        }

        if melon {

            self.here.kitchen.melon_offered = true;

            return Ok(self.melon_offer());

        }

        Ok(self.unpack(loot))

    }

    fn off_limits(&self) -> Problem {

        Problem::new(

            StatusCode::GONE,

            "kitchen-off-limits",

            "The kitchen is off limits.",

        )

    }

    fn unpack(&mut self, loot: Loot) -> Outcome {

        let item = match loot {

            Loot::CoconutOil => Item::CoconutOil,

            Loot::EnergyDrink => Item::EnergyDrink,

            Loot::IcePack => Item::IcePack,

            Loot::Kettle => {

                self.here.kitchen.kettle_boiled = true;

                return Outcome::json(

                    StatusCode::OK,

                    json!({ "detail": format!("{} The towel can be warmed once more.", loot.sight()) }),

                );

            }

            Loot::Nothing => return Outcome::empty(StatusCode::NO_CONTENT),

        };

        self.items.grant(item);

        Outcome::json(StatusCode::OK, json!({ "detail": loot.sight() }))

    }

    fn melon_offer(&self) -> Outcome {

        Outcome::choices(

            "The fridge holds a watermelon. It is exactly the right shape.",

            &[

                Choice {

                    href: self.path("/kitchen/watermelon"),

                    method: "POST",

                    title: "Commit to the watermelon",

                },

                Choice {

                    href: self.path(""),

                    method: "GET",

                    title: "Close the fridge",

                },

            ],

        )

    }

    /// A bail-out that costs no turn. The more the household has already heard, the likelier Mum is in the doorway.

    pub fn commit_melon(&mut self) -> Result<Outcome, Problem> {

        if !self.here.kitchen.melon_offered {

            return Err(Problem::new(

                StatusCode::CONFLICT,

                "no-melon-on-offer",

                "There is no watermelon on offer.",

            ));

        }

        self.here.kitchen.melon_offered = false;

        self.reset_eq(0);

        self.standing.shame += MELON_SHAME;

        self.touch();

        if self.oracle.ratio(

            self.decision(

                "caught-meloned",

                "Is Mum standing in the doorway as you look up?",

            ),

            u32::from(self.standing.suspicion) + 2,

            CAUGHT_MELONED,

        ) {

            return Err(self.end(Cause::Meloned));

        }

        Ok(Outcome::json(

            StatusCode::OK,

            json!({

                "detail": "The watermelon did not survive, and neither did the mood. EQ is gone, the gains are kept, and the shame is considerable.",

            }),

        ))

    }

}