jelq

use super::{

    Cause, Elder, Floor, FloorState, Notice, Outcome, Run,

    balance::{

        EQ_BAND, FLOOR_ALLOWANCE, FLOOR_LIMIT, FLOOR_TURNS, FRICTION_FLOOR, LOCKER_ROOM_BAR,

        LOCKER_ROOM_OTHERS, LOCKER_ROOM_SHAME, OVERSTAY_BUSTED, OVERSTAY_EQ, OVERSTAY_SHAME,

        STARTING_EQ, ZIP,

    },

    measure::round2,

};

use crate::problem::Problem;

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

use serde_json::{Value, json};

/// How a floor was left. Only a proper exit is paid.

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

pub(super) enum Exit {

    Proper,

    Premature,

    Overstayed,

}

impl Run {

    /// Whether enough turns have passed for a timed floor to let the player go.

    pub(super) fn served_floor(&self) -> bool {

        self.here.turns >= FLOOR_TURNS

    }

    pub(super) fn next_floor(&mut self, exit: Exit) {

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

            return;

        };

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

        self.floor = next;

        self.here = FloorState {

            warm_arrival: warm,

            ..FloorState::default()

        };

        self.realise(true);

        self.reset_eq(STARTING_EQ);

        self.standing.suspicion = 0;

        self.shed(FRICTION_FLOOR);

        self.household.mum = None;

        if self.floor == Floor::ChangingRoom && !self.holds_own_in_the_locker_room() {

            self.standing.shame += LOCKER_ROOM_SHAME;

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

        }

        if exit == Exit::Proper {

            self.standing.cash += FLOOR_ALLOWANCE;

        }

        self.touch();

    }

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

        if self.floor.timed() && self.here.turns + 1 >= FLOOR_LIMIT {

            return Err(self.overstay());

        }

        Ok(())

    }

    /// A floor past its limit either ends the run or moves you along, shamed and deflated.

    fn overstay(&mut self) -> Problem {

        self.touch();

        if self.chance(

            self.decision(

                "overstayed",

                "The floor has run long. Does somebody walk in?",

            ),

            OVERSTAY_BUSTED,

        ) {

            return self.end(Cause::Overstayed);

        }

        self.standing.shame += OVERSTAY_SHAME;

        self.next_floor(Exit::Overstayed);

        self.here.warm_arrival = false;

        self.reset_eq(OVERSTAY_EQ);

        Problem::new(

            StatusCode::REQUEST_TIMEOUT,

            "floor-timed-out",

            "The floor has timed out. You have been moved along.",

        )

        .header(header::CONNECTION, "close")

    }

    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.online.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.served_floor() => {

                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(Exit::Proper);

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

                let others: Vec<Value> = LOCKER_ROOM_OTHERS

                    .into_iter()

                    .chain([("Kev", LOCKER_ROOM_BAR)])

                    .map(|(name, length)| json!({ "name": name, "self_reported_length": length }))

                    .collect();

                view["others"] = json!(others);

            }

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

            Floor::Forum => {

                view["thread"] = json!(self.path("/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

    }

    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("")))

    }

}