jelq

use std::time::Instant;

use serde_json::{Value, json};

use super::{

    Arousal, Arrival, Danger, Elder, Excuse, Floor, Grip, Item, Observer, Run, Story, Technique,

    balance::{DANGER_EQ, FLOOR_LIMIT},

    techniques::{Training, Utility},

};

pub enum Shown {

    Measured(f64),

    SelfReported(f64),

}

pub struct Gauges {

    pub(crate) length: Shown,

    pub(crate) girth: f64,

    pub(crate) foreskin: Option<f64>,

    pub(crate) friction: i32,

    pub(crate) arousal: Arousal,

    pub(crate) stamina: i32,

    pub(crate) max_stamina: i32,

    pub(crate) suspicion: u8,

    pub(crate) cash: u32,

    pub(crate) floor: u8,

    pub(crate) turn: u32,

    pub(crate) floor_turns: u32,

    pub(crate) floor_limit: Option<u32>,

    pub(crate) floor_over: bool,

    pub(crate) dangers: Vec<(&'static str, Danger)>,

    pub(crate) observed: Option<Observer>,

    pub(crate) mum_challenge: Option<String>,

    pub(crate) warnings: Vec<&'static str>,

    pub(crate) arrived: Option<Arrival>,

    pub(crate) ruler: bool,

    pub(crate) ring: bool,

}

pub struct Reach {

    pub(crate) foreskin: bool,

    pub(crate) drawer: bool,

    pub(crate) kitchen: bool,

    pub(crate) thread: bool,

    pub(crate) shop: bool,

    pub(crate) portal: bool,

    pub(crate) elder: bool,

    pub(crate) footage: bool,

    pub(crate) diagnosis: bool,

    pub(crate) branch_pending: bool,

    pub(crate) shopping: bool,

}

impl Run {

    /// Drains the notices, so call it once per response.

    pub fn gauges(&mut self) -> Gauges {

        let conditions = &self.body.conditions;

        let mut warnings = Vec::new();

        if conditions.pulled_muscle {

            warnings.push("a muscle has been pulled");

        }

        if conditions.friction_burn {

            warnings.push("friction burn");

        }

        warnings.extend(self.notices.drain(..).map(|notice| notice.text()));

        let arrived = self.body.arrived.take();

        if arrived.is_some() {

            warnings.push("the queued gains have arrived");

        }

        if self.hotter_than(DANGER_EQ) && self.ended.is_none() {

            warnings.push("it is turning purple");

        }

        Gauges {

            length: if self.items.kit.ruler {

                Shown::Measured(self.current_length())

            } else {

                Shown::SelfReported(self.self_reported())

            },

            girth: self.body.girth,

            foreskin: self.body.foreskin,

            friction: self.body.friction,

            arousal: self.arousal(),

            stamina: self.body.stamina,

            max_stamina: self.max_stamina(),

            suspicion: self.standing.suspicion,

            cash: self.standing.cash,

            floor: self.floor.number(),

            turn: self.turn,

            floor_turns: self.here.turns,

            floor_limit: self.floor.timed().then_some(FLOOR_LIMIT),

            floor_over: self.floor.timed() && self.served_floor(),

            dangers: self.dangers(),

            observed: self.observed,

            mum_challenge: self.mum_challenge(),

            warnings,

            arrived,

            ruler: self.items.kit.ruler,

            ring: self.items.kit.ring,

        }

    }

    pub fn reach(&self) -> Reach {

        Reach {

            foreskin: self.body.foreskin.is_some(),

            drawer: self.drawer_worth_searching(),

            kitchen: self.floor.has_kitchen() && !self.here.kitchen.closed,

            thread: self.thread_reachable(),

            shop: self.floor.shop_open(),

            portal: self.needs_portal(),

            elder: self.floor == Floor::Forum && self.online.elder != Elder::Beaten,

            footage: self.online.filmed_at.is_some(),

            diagnosis: self.floor == Floor::Clinic,

            branch_pending: self.online.story == Story::Pending,

            shopping: self.here.shopping,

        }

    }

    pub fn needs_portal(&self) -> bool {

        self.floor == Floor::Hotel && !self.here.wifi_accepted

    }

    /// Shame follows the player across runs in a signed cookie. Each response adds this run's new

    /// shame to whatever total the client presents, so two runs at once both count.

    pub fn settle_shame(&mut self, presented: Option<u32>) -> u32 {

        let standing = &mut self.standing;

        let total =

            presented.unwrap_or(standing.shame_total) + (standing.shame - standing.shame_reported);

        standing.shame_reported = standing.shame;

        standing.shame_total = total;

        total

    }

    pub fn trace(&mut self) {

        self.standing.shame += 1;

    }

    pub fn measured(&self) -> bool {

        self.items.kit.ruler

    }

    pub fn id(&self) -> &str {

        &self.ident.id

    }

    pub fn last_seen(&self) -> Instant {

        self.ident.last_seen

    }

    /// A request has arrived. Whoever was watching last time has looked away.

    pub fn seen(&mut self, now: Instant) {

        self.ident.last_seen = now;

        self.observed = None;

    }

    pub fn foreskin(&self) -> Option<f64> {

        self.body.foreskin

    }

    pub fn grip(&self) -> Grip {

        self.body.grip

    }

    pub fn knows(&self, technique: Technique) -> bool {

        match technique {

            Technique::Training(Training::Uli) => self.online.uli_taught,

            Technique::Utility(Utility::Meditate) => self.online.meditation_taught,

            _ => true,

        }

    }

    pub fn holds(&self, item: Item) -> bool {

        self.items.has(item)

    }

    pub fn inventory_view(&self) -> Value {

        let items: Vec<Value> = self

            .items

            .owned()

            .into_iter()

            .map(|item| {

                json!({

                    "name": item.slug(),

                    "href": self.item_path(item),

                })

            })

            .collect();

        json!({

            "items": items,

            "ice_packs": self.items.stores.ice_packs,

            "supplements": self.items.stores.supplements,

            "excuses": self.excuses().into_iter().map(Excuse::phrase).collect::<Vec<_>>(),

        })

    }

}