jelq

use axum::http::StatusCode;

use serde::Deserialize;

use serde_json::{Value, json};

use super::{

    Grip, Outcome, Run,

    balance::{EXAGGERATION, GIRTH_RESPECTED, GIRTH_THICK, LOCKER_ROOM_BAR, PATCH_EQ, PUT_GAIN},

    etag_matches, honest,

};

use crate::problem::Problem;

#[derive(Deserialize)]

pub struct PatchOp {

    pub op: String,

    pub path: String,

    #[serde(default)]

    pub value: Value,

}

pub(super) fn exaggeration() -> Problem {

    Problem::new(

        StatusCode::BAD_REQUEST,

        "exaggeration",

        "The server has measured. Lying is not a technique.",

    )

}

impl Run {

    pub fn put(&mut self) -> Outcome {

        if self.put_applied {

            return Outcome::empty(StatusCode::NO_CONTENT);

        }

        self.put_applied = true;

        self.length += PUT_GAIN;

        self.touch();

        Outcome::json(StatusCode::OK, json!({ "detail": "Applied." }))

    }

    /// Being measured is not arousing, so every PATCH costs a little EQ whatever it finds.

    pub fn patch(&mut self, ops: &[PatchOp]) -> Result<Outcome, Problem> {

        self.reset_eq(self.eq - PATCH_EQ);

        self.touch();

        for op in ops {

            if op.op != "test" {

                return Err(Problem::new(

                    StatusCode::UNPROCESSABLE_ENTITY,

                    "wishful-thinking",

                    "The server accepts only the truth.",

                )

                .with("op", op.op.clone()));

            }

            let actual = match op.path.as_str() {

                "/length" => self.current_length(),

                "/girth" => self.girth,

                "/foreskin" => self.foreskin.unwrap_or(0.0),

                _ => {

                    return Err(Problem::new(

                        StatusCode::UNPROCESSABLE_ENTITY,

                        "no-such-measurement",

                        "There is no such measurement.",

                    )

                    .with("path", op.path.clone()));

                }

            };

            let Some(claimed) = op.value.as_f64() else {

                return Err(Problem::new(

                    StatusCode::BAD_REQUEST,

                    "malformed-patch",

                    "A test requires a numeric value.",

                ));

            };

            if op.path == "/length" && claimed >= actual + EXAGGERATION {

                self.shame += 2;

                self.touch();

                return Err(exaggeration());

            }

            if !honest(claimed, actual) {

                self.shame += 1;

                self.touch();

                return Err(

                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")

                        .with("path", op.path.clone()),

                );

            }

        }

        Ok(Outcome::json(

            StatusCode::OK,

            json!({ "detail": "Correct." }),

        ))

    }

    pub fn delete_foreskin(&mut self, if_match: Option<&str>) -> Result<Outcome, Problem> {

        if self.foreskin.is_none() {

            return Err(Problem::new(

                StatusCode::GONE,

                "foreskin-gone",

                "The foreskin is gone. It will not be returning.",

            ));

        }

        let Some(if_match) = if_match else {

            return Err(Problem::new(

                StatusCode::PRECONDITION_REQUIRED,

                "confirmation-required",

                "The server requires you to be sure. Send If-Match.",

            ));

        };

        if !etag_matches(if_match, &self.etag()) {

            return Err(Problem::new(

                StatusCode::PRECONDITION_FAILED,

                "stale-foreskin",

                "The foreskin has changed since you last looked at it.",

            ));

        }

        self.foreskin = None;

        self.shame += 20;

        self.touch();

        Ok(Outcome::empty(StatusCode::NO_CONTENT))

    }

    pub fn set_grip(&mut self, grip: Grip) -> Result<(), Problem> {

        self.grip_closes(grip)?;

        self.grip = grip;

        self.touch();

        Ok(())

    }

    pub(super) fn grip_closes(&self, grip: Grip) -> Result<(), Problem> {

        if grip == Grip::Underhand && self.girth > GIRTH_THICK {

            return Err(Problem::new(

                StatusCode::PAYLOAD_TOO_LARGE,

                "grip-too-small",

                format!(

                    "The underhand grip no longer closes around {:.2} inches of girth.",

                    self.girth

                ),

            )

            .with("maximum", GIRTH_THICK));

        }

        Ok(())

    }

    /// Everyone in the changing room self-reports, so the comparison is self-report against self-report.

    pub fn holds_own_in_the_locker_room(&self) -> bool {

        self.self_reported() >= LOCKER_ROOM_BAR

    }

    pub fn girth_respected(&self) -> bool {

        self.girth >= GIRTH_RESPECTED

    }

}

/// A cylinder whose circumference is the girth.

pub fn volume(length: f64, girth: f64) -> f64 {

    girth * girth * length / (4.0 * std::f64::consts::PI)

}