jelq

use std::collections::HashMap;

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

use super::{

    Cause, Floor, Run,

    balance::{PATIENCE, VIRAL_ERRAND},

    parse_credentials,

};

use crate::problem::Problem;

const EXCUSES: [&str; 7] = [

    "changing",

    "homework",

    "pulled a muscle",

    "tidying",

    "the washing up",

    "fed the cat",

    "revising",

];

const CHRISTMAS_EXCUSES: [&str; 6] = [

    "on a call",

    "wrapping presents",

    "folding the washing",

    "hanging the lights",

    "helping Nan",

    "peeling sprouts",

];

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

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

const BEDROOM_ERRANDS: [&str; 4] = [

    "She has brought your washing.",

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

    "She needs the wifi password.",

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

];

const CHRISTMAS_ERRANDS: [&str; 4] = [

    "Nan would like to see you.",

    "Christmas dinner is in ten minutes.",

    "The King's speech is about to start.",

    "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::Nans.number() {

            return EXCUSES.to_vec();

        }

        EXCUSES

            .into_iter()

            .chain(CHRISTMAS_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(

                self.decision("viral", "Has a neighbour already sent Mum the footage?"),

                VIRAL_ERRAND,

            )

        {

            return "A neighbour has sent her something.";

        }

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

            CHRISTMAS_ERRANDS

        } else {

            BEDROOM_ERRANDS

        };

        let weights = vec![1; errands.len()];

        let i = self.oracle.pick(

            self.decision("errand", "What has brought Mum to the door?"),

            &weights,

            &errands,

        );

        errands[i]

    }

    /// Mum 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.mum.as_ref().map(|v| (v.errand, v.nonce.clone())) else {

            return Ok(());

        };

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

        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 {

            let knocked_before = self.mum.as_ref().is_some_and(|visit| visit.knocked);

            if let Some(visit) = &mut self.mum {

                visit.knocked = true;

            }

            if !knocked_before {

                self.touch();

                return Err(challenge(

                    Problem::new(

                        StatusCode::UNAUTHORIZED,

                        "someone-at-the-door",

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

                    )

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

                ));

            }

            return Err(self.strike(

                challenge(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "knocking-again",

                    format!("Mum is knocking again. {errand}"),

                )),

                Cause::Opened,

            ));

        };

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

                StatusCode::UNAUTHORIZED,

                "basic",

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

            ))));

        }

        let excuse = if digest {

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

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

                    StatusCode::UNAUTHORIZED,

                    "digest-required",

                    "Mum has started using Digest authentication.",

                ))));

            };

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

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

                StatusCode::UNAUTHORIZED,

                "excuse-replayed",

                "Mum 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 {

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

        } else {

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

        };

        Err(self.mum_strike(challenge(Problem::new(

            StatusCode::UNAUTHORIZED,

            "excuse-rejected",

            detail,

        ))))

    }

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

        self.strike(problem, Cause::Caught)

    }

    fn strike(&mut self, problem: Problem, cause: Cause) -> Problem {

        self.touch();

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

            return problem;

        };

        visit.strikes += 1;

        if visit.strikes < PATIENCE {

            return problem;

        }

        self.end(cause)

    }

    fn leave_door(&mut self) {

        self.mum = None;

        self.suspicion = 0;

        self.notices

            .push("Mum seems satisfied. She takes the washing with her.");

        self.touch();

    }

}