jelq

use std::collections::HashMap;

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

use super::{

    Cause, Floor, Notice, Run,

    balance::{PATIENCE, VIRAL_ERRAND},

    credentials::{Scheme, parse_credentials},

};

use crate::problem::Problem;

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

pub enum Excuse {

    Changing,

    Homework,

    PulledAMuscle,

    Tidying,

    TheWashingUp,

    FedTheCat,

    Revising,

    OnACall,

    WrappingPresents,

    FoldingTheWashing,

    HangingTheLights,

    HelpingNan,

    PeelingSprouts,

}

impl Excuse {

    const EVERYDAY: [Self; 7] = [

        Self::Changing,

        Self::Homework,

        Self::PulledAMuscle,

        Self::Tidying,

        Self::TheWashingUp,

        Self::FedTheCat,

        Self::Revising,

    ];

    const CHRISTMAS: [Self; 6] = [

        Self::OnACall,

        Self::WrappingPresents,

        Self::FoldingTheWashing,

        Self::HangingTheLights,

        Self::HelpingNan,

        Self::PeelingSprouts,

    ];

    pub fn phrase(self) -> &'static str {

        match self {

            Self::Changing => "changing",

            Self::Homework => "homework",

            Self::PulledAMuscle => "pulled a muscle",

            Self::Tidying => "tidying",

            Self::TheWashingUp => "the washing up",

            Self::FedTheCat => "fed the cat",

            Self::Revising => "revising",

            Self::OnACall => "on a call",

            Self::WrappingPresents => "wrapping presents",

            Self::FoldingTheWashing => "folding the washing",

            Self::HangingTheLights => "hanging the lights",

            Self::HelpingNan => "helping Nan",

            Self::PeelingSprouts => "peeling sprouts",

        }

    }

    fn all() -> impl Iterator<Item = Self> {

        Self::EVERYDAY.into_iter().chain(Self::CHRISTMAS)

    }

    fn parse(spoken: &str) -> Option<Self> {

        Self::all().find(|excuse| excuse.phrase().eq_ignore_ascii_case(spoken))

    }

}

/// Every excuse Mum might hear, so a localised one can be traced back to the phrase she checks.

pub fn vocabulary() -> impl Iterator<Item = &'static str> {

    Excuse::all().map(Excuse::phrase)

}

fn is_truth(spoken: &str) -> bool {

    ["the truth", "truth", "honesty"]

        .iter()

        .any(|truth| truth.eq_ignore_ascii_case(spoken))

}

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

];

#[derive(Default)]

pub struct Household {

    pub(crate) mum: Option<MumVisit>,

    /// Every excuse Mum has accepted this run. Digest Mum remembers them all.

    pub(crate) heard: Vec<Excuse>,

}

pub struct MumVisit {

    pub(crate) errand: &'static str,

    pub(crate) nonce: String,

    pub(crate) strikes: u8,

    pub(crate) knocked: bool,

}

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) -> &str {

    authorization

        .split_once(' ')

        .map_or("", |(_, rest)| rest.trim().trim_matches('"'))

}

fn names_a_scheme(authorization: &str) -> bool {

    authorization

        .trim()

        .split_once(' ')

        .is_some_and(|(scheme, _)| {

            ["basic", "digest", "excuse"]

                .iter()

                .any(|known| known.eq_ignore_ascii_case(scheme))

        })

}

fn turned_away(code: &'static str, detail: &'static str) -> Problem {

    Problem::new(StatusCode::UNAUTHORIZED, code, detail)

}

impl Run {

    pub fn excuses(&self) -> Vec<Excuse> {

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

            return Excuse::EVERYDAY.to_vec();

        }

        Excuse::all()

            .filter(|excuse| !self.household.heard.contains(excuse))

            .collect()

    }

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

        if summoned {

            return "She heard a noise.";

        }

        if self.online.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(visit) = &self.household.mum else {

            return Ok(());

        };

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

        let challenge = if digest {

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

        } else {

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

        };

        let result = match authorization {

            None => Err(self.knock()),

            Some(authorization) => self.hear(authorization, digest),

        };

        if self.ended.is_some() {

            return result;

        }

        result.map_err(|problem| problem.header(header::WWW_AUTHENTICATE, &challenge))

    }

    /// The first knock is free. Every one after it is a strike.

    fn knock(&mut self) -> Problem {

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

            unreachable!("knock is only called while Mum is at the door");

        };

        let errand = visit.errand;

        if !std::mem::replace(&mut visit.knocked, true) {

            self.touch();

            return Problem::new(

                StatusCode::UNAUTHORIZED,

                "someone-at-the-door",

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

            )

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

        }

        self.strike(

            Problem::new(

                StatusCode::UNAUTHORIZED,

                "knocking-again",

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

            ),

            Cause::Opened,

        )

    }

    fn hear(&mut self, authorization: &str, digest: bool) -> Result<(), Problem> {

        if is_truth(spoken(authorization)) {

            self.confess();

            return Ok(());

        }

        if !names_a_scheme(authorization) {

            self.touch();

            return Err(turned_away(

                "excuse-unheard",

                if digest {

                    "Mum did not catch that. At Christmas she uses Digest, with the excuse as the username."

                } else {

                    "Mum did not catch that. Excuses are given as Excuse \"homework\"."

                },

            ));

        }

        if parse_credentials(authorization, Scheme::Basic).is_some() {

            return Err(self.mum_strike(turned_away(

                "basic",

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

            )));

        }

        let said = if digest {

            self.digest_username(authorization)?

        } else {

            parse_credentials(authorization, Scheme::Excuse)

                .unwrap_or_default()

                .to_owned()

        };

        if is_truth(&said) {

            self.confess();

            return Ok(());

        }

        let excuse = Excuse::parse(&said);

        let true_now = self.body.conditions.pulled_muscle && excuse == Some(Excuse::PulledAMuscle);

        if digest && !true_now && excuse.is_some_and(|e| self.household.heard.contains(&e)) {

            self.standing.shame += 3;

            return Err(self.mum_strike(turned_away(

                "excuse-replayed",

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

            )));

        }

        if let Some(excuse) = excuse.filter(|e| true_now || self.excuses().contains(e)) {

            self.household.heard.push(excuse);

            self.leave_door();

            return Ok(());

        }

        self.standing.shame += 3;

        Err(self.mum_strike(turned_away(

            "excuse-rejected",

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

            },

        )))

    }

    fn digest_username(&mut self, authorization: &str) -> Result<String, Problem> {

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

            return Err(self.mum_strike(turned_away(

                "digest-required",

                "Mum has started using Digest authentication.",

            )));

        };

        let current = self

            .household

            .mum

            .as_ref()

            .is_some_and(|visit| params.get("nonce") == Some(&visit.nonce));

        if !current {

            return Err(self.mum_strike(turned_away(

                "stale-nonce",

                "That was a different conversation.",

            )));

        }

        Ok(params.remove("username").unwrap_or_default())

    }

    fn confess(&mut self) {

        self.standing.shame += 10;

        self.leave_door();

    }

    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.household.mum else {

            return problem;

        };

        visit.strikes += 1;

        if visit.strikes < PATIENCE {

            return problem;

        }

        self.end(cause)

    }

    fn leave_door(&mut self) {

        self.household.mum = None;

        self.standing.suspicion = 0;

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

        self.touch();

    }

}