jelq

use std::collections::HashMap;

use axum::http::StatusCode;

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))

}

/// Why Mum came to the door, and how she leaves once she believes you.

#[derive(Clone, Copy)]

pub struct Errand {

    pub(crate) arrival: &'static str,

    pub(crate) knock: &'static str,

    pub(crate) parting: &'static str,

}

macro_rules! errand {

    ($knock:literal, $parting:literal) => {

        Errand {

            arrival: concat!("Mum is at the door. ", $knock),

            knock: $knock,

            parting: concat!("Mum seems satisfied. ", $parting),

        }

    };

}

pub const HEARD_A_NOISE: Errand = errand!("She heard a noise.", "It must have been the pipes.");

const VIRAL: Errand = errand!(

    "A neighbour has sent her something.",

    "She has decided not to open the attachment."

);

const BEDROOM_ERRANDS: [Errand; 4] = [

    errand!(

        "She has brought your washing.",

        "She leaves the washing on the chair."

    ),

    errand!(

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

        "There will be a plate in the oven."

    ),

    errand!(

        "She wants the wifi password.",

        "She has written the wifi password on her hand."

    ),

    errand!(

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

        "The future can wait until dinner."

    ),

];

const CHRISTMAS_ERRANDS: [Errand; 4] = [

    errand!(

        "Nan would like to see you.",

        "She tells Nan you are on your way."

    ),

    errand!(

        "Christmas dinner is in ten minutes.",

        "She will save you a pig in a blanket."

    ),

    errand!(

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

        "She will tell you what the King said."

    ),

    errand!(

        "An uncle has asked where you went.",

        "She tells the uncle you are helping in the kitchen."

    ),

];

#[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>,

    /// Set when the request now being answered sent Mum away, so the same turn cannot fetch her back.

    pub(crate) just_left: bool,

}

pub struct MumVisit {

    pub(crate) errand: Errand,

    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) -> Errand {

        if summoned {

            return 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 VIRAL;

        }

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

            CHRISTMAS_ERRANDS

        } else {

            BEDROOM_ERRANDS

        };

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

        let knocks = errands.map(|errand| errand.knock);

        let i = self.oracle.pick(

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

            &weights,

            &knocks,

        );

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

        self.household.just_left = false;

        if self.household.mum.is_none() {

            return Ok(());

        }

        match authorization {

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

            Some(authorization) => self.hear(authorization, self.floor == Floor::Nans),

        }

    }

    /// Sent on every response while she is at the door, so a client always holds the current nonce.

    pub fn mum_challenge(&self) -> Option<String> {

        let visit = self

            .household

            .mum

            .as_ref()

            .filter(|_| self.ended.is_none())?;

        Some(if self.floor == Floor::Nans {

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

        } else {

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

        })

    }

    /// 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.knock;

        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 {

            self.touch();

            return Err(turned_away(

                "stale-nonce",

                "That was a different conversation. Mum has started a new one, with a new nonce.",

            ));

        }

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

        if let Some(visit) = self.household.mum.take() {

            self.notices

                .push(Notice::MumSatisfied(visit.errand.parting));

            self.household.just_left = true;

        }

        self.standing.suspicion = 0;

        self.touch();

    }

}