jelq

use axum::{

    Json,

    http::{HeaderMap, HeaderName, HeaderValue, StatusCode, header},

    response::{IntoResponse, Response},

};

use serde_json::{Map, Value, json};

pub const PROBLEM_BASE: &str = "https://jelq.dev/problems/";

/// An RFC 9457 problem document.

pub struct Problem(Box<Inner>);

struct Inner {

    status: StatusCode,

    slug: &'static str,

    detail: String,

    extensions: Map<String, Value>,

    headers: HeaderMap,

}

impl Problem {

    pub fn new(status: StatusCode, slug: &'static str, detail: impl Into<String>) -> Self {

        Self(Box::new(Inner {

            status,

            slug,

            detail: detail.into(),

            extensions: Map::new(),

            headers: HeaderMap::new(),

        }))

    }

    pub fn slug(&self) -> &'static str {

        self.0.slug

    }

    pub fn status(&self) -> StatusCode {

        self.0.status

    }

    pub fn with(mut self, key: &str, value: impl Into<Value>) -> Self {

        self.0.extensions.insert(key.into(), value.into());

        self

    }

    pub fn document(&self) -> Map<String, Value> {

        let problem = &self.0;

        let mut body = Map::new();

        body.insert(

            "type".into(),

            json!(format!("{PROBLEM_BASE}{}", problem.slug)),

        );

        body.insert("title".into(), json!(reason(problem.status)));

        body.insert("status".into(), json!(problem.status.as_u16()));

        body.insert("detail".into(), json!(problem.detail));

        body.extend(problem.extensions.clone());

        body

    }

    pub fn header(mut self, name: HeaderName, value: impl AsRef<str>) -> Self {

        if let Ok(value) = HeaderValue::from_str(value.as_ref()) {

            self.0.headers.append(name, value);

        }

        self

    }

}

// The http crate still uses the RFC 7231 names for these.

pub fn reason(status: StatusCode) -> &'static str {

    match status.as_u16() {

        413 => "Content Too Large",

        422 => "Unprocessable Content",

        _ => status.canonical_reason().unwrap_or("Unknown"),

    }

}

impl IntoResponse for Problem {

    fn into_response(self) -> Response {

        let body = self.document();

        let problem = *self.0;

        let mut response = (problem.status, Json(body)).into_response();

        let headers = response.headers_mut();

        headers.insert(

            header::CONTENT_TYPE,

            HeaderValue::from_static("application/problem+json"),

        );

        for (name, value) in &problem.headers {

            headers.append(name, value.clone());

        }

        response

    }

}