jelq

use std::collections::HashMap;

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

use rand::Rng;

use serde::Deserialize;

use serde_json::{Value, json};

use super::{

    Floor, Grip, Outcome, Run, SHOP, SUSPICION_LIMIT, X_DIAGNOSIS, honest, parse_credentials,

    round2,

};

use crate::problem::Problem;

pub const FORUM_THREAD: &str = "/forum/threads/2009";

pub const ELDER_LAST_MODIFIED: &str = "Sun, 14 Jun 2009 03:12:00 GMT";

pub const EXCUSES: [&str; 3] = ["changing", "homework", "pulled a muscle"];

pub const THANKSGIVING_EXCUSES: [&str; 3] = ["on a call", "folding laundry", "praying"];

const TRUTHS: [&str; 3] = ["the truth", "truth", "honesty"];

const INTAKE: [&str; 3] = [

    "The clinic does not accept excuses.",

    "The clinic accepts one token. You have not been carrying it.",

    "Be honest.",

];

const SPREADSHEET: &str = "\

date,length,girth,technique,notes,honest?

2007-01-03,7.50,5.50,wet,baseline,no

2007-06-11,7.50,5.50,wet,feeling fuller,no

2008-01-02,7.50,5.50,dry,new routine,no

2008-09-19,7.50,5.50,uli,PUT is idempotent. do not use PUT.,no

2009-06-14,7.50,5.50,wet,progress is slow but real,no

";

pub fn forum_thread() -> Value {

    json!({

        "title": "The definitive jelqing FAQ (updated 2009)",

        "posts": [

            { "author": "TheElder", "body": "Warm up. Always warm up. A cold jelq is a 412 waiting to happen." },

            { "author": "TheElder", "body": "Keep EQ between 50 and 70. Above 70 you are gambling. Above 90 you are a cautionary tale." },

            { "author": "newbie_2009", "body": "I have been sending PUT for three weeks and nothing has changed." },

            { "author": "TheElder", "body": "PUT is idempotent. Read the spec." },

            { "author": "TheElder", "body": "Members verify with a Ruler. Proxy-Authorization, inches, no rounding up. We can tell." },

            { "author": "throwaway_77", "body": "my doctor said i was normal. i didnt believe him. i still dont know what he meant by bearer" },

            { "author": "TheElder", "body": "My numbers are in my spreadsheet. They have not changed since 2009. Nothing about me has changed since 2009." },

        ],

    })

}

#[derive(Deserialize)]

pub struct PatchOp {

    pub op: String,

    pub path: String,

    #[serde(default)]

    pub value: Value,

}

fn digest_params(authorization: &str) -> Option<HashMap<String, String>> {

    let (scheme, rest) = authorization.trim().split_once(' ')?;

    if !scheme.eq_ignore_ascii_case("digest") {

        return None;

    }

    Some(

        rest.split(',')

            .filter_map(|pair| {

                let (key, value) = pair.split_once('=')?;

                Some((

                    key.trim().to_ascii_lowercase(),

                    value.trim().trim_matches('"').to_owned(),

                ))

            })

            .collect(),

    )

}

fn exaggeration() -> Problem {

    Problem::new(

        StatusCode::BAD_REQUEST,

        "exaggeration",

        "The server has measured. Lying is not a technique.",

    )

}

impl Run {

    pub fn excuses(&self) -> Vec<&'static str> {

        if self.floor.number() < Floor::Grandmas.number() {

            return EXCUSES.to_vec();

        }

        EXCUSES

            .into_iter()

            .chain(THANKSGIVING_EXCUSES)

            .filter(|e| !self.heard.iter().any(|h| h == e))

