jelq

use axum::{

    Json,

    http::{HeaderValue, StatusCode, header},

    response::{IntoResponse, Response},

};

use crate::game::{Outcome, Payload};

impl IntoResponse for Outcome {

    fn into_response(self) -> Response {

        let (status, payload, extra) = self.into_parts();

        let mut response = match payload {

            // RFC 9110 §15.3.7 obliges a 206 to be a byte range of the full representation, so it is.

            Payload::Json(body) if status == StatusCode::PARTIAL_CONTENT => {

                let full = body.to_string().into_bytes();

                let half = full.len() / 2;

                let range = format!("bytes 0-{}/{}", half.saturating_sub(1), full.len());

                (

                    status,

                    [

                        (header::CONTENT_TYPE, "application/json".to_owned()),

                        (header::CONTENT_RANGE, range),

                    ],

                    full[..half].to_vec(),

                )

                    .into_response()

            }

            Payload::Json(body) => (status, Json(body)).into_response(),

            Payload::Raw(content_type, body) => {

                (status, [(header::CONTENT_TYPE, content_type)], body).into_response()

            }

            Payload::Empty => status.into_response(),

        };

        let headers = response.headers_mut();

        for (name, value) in extra {

            if let Ok(value) = HeaderValue::from_str(&value) {

                headers.append(name, value);

            }

        }

        response

    }

}

pub fn respond<T: IntoResponse, E: IntoResponse>(result: Result<T, E>) -> Response {

    match result {

        Ok(ok) => ok.into_response(),

        Err(err) => err.into_response(),

    }

}