jelq

use axum::http::StatusCode;

use serde::Deserialize;

use serde_json::{Value, json};

use super::{

    Outcome, Run,

    balance::{EXAGGERATION, HONEST_TOLERANCE, PATCH_EQ, PUT_GAIN},

};

use crate::problem::Problem;

pub fn round2(x: f64) -> f64 {

    (x * 100.0).round() / 100.0

}

pub(super) fn round3(x: f64) -> f64 {

    (x * 1000.0).round() / 1000.0

}

pub(super) fn honest(claimed: f64, actual: f64) -> bool {

    (claimed - actual).abs() < HONEST_TOLERANCE

}

/// A cylinder whose circumference is the girth.

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

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

}

pub fn shaft(mm: usize) -> String {

    format!("8{}D", "=".repeat(mm.saturating_sub(2)))

}

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

    Problem::new(

        StatusCode::BAD_REQUEST,

        "exaggeration",

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

    )

}

/// One JSON Patch operation as sent, before the server decides what it will honour.

#[derive(Deserialize)]

pub struct PatchOp {

    op: String,

    path: String,

    #[serde(default)]

    value: Value,

}

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

enum Measurement {

    Length,

    Girth,

    Foreskin,

}

struct Claim {

    measurement: Measurement,

    value: f64,

}

impl PatchOp {

    fn claim(&self) -> Result<Claim, Problem> {

        if self.op != "test" {

            return Err(Problem::new(

                StatusCode::UNPROCESSABLE_ENTITY,

                "wishful-thinking",

                "The server accepts only the truth.",

            )

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

        }

        let measurement = match self.path.as_str() {

            "/length" => Measurement::Length,

            "/girth" => Measurement::Girth,

            "/foreskin" => Measurement::Foreskin,

            _ => {

                return Err(Problem::new(

                    StatusCode::UNPROCESSABLE_ENTITY,

                    "no-such-measurement",

                    "There is no such measurement.",

                )

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

            }

        };

        let value = self.value.as_f64().ok_or_else(|| {

            Problem::new(

                StatusCode::BAD_REQUEST,

                "malformed-patch",

                "A test requires a numeric value.",

            )

        })?;

        Ok(Claim { measurement, value })

    }

}

impl Run {

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

        if self.body.put_applied {

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

        }

        self.body.put_applied = true;

        self.body.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.body.eq - PATCH_EQ);

        self.touch();

        for op in ops {

            let claim = op.claim()?;

            let actual = match claim.measurement {

                Measurement::Length => self.current_length(),

                Measurement::Girth => self.body.girth,

                Measurement::Foreskin => self.body.foreskin.unwrap_or(0.0),

            };

            if claim.measurement == Measurement::Length && claim.value >= actual + EXAGGERATION {

                self.standing.shame += 2;

                return Err(exaggeration());

            }

            if !honest(claim.value, actual) {

                self.standing.shame += 1;

                return Err(

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

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

                );

            }

        }

        Ok(Outcome::json(

            StatusCode::OK,

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

        ))

    }

}