jelq

use axum::http::{StatusCode, header};

use serde_json::json;

use super::{

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

    balance::{

        CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KETTLE_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TELLINGS,

        KITCHEN_TOLD, MELON_SHAME, RAID_NOISE, RUPTURE_LINE, WATERMELON,

    },

};

use crate::problem::Problem;

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.household.kitchen_tellings >= KITCHEN_TELLINGS {

            return Err(Problem::new(

                StatusCode::GONE,

                "kitchen-off-limits",

                "The kitchen is off limits. You have been told twice.",

            ));

        }

        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);

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

        let loot = self.oracle.pick(

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

            &[

                120 / COCONUT_ODDS,

                120 / ENERGY_ODDS,

                120 / KITCHEN_ICE_ODDS,

                120 / KETTLE_ODDS,

                120 - (120 / COCONUT_ODDS

                    + 120 / ENERGY_ODDS

                    + 120 / KITCHEN_ICE_ODDS

                    + 120 / KETTLE_ODDS),

            ],

            &[

                "A jar of coconut oil, half of it already gone.",

                "An energy drink, cold and faintly alarming.",

                "An ice pack, buried under the peas.",

                "The kettle has just boiled.",

                "Nothing. The fridge is ordinary.",

            ],

        );

        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.household.kitchen_tellings += 1;

            if self.household.kitchen_tellings >= KITCHEN_TELLINGS {

                self.end_kitchen_visit();

                return Err(Problem::new(

                    StatusCode::GONE,

                    "kitchen-off-limits",

                    "The kitchen is off limits. You have been told twice.",

                ));

            }

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

                Notice::StopRaidingTheFridge

            } else {

                Notice::StopRaidingTheKitchen

            });

        }

        if melon {

            self.here.kitchen.melon_offered = true;

            return Ok(self.melon_offer());

        }

        Ok(self.unpack(loot))

    }

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

        let (item, detail) = match loot {

            0 => (

                Item::CoconutOil,

                "A jar of coconut oil, half of it already gone.",

            ),

            1 => (

                Item::EnergyDrink,

                "An energy drink, cold and faintly alarming.",

            ),

            2 => (Item::IcePack, "An ice pack, buried under the peas."),

            3 => {

                self.here.kitchen.kettle_boiled = true;

                return Outcome::json(

                    StatusCode::OK,

                    json!({ "detail": "The kettle has just boiled. The towel can be warmed once more." }),

                );

            }

            _ => return Outcome::empty(StatusCode::NO_CONTENT),

        };

        self.items.grant(item);

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

    }

    fn melon_offer(&self) -> Outcome {

        let commit = self.path("/kitchen/watermelon");

        Outcome::json(

            StatusCode::MULTIPLE_CHOICES,

            json!({

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

                "choices": [

                    { "href": commit, "method": "POST", "title": "Commit to the watermelon" },

                    { "href": self.path(""), "method": "GET", "title": "Close the fridge" },

                ],

            }),

        )

        .header(

            header::LINK,

            format!(

                "<{commit}>; rel=\"alternate\"; title=\"Commit to the watermelon\"; allow=\"POST\""

            ),

        )

    }

    /// 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.",

            }),

        ))

    }

}