jelq

use axum::http::StatusCode;

use serde::Deserialize;

use serde_json::{Value, json};

use super::{

    Grip, Outcome, Run,

    balance::{EXAGGERATION, 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." }))

    }

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

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

        self.grip = grip;

        self.touch();

    }

}