jelq

use super::{

    Floor, Item, Notice, Outcome, Run,

    balance::{

        BATHROOM_VASELINE, DRAWER_JAMS, GREGS_LOCKER, KEY_IN_DRAWER, RULER_IN_DRAWER, RULER_SHAME,

    },

};

use crate::problem::Problem;

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

use serde_json::json;

fn nothing() -> Result<Outcome, Problem> {

    Ok(Outcome::empty(StatusCode::NO_CONTENT))

}

impl Run {

    pub(super) fn found(&self, item: Item, detail: &str) -> Outcome {

        Outcome::json(StatusCode::FOUND, json!({ "detail": detail })).header(

            header::LOCATION,

            self.path(&format!("/inventory/{}", item.slug())),

        )

    }

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

        self.touch();

        self.end_kitchen_visit();

        if self.items.kit.cage {

            return self.rummage_for_key();

        }

        let first = !self.here.drawer.searched;

        self.here.drawer.searched = true;

        match self.floor {

            Floor::Bedroom => self.search_bedroom(first),

            Floor::Bathroom if first => Ok(self.search_bathroom()),

            Floor::ChangingRoom => self.search_locker(first),

            Floor::Nans if first => {

                self.items.grant(Item::Cage);

                self.standing.shame += 5;

                Ok(self.found(

                    Item::Cage,

                    "A small box. Inside was a cage. It is now on. The key is not in the box.",

                ))

            }

            Floor::Hotel if first => {

                for item in [Item::DndSign, Item::IcePack, Item::IcePack, Item::Lotion] {

                    self.items.grant(item);

                }

                Ok(self.found(

                    Item::DndSign,

                    "A Do Not Disturb sign, two ice packs from the machine down the hall, and a complimentary lotion.",

                ))

            }

            Floor::Forum if first => {

                self.items.grant(Item::Spreadsheet);

                Ok(self.found(

                    Item::Spreadsheet,

                    "Your own spreadsheet. Every line is flat.",

                ))

            }

            Floor::Clinic => Err(Problem::new(

                StatusCode::FORBIDDEN,

                "doctors-drawer",

                "That is the doctor's drawer.",

            )),

            _ => nothing(),

        }

    }

    fn search_bedroom(&mut self, first: bool) -> Result<Outcome, Problem> {

        let ruler_here = self.chance(

            self.decision("ruler", "Is there a ruler hiding in the drawer?"),

            RULER_IN_DRAWER,

        );

        if !first || self.items.kit.ruler || !ruler_here {

            return nothing();

        }

        self.items.grant(Item::Ruler);

        self.standing.shame += RULER_SHAME;

        Ok(self.found(

            Item::Ruler,

            "You now know. This is the first honest measurement of the run.",

        ))

    }

    fn search_bathroom(&mut self) -> Outcome {

        self.items.grant(Item::DoorLock);

        let vaseline = self.chance(

            self.decision(

                "bathroom-vaseline",

                "Is it the vaseline behind the door lock, rather than the lotion?",

            ),

            BATHROOM_VASELINE,

        );

        let (lube, detail) = if vaseline {

            (

                Item::Vaseline,

                "A door lock, which works once, and a tub of vaseline behind it.",

            )

        } else {

            (

                Item::Lotion,

                "A door lock, which works once, and a bottle of lotion behind it.",

            )

        };

        self.items.grant(lube);

        self.found(Item::DoorLock, detail)

    }

    fn search_locker(&mut self, first: bool) -> Result<Outcome, Problem> {

        let open = first

            && self.chance(

                self.decision("gregs-locker", "Has Greg left his locker open?"),

                GREGS_LOCKER,

            );

        if open {

            self.items.grant(Item::BabyOil);

            return Ok(self.found(

                Item::BabyOil,

                "Greg has left his locker open. The baby oil is yours now, legally speaking.",

            ));

        }

        self.standing.shame += 3;

        Err(Problem::new(

            StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,

            "not-your-locker",

            "That locker belongs to Greg. The server cannot serve this request for legal reasons.",

        ))

    }

    /// Searching while caged is noisy, costs the floor turn, and the key only turns up some of

    /// the time. A jammed drawer takes a whole turn to work loose.

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

        self.begin_turn()?;

        self.add_suspicion(1);

        self.maybe_summon_mum();

        if self.here.drawer.jammed {

            self.here.drawer.jammed = false;

            self.notices.push(Notice::DrawerComesLoose);

            return Ok(Outcome::empty(StatusCode::NO_CONTENT));

        }

        if !self.chance(

            self.decision("key", "Does the drawer finally give up the cage key?"),

            KEY_IN_DRAWER,

        ) {

            if self.chance(

                self.decision("drawer-jams", "Has the drawer jammed on its runners?"),

                DRAWER_JAMS,

            ) {

                self.here.drawer.jammed = true;

                self.notices.push(Notice::DrawerJammed);

            }

            return Ok(Outcome::empty(StatusCode::NO_CONTENT));

        }

        self.items.grant(Item::CageKey);

        Ok(Outcome::json(

            StatusCode::OK,

            json!({ "detail": "The key was in the drawer. The cage is off." }),

        ))

    }

    pub fn drawer_worth_searching(&self) -> bool {

        !self.here.drawer.searched || self.items.kit.cage

    }

}