            .collect()

    }

    pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {

        let digest = self.floor == Floor::Grandmas;

        let challenge_value = if digest {

            format!("Digest realm=\"household\", nonce=\"{}\"", self.nonce)

        } else {

            "Excuse realm=\"household\"".to_owned()

        };

        let challenge = |p: Problem| p.header(header::WWW_AUTHENTICATE, &challenge_value);

        let Some(authorization) = authorization else {

            return Err(challenge(

                Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "someone-at-the-door",

                    format!("Someone is at the door. {}", self.mom_errand),

                )

                .with("inventory", format!("/runs/{}/inventory", self.id)),

            ));

        };

        let spoken = authorization

            .split_once(' ')

            .map(|(_, rest)| rest.trim().trim_matches('"').to_ascii_lowercase())

            .unwrap_or_default();

        if TRUTHS.contains(&spoken.as_str()) {

            self.shame += 10;

            self.leave_door();

            return Ok(());

        }

        if parse_credentials(authorization, "basic").is_some() {

            return Err(challenge(Problem::new(

                StatusCode::UNAUTHORIZED,

                "basic",

                "Mom does not accept Basic authentication. Nobody should.",

            )));

        }

        let excuse = if digest {

            let Some(params) = digest_params(authorization) else {

                return Err(challenge(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "digest-required",

                    "Mom has started using Digest authentication.",

                )));

            };

            if params.get("nonce") != Some(&self.nonce) {

                return Err(challenge(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "stale-nonce",

                    "That was a different conversation.",

                )));

            }

            params.get("username").cloned().unwrap_or_default()

        } else {

            parse_credentials(authorization, "excuse")

                .unwrap_or_default()

                .to_owned()

        };

        let excuse = excuse.to_ascii_lowercase();

        if TRUTHS.contains(&excuse.as_str()) {

            self.shame += 10;

            self.leave_door();

            return Ok(());

        }

        if digest && self.heard.contains(&excuse) {

            self.shame += 3;

            self.touch();

            return Err(challenge(Problem::new(

                StatusCode::UNAUTHORIZED,

                "excuse-replayed",

                "Mom has heard that one before. She would have preferred the truth.",

            )));

        }

        if self.excuses().contains(&excuse.as_str()) {

            self.heard.push(excuse);

            self.leave_door();

            return Ok(());

        }

        self.shame += 3;

        self.touch();

        let detail = if digest {

            "Mom has not heard that one before. She does not believe it. She would have preferred the truth."

        } else {

            "Mom has not heard that one before. She does not believe it."

        };

        Err(challenge(Problem::new(

            StatusCode::UNAUTHORIZED,

            "excuse-rejected",

            detail,

        )))

    }

    pub(super) fn errand(&mut self, summoned: bool) -> &'static str {

        if summoned {

            return "She heard a noise.";

        }

        let errands: &[&'static str] = if self.floor == Floor::Grandmas {

            &[

                "Grandma would like to see you.",

                "Dinner is in ten minutes.",

                "She needs help with the folding table.",

                "An uncle has asked where you went.",

            ]

        } else {

            &[

                "She has brought laundry.",

                "She wants to know if you have eaten.",

                "She needs the wifi password.",

                "She would like to talk about your future.",

            ]

        };

        errands[self.rng.random_range(0..errands.len())]

    }

    fn leave_door(&mut self) {

        self.mom_present = false;

        self.suspicion = 0;

        self.touch();

    }

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

        let wanders_in = matches!(self.floor, Floor::Bathroom | Floor::Hotel)

            && self.rng.random_ratio(u32::from(self.suspicion) + 1, 32);

        if self.suspicion < SUSPICION_LIMIT && !wanders_in {

            return Ok(());

        }

        match self.floor {

            Floor::Bathroom => {

                self.suspicion = 0;

                self.touch();

                if self.items.door_locks > 0 {

                    self.items.door_locks -= 1;

                    return Ok(());

                }

                self.roommate_told = true;

                Err(Problem::new(

                    StatusCode::CONFLICT,

                    "roommate",

                    "The roommate needs the bathroom. He will mention this to people.",

                ))

            }

            Floor::LockerRoom => {

                self.suspicion = 0;

                self.shame += 5;

                self.touch();

                Err(Problem::new(

                    StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,

                    "gym-staff",

                    "Gym staff have been notified. The server cannot serve this request for legal reasons.",

                ))

            }

            Floor::Hotel => {

                self.suspicion = 0;

                self.touch();

                if self.items.dnd_sign {

                    return Ok(());

                }

                self.shame += 3;

                Err(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "housekeeping",

                    "Housekeeping has entered. Housekeeping accepts no excuses.",

                )

                .header(header::WWW_AUTHENTICATE, "Excuse realm=\"housekeeping\""))

            }

            _ => Ok(()),

        }

    }

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

        self.drawer_searches += 1;

        self.touch();

        let first = self.drawer_searches == 1;

        let id = self.id.clone();

        let found = |slug: &str, detail: &str| {

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

                .header(header::LOCATION, format!("/runs/{id}/inventory/{slug}"))

        };

        match self.floor {

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

                self.items.ruler = true;

                self.shame += 10;

                Ok(found(

                    "ruler",

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

                ))

            }

            Floor::Bathroom if first => {

                self.items.door_locks += 1;

                Ok(found("door-lock", "A door lock. It works once."))

            }

            Floor::LockerRoom => {

                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::Grandmas if first => {

                self.items.cage = true;

                self.shame += 5;

                Ok(found(

                    "chastity-cage",

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

                ))

            }

            Floor::Grandmas if self.items.cage => {

                self.items.cage = false;

                Ok(Outcome::json(

                    StatusCode::OK,

                    json!({ "detail": "The key was under where the box had been. The cage is off." }),

                ))

            }

            Floor::Hotel if first => {

                self.items.dnd_sign = true;

                self.items.ice_packs += 2;

                Ok(found(

                    "do-not-disturb-sign",

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

                ))

            }

            Floor::Forum if first => {

                self.items.spreadsheet = true;

                Ok(found(

                    "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 shop_view(&self) -> Result<Value, Problem> {

        if !self.floor.shop_open() {

            return Err(pump_bro_absent());

        }

        let stock: Vec<Value> = SHOP

            .iter()

            .map(|item| {

                json!({

                    "item": item.slug,

                    "price": item.price,

                    "description": item.description,

                    "href": format!("/runs/{}/shop/{}", self.id, item.slug),

                    "method": "POST",

                })

            })

            .collect();

        Ok(json!({ "merchant": "Pump-Bro", "cash": self.cash, "stock": stock }))

    }

    pub fn buy(&mut self, slug: &str) -> Result<Outcome, Problem> {

        if !self.floor.shop_open() {

            return Err(pump_bro_absent());

        }

        let Some(item) = SHOP.iter().find(|i| i.slug == slug) else {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "not-for-sale",

                "Pump-Bro does not sell that. He knows a guy.",

            ));

        };

        if slug == "pump" {

            return Err(Problem::new(

                StatusCode::UPGRADE_REQUIRED,

                "upsell",

                "This pump requires an upgrade.",

            )

            .header(header::UPGRADE, "pump-pro/2.0")

            .with("upgrade", format!("/runs/{}/shop/pump-pro", self.id)));

        }

        if self.cash < item.price {

            return Err(Problem::new(

                StatusCode::PAYMENT_REQUIRED,

                "insufficient-funds",

                "Payment is required. RFC 9110 has reserved this status for future use since 1997. The future is here and you cannot afford it.",

            )

            .with("cash", self.cash)

            .with("price", item.price));

        }

        self.cash -= item.price;

        self.touch();

        let items = &mut self.items;

        match slug {

            "supplement" => {

                items.supplements += 1;

                return Err(Problem::new(

                    StatusCode::GATEWAY_TIMEOUT,

                    "still-shipping",

                    "The supplement is still shipping. You have been charged. It may arrive.",

                )

                .with("cash", self.cash));

            }

            "pump-pro" => items.pump_pro = true,

            "extender" => items.extender = true,

            "cock-ring" => items.ring = true,

            "door-lock" => items.door_locks += 1,

            "do-not-disturb-sign" => items.dnd_sign = true,

            "ruler" => items.ruler = true,

            "ice-pack" => items.ice_packs += 1,

            _ => items.cage = false,

        }

        Ok(Outcome::json(

            StatusCode::CREATED,

            json!({ "detail": "Purchased. No refunds.", "cash": self.cash }),

        )

        .header(

            header::LOCATION,

            format!("/runs/{}/inventory/{slug}", self.id),

        ))

    }

    pub fn drop_item(&mut self, slug: &str) -> Result<Outcome, Problem> {

        match slug {

            "extender" => self.items.extender = false,

            "cock-ring" => self.items.ring = false,

            "chastity-cage" => {

                return Err(Problem::new(

                    StatusCode::LOCKED,

                    "caged",

                    "The cage is locked.",

                ));

            }

            _ => {

                return Err(Problem::new(

                    StatusCode::FORBIDDEN,

                    "cannot-be-dropped",

                    "That cannot be dropped.",

                ));

            }

        }

        self.touch();

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

    }

    pub(super) fn branch_offer(&self) -> Outcome {

        let forum = format!("/runs/{}/branches/forum", self.id);

        let close = format!("/runs/{}/branches/close-tab", self.id);

        Outcome::json(

            StatusCode::MULTIPLE_CHOICES,

            json!({

                "detail": "A browser tab is open. It has been open for some time.",

                "choices": [

                    { "href": forum, "method": "POST", "title": "Read the forum" },

                    { "href": close, "method": "POST", "title": "Close the tab" },

                ],

            }),

        )

        .header(

            header::LINK,

            format!(

                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\", <{close}>; rel=\"alternate\"; title=\"Close the tab\""

            ),

        )

    }

    pub fn choose(&mut self, choice: &str) -> Result<Outcome, Problem> {

        if !self.branch_pending {

            return Err(Problem::new(

                StatusCode::CONFLICT,

                "no-decision-pending",

                "There is no decision pending.",

            ));

        }

        let (location, detail) = match choice {

            "forum" => {

                self.forum_read = true;

                self.shame += 3;

                (

                    format!("/runs/{}/techniques", self.id),

                    "The thread is from 2009. A technique called uli is discussed at length.",

                )

            }

            "close-tab" => {

                self.suspicion = 0;

                (

                    format!("/runs/{}", self.id),

                    "The tab is closed. Nobody saw it.",