jelq

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

use serde_json::json;

use super::{

    Floor, Outcome, Run,

    credentials::{Scheme, etag_matches, parse_credentials},

    measure::{round2, volume},

};

use crate::{

    headers::{SERVER_TIMING, X_DIAGNOSIS},

    problem::Problem,

};

#[derive(Default)]

pub struct Clinic {

    pub(crate) intake_attempts: usize,

    pub(crate) measured: bool,

    pub(crate) prescribed: bool,

    pub(crate) cured: bool,

}

const INTAKE: [&str; 3] = [

    "The clinic does not accept excuses.",

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

    "Be honest.",

];

impl Run {

    pub fn diagnose(

        &mut self,

        authorization: Option<&str>,

        if_none_match: Option<&str>,

    ) -> Result<Outcome, Problem> {

        if self.floor != Floor::Clinic {

            let floors = Floor::Clinic.number() - self.floor.number();

            return Err(Problem::new(

                StatusCode::TOO_EARLY,

                "no-appointment",

                format!("The clinic's next available appointment is {floors} floors away."),

            ));

        }

        let intake = Problem::new(

            StatusCode::UNAUTHORIZED,

            "intake",

            "The clinic requires authorisation.",

        );

        let Some(authorization) = authorization else {

            return Err(intake.header(header::WWW_AUTHENTICATE, "Bearer realm=\"clinic\""));

        };

        let truthful = parse_credentials(authorization, Scheme::Bearer)

            .is_some_and(|token| token.eq_ignore_ascii_case("honesty"));

        if !truthful {

            let hint = INTAKE[self.clinic.intake_attempts.min(INTAKE.len() - 1)];

            self.clinic.intake_attempts += 1;

            return Err(intake.header(

                header::WWW_AUTHENTICATE,

                format!(

                    "Bearer realm=\"clinic\", error=\"invalid_token\", error_description=\"{hint}\""

                ),

            ));

        }

        self.body.conditions.peyronie = false;

        self.body.conditions.priapism_turns = 0;

        let etag = self.origin_etag();

        if if_none_match.is_some_and(|inm| etag_matches(inm, &etag)) {

            self.clinic.cured = true;

            return Ok(Outcome::empty(StatusCode::NOT_MODIFIED)

                .header(header::ETAG, etag)

                .header(X_DIAGNOSIS, "normal"));

        }

        if !self.clinic.measured {

            self.clinic.measured = true;

            if !self.items.kit.ruler {

                self.standing.shame += 15;

            }

        }

        let volume = volume(self.body.length, self.body.girth);

        let foreskin = self.body.foreskin.unwrap_or(0.0);

        let timing = format!(

            "length;dur={:.2}, girth;dur={:.2}, foreskin;dur={foreskin:.2}, volume;desc=\"cubic inches\";dur={volume:.2}",

            self.body.length, self.body.girth

        );

        self.clinic.prescribed = true;

        self.touch();

        Ok(Outcome::json(

            StatusCode::OK,

            json!({

                "diagnosis": "within normal range",

                "detail": "Congratulations. You have been cured of a condition you never had. The run is over.",

                "measured_length": round2(self.body.length),

                "measured_girth": round2(self.body.girth),

                "volume": round2(volume),

                "prescription": "Please stop.",

            }),

        )

        .header(header::ETAG, etag)

        .header(SERVER_TIMING, timing))

    }

}