jelq

use std::convert::Infallible;

use axum::{

    body::{Body, Bytes},

    http::{StatusCode, header},

    response::{IntoResponse, Response},

};

use super::ctx::Ctx;

use crate::{

    game::{Run, balance::MM_PER_INCH, shaft},

    problem::Problem,

};

const SHAFT_CHUNK: usize = 16;

const SHAFT_TYPE: &str = "text/plain; charset=us-ascii";

const RANGE_UNIT: &str = "inches";

pub(super) fn millimetres(inches: f64) -> usize {

    (inches * MM_PER_INCH).round() as usize

}

pub(super) enum InchRange {

    Satisfiable(f64, f64),

    Unsatisfiable,

}

/// `None` means the header is not a valid range, which RFC 9110 §14.2 says to ignore rather than refuse.

pub(super) fn parse_inch_range(range: &str, total: f64) -> Option<InchRange> {

    let (start, end) = range.strip_prefix("inches=")?.split_once('-')?;

    let number = |text: &str| {

        text.parse::<f64>()

            .ok()

            .filter(|n| n.is_finite() && *n >= 0.0)

    };

    let (start, end) = match (start.trim(), end.trim()) {

        ("", "") => return None,

        ("", suffix) => ((total - number(suffix)?).max(0.0), total),

        (start, "") => (number(start)?, total),

        (start, end) => {

            let (start, end) = (number(start)?, number(end)?);

            if start > end {

                return None;

            }

            (start, end)

        }

    };

    Some(if start < total {

        InchRange::Satisfiable(start, end.min(total))

    } else {

        InchRange::Unsatisfiable

    })

}

pub(super) fn unsatisfied_range(inches: f64) -> Response {

    Problem::new(

        StatusCode::RANGE_NOT_SATISFIABLE,

        "range-not-satisfiable",

        format!("The requested range is not available. {inches:.2} inches are."),

    )

    .header(header::CONTENT_RANGE, format!("inches */{inches:.2}"))

    .into_response()

}

pub(super) fn partial_inches(

    body: &str,

    offset: usize,

    start: f64,

    end: f64,

    total: f64,

) -> Response {

    let from = (millimetres(start) + offset).min(body.len() - 1);

    let to = (millimetres(end) + offset).clamp(from + 1, body.len());

    (

        StatusCode::PARTIAL_CONTENT,

        [

            (header::CONTENT_TYPE, SHAFT_TYPE.to_owned()),

            (header::ACCEPT_RANGES, RANGE_UNIT.to_owned()),

            (

                header::CONTENT_RANGE,

                format!("inches {start:.2}-{end:.2}/{total:.2}"),

            ),

        ],

        body[from..to].to_owned(),

    )

        .into_response()

}

pub(super) fn get_length(run: &mut Run, ctx: &Ctx) -> Response {

    let inches = run.shown_length();

    let body = shaft(millimetres(inches));

    let content_type = (header::CONTENT_TYPE, SHAFT_TYPE.to_owned());

    let accept_ranges = (header::ACCEPT_RANGES, RANGE_UNIT.to_owned());

    if let Some(range) = ctx

        .header(header::RANGE)

        .and_then(|range| parse_inch_range(range, inches))

    {

        match range {

            InchRange::Satisfiable(start, end) => {

                return partial_inches(&body, 0, start, end, inches);

            }

            InchRange::Unsatisfiable => return unsatisfied_range(inches),

        }

    }

    if run.measured() {

        return (StatusCode::OK, [content_type, accept_ranges], body).into_response();

    }

    let chunks: Vec<Result<Bytes, Infallible>> = body

        .into_bytes()

        .chunks(SHAFT_CHUNK)

        .map(|c| Ok(Bytes::copy_from_slice(c)))

        .collect();

    let body = Body::from_stream(futures_util::stream::iter(chunks));

    (StatusCode::OK, [content_type, accept_ranges], body).into_response()

}

pub(super) fn get_foreskin(run: &mut Run, ctx: &Ctx) -> Response {

    let Some(inches) = run.foreskin() else {

        return Problem::new(

            StatusCode::GONE,

            "foreskin-gone",

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

        )

        .into_response();

    };

    let body = format!("8({})D", "~".repeat(millimetres(inches)));

    if let Some(range) = ctx

        .header(header::RANGE)

        .and_then(|range| parse_inch_range(range, inches))

    {

        match range {

            InchRange::Satisfiable(start, end) => {

                return partial_inches(&body, 2, start, end, inches);

            }

            InchRange::Unsatisfiable => return unsatisfied_range(inches),

        }

    }

    (

        StatusCode::OK,

        [

            (header::ETAG, run.etag()),

            (header::CONTENT_TYPE, SHAFT_TYPE.to_owned()),

            (header::ACCEPT_RANGES, RANGE_UNIT.to_owned()),

        ],

        body,

    )

        .into_response()

}