jelq

use std::collections::HashMap;

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

use rand::Rng;

use super::{

    Cause, Floor, Run,

    balance::{PATIENCE, VIRAL_ERRAND},

    parse_credentials,

};

use crate::problem::Problem;

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

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

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

const TRUE_WHEN_PULLED: &str = "pulled a muscle";

const BEDROOM_ERRANDS: [&str; 4] = [

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

];

const THANKSGIVING_ERRANDS: [&str; 4] = [

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

];

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 spoken(authorization: &str) -> String {

    authorization

        .split_once(' ')

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

        .unwrap_or_default()

}

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(super) fn errand(&mut self, summoned: bool) -> &'static str {

        if summoned {

            return "She heard a noise.";

        }

        if self.filmed_at.is_some() && self.chance(VIRAL_ERRAND) {

            return "A neighbour has sent her something.";

        }

        let errands = if self.floor == Floor::Grandmas {

            THANKSGIVING_ERRANDS

        } else {

            BEDROOM_ERRANDS

        };

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

    }

    /// Mom answers every request on the run until she has been given something she believes.

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

        let Some((errand, nonce)) = self.mom.as_ref().map(|v| (v.errand, v.nonce.clone())) else {

            return Ok(());

        };

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

        let challenge_value = if digest {

            format!("Digest realm=\"household\", nonce=\"{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. {errand}"),

                )

                .with("inventory", self.path("/inventory")),

            ));

        };

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

            self.shame += 10;

            self.leave_door();

            return Ok(());

        }

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

            return Err(self.mom_strike(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(self.mom_strike(challenge(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "digest-required",

                    "Mom has started using Digest authentication.",

                ))));

            };

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

                return Err(self.mom_strike(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(());

        }

        let true_now = self.conditions.pulled_muscle && excuse == TRUE_WHEN_PULLED;

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

            self.shame += 3;

            return Err(self.mom_strike(challenge(Problem::new(

                StatusCode::UNAUTHORIZED,

                "excuse-replayed",

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

            ))));

        }

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

            self.heard.push(excuse);

            self.leave_door();

            return Ok(());

        }

        self.shame += 3;

        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(self.mom_strike(challenge(Problem::new(

            StatusCode::UNAUTHORIZED,

            "excuse-rejected",

            detail,

        ))))

    }

    fn mom_strike(&mut self, problem: Problem) -> Problem {

        self.touch();

        let Some(visit) = &mut self.mom else {

            return problem;

        };

        visit.strikes += 1;

        if visit.strikes < PATIENCE {

            return problem;

        }

        self.end(Cause::Caught)

    }

    fn leave_door(&mut self) {

        self.mom = None;

        self.suspicion = 0;

        self.touch();

    }

}