jelq

mod body;

mod floors;

mod household;

mod meta;

mod methods;

mod rolls;

mod turns;

pub use std::{sync::Arc, time::Duration};

pub use axum::{

    Router,

    body::{Body, to_bytes},

    http::{Method, Request, StatusCode, Version, header},

    response::Response,

};

pub use serde_json::Value;

use tower::ServiceExt;

pub use crate::{

    AppState, Config,

    game::{

        Excuse, Floor, MumVisit, Run, Story,

        balance::{BRANCH_TURN, SUSPICION_LIMIT},

    },

    router,

};

pub const SEED: u64 = 420;

pub async fn send(

    app: &Router,

    method: &str,

    uri: &str,

    headers: &[(&str, &str)],

    body: &str,

) -> Response {

    let mut request = Request::builder()

        .method(Method::from_bytes(method.as_bytes()).unwrap())

        .uri(uri);

    for (name, value) in headers {

        request = request.header(*name, *value);

    }

    app.clone()

        .oneshot(request.body(Body::from(body.to_owned())).unwrap())

        .await

        .unwrap()

}

pub async fn json(response: Response) -> Value {

    serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap()

}

pub async fn text(response: Response) -> String {

    String::from_utf8(

        to_bytes(response.into_body(), usize::MAX)

            .await

            .unwrap()

            .to_vec(),

    )

    .unwrap()

}

pub fn header<'a>(response: &'a Response, name: &str) -> &'a str {

    response.headers()[name].to_str().unwrap()

}

/// Every `Warning` on a response, since a turn can carry several.

pub fn warnings(response: &Response) -> Vec<String> {

    response

        .headers()

        .get_all("warning")

        .iter()

        .map(|value| value.to_str().unwrap().to_owned())

        .collect()

}

/// A server holding one run, `cafebabe`, set up by `setup` before anyone can reach it.

pub struct Harness {

    pub app: Router,

    pub origin: String,

    pub state: Arc<AppState>,

}

impl Harness {

    /// The EQ of `cafebabe`, which `X-EQ` only names.

    pub fn eq(&self) -> i32 {

        self.state.inspect(|run| run.body.eq)[0]

    }

}

pub fn harness(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Harness {

    let state = Arc::new(AppState::default());

    let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);

    run.floor = floor;

    setup(&mut run);

    let origin = run.origin_etag();

    state.insert(run);

    Harness {

        app: router(state.clone()),

        origin,

        state,

    }

}

pub fn seeded_with(floor: Floor, setup: impl FnOnce(&mut Run)) -> Router {

    harness(floor, SEED, setup).app

}

pub fn app_with(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Router {

    harness(floor, seed, setup).app

}

pub fn app() -> Router {

    crate::app(Config::default()).unwrap()

}

pub fn mum_at_the_door(run: &mut Run) {

    run.household.mum = Some(MumVisit {

        errand: crate::game::HEARD_A_NOISE,

        nonce: "abc".into(),

        strikes: 0,

        knocked: false,

    });

}

/// The `Link` entries on a response, as `(rel, title)` with the rel base stripped.

pub fn links(response: &Response) -> Vec<(String, Option<String>)> {

    header(response, "link")

        .split(", <")

        .filter_map(|entry| {

            let rel = entry.split("rels/").nth(1)?.split('"').next()?.to_owned();

            let title = entry

                .split("title=\"")

                .nth(1)

                .and_then(|t| t.split('"').next())

                .map(str::to_owned);

            Some((rel, title))

        })

        .collect()

}

pub fn advertised(response: &Response) -> Vec<String> {

    links(response)

        .into_iter()

        .filter(|(rel, _)| rel == "technique")

        .filter_map(|(_, title)| title)

        .collect()

}

pub fn linked_rels(response: &Response) -> Vec<String> {

    links(response)

        .into_iter()

        .map(|(rel, _)| rel)

        .filter(|rel| rel != "technique")

        .collect()

}