jelq

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

use serde_json::{Value, json};

use super::{

    Cause, Elder, Floor, FloorState, Item, Outcome, Run,

    balance::{

        EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, FRICTION_FLOOR, GREGS_LOCKER, KEY_IN_DRAWER,

        RULER_IN_DRAWER, STARTING_EQ, SUSPICION_LIMIT, ZIP,

    },

    round2,

};

use crate::problem::Problem;

impl Run {

    pub(super) fn next_floor(&mut self, paid: bool) {

        let Some(next) = self.floor.next() else {

            return;

        };

        let warm = EQ_BAND.contains(&self.eq);

        self.floor = next;

        self.here = FloorState {

            warm_arrival: warm,

            ..FloorState::default()

        };

        self.warmed_up = false;

        self.reset_eq(STARTING_EQ);

        self.suspicion = 0;

        self.shed(FRICTION_FLOOR);

        self.mum = None;

        if paid {

            self.cash += FLOOR_ALLOWANCE;

        }

        self.touch();

    }

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

        match self.floor {

            Floor::Clinic => {

                return Err(Problem::new(

                    StatusCode::CONFLICT,

                    "no-further-floor",

                    "There is no further floor. There is only the diagnosis.",

                ));

            }

            Floor::Forum if self.elder != Elder::Beaten => {

                return Err(Problem::new(

                    StatusCode::CONFLICT,

                    "elder-unaddressed",

                    "The Elder has not been addressed.",

                )

                .with("elder", self.path("/elder")));

            }

            floor if floor.timed() && self.here.turns < FLOOR_TURNS => {

                return Err(Problem::new(

                    StatusCode::TOO_EARLY,

                    "floor-not-over",

                    format!(

                        "The floor is not over. {} turns remain.",

                        FLOOR_TURNS - self.here.turns

                    ),

                ));

            }

            _ => {}

        }

        if self.chance(

            self.decision(

                "zip",

                "As the floor ends and you put yourself away, does the zip catch?",

            ),

            ZIP,

        ) {

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

        }

        let left = self.floor.name();

        let reverted = self.here.temp_length;

        self.next_floor(true);

        let warm = if self.here.warm_arrival {

            ", and the warmth came with you"

        } else {

            ""

        };

        let mut body = json!({

            "detail": format!("You leave {left}. You have arrived at {}{warm}.", self.floor.name()),

            "note": self.floor.note(),

        });

        if reverted > 0.0 {

            body["reverted"] = json!(round2(reverted));

        }

        Ok(

            Outcome::json(StatusCode::SEE_OTHER, body)

                .header(header::LOCATION, self.path("/floor")),

        )

    }

    pub fn floor_view(&self) -> Value {

        let mut view = json!({

            "name": self.floor.name(),

            "note": self.floor.note(),

            "turns": self.here.turns,

            "turns_required": self.floor.timed().then_some(FLOOR_TURNS),

            "exit": { "href": self.path("/floor"), "method": "POST" },

        });

        match self.floor {

            Floor::ChangingRoom => {

                view["others"] = json!([

                    { "name": "Greg", "self_reported_length": 9.5 },

                    { "name": "Dmitri", "self_reported_length": 8.75 },

                    { "name": "a man in a towel", "self_reported_length": 11.0 },

                ]);

            }

            Floor::Hotel => view["portal"] = json!(self.path("/portal")),

            Floor::Forum => {

                view["thread"] = json!(super::FORUM_THREAD);

                view["elder"] = json!(self.path("/elder"));

            }

            Floor::Clinic => view["diagnosis"] = json!(self.path("/diagnosis")),

            _ => {}

        }

        if self.floor.shop_open() {

            view["shop"] = json!(self.path("/shop"));

        }

        view

    }

    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.cage {

            return Ok(self.rummage_for_key());

        }

        let first = !self.here.drawer_searched;

        self.here.drawer_searched = true;

        let ruler_here = self.floor == Floor::Bedroom

            && self.chance(

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

                RULER_IN_DRAWER,

            );

        let locker_open = self.floor == Floor::ChangingRoom

            && first

            && self.chance(

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

                GREGS_LOCKER,

            );

        match self.floor {

            Floor::Bedroom if first && !self.items.ruler && ruler_here => {

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

                self.shame += 10;

                Ok(self.found(

                    Item::Ruler,

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

                ))

            }

            Floor::Bathroom if first => {

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

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

                Ok(self.found(

                    Item::DoorLock,

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

                ))

            }

            Floor::ChangingRoom if locker_open => {

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

                Ok(self.found(

                    Item::BabyOil,

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

                ))

            }

            Floor::ChangingRoom => {

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

                ))

            }

            Floor::Nans if first => {

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

                self.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 => {

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

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

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

                Ok(self.found(

                    Item::DndSign,

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

                ))

            }

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

            )),

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

        }

    }

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

        if self.floor != Floor::Hotel {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "no-portal",

                "There is no captive portal here. There is only the regular kind of captivity.",

            ));

        }

        self.here.wifi_accepted = true;

        self.touch();

        Ok(Outcome::json(

            StatusCode::SEE_OTHER,

            json!({ "detail": "Connected. The hotel does not want to know." }),

        )

        .header(header::LOCATION, self.path("")))

    }

    /// Searching while caged is noisy, and the key only turns up some of the time.

    fn rummage_for_key(&mut self) -> Outcome {

        let was_below = self.suspicion < SUSPICION_LIMIT;

        self.suspicion = (self.suspicion + 1).min(SUSPICION_LIMIT);

        self.maybe_summon_mum(was_below);

        if !self.chance(

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

            KEY_IN_DRAWER,

        ) {

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

        }

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

        Outcome::json(

            StatusCode::OK,

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

        )

    }

    /// Whether searching the drawer on this floor would turn anything up.

    pub fn drawer_worth_searching(&self) -> bool {

        !self.here.drawer_searched || self.items.cage

    }

}