use axum::http::{self, Request, StatusCode};
use echo::{
    app,
    messages::{Message, MessageBody},
};
use http_body_util::BodyExt;
use serde_json::{json, Value};
use tower::{Service, ServiceExt};

#[tokio::test]
async fn test_single() {
    let app = app().into_service();

    let response = {
        let request: Message = {
            let src = "c1".to_string();
            let dest = "n1".to_string();
            let body = {
                let msg_id = 1;

                MessageBody::Generate { msg_id }
            };
            Message { src, dest, body }
        };

        let response = app
            .oneshot(
                Request::builder()
                    .method(http::Method::POST)
                    .uri("/")
                    .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
                    .body(serde_json::to_string(&request).unwrap())
                    .unwrap(),
            )
            .await
            .unwrap();

        assert_eq!(response.status(), StatusCode::OK);
        response
    };

    {
        let body: Value = {
            let body = response.into_body().collect().await.unwrap().to_bytes();
            serde_json::from_slice(&body).unwrap()
        };

        let expected = json!(
            {
                "src": "n1",
                "dest": "c1",
                "body": {
                    "type": "generate_ok",
                    "msg_id": 1,
                    "in_reply_to": 1,
                    "id": 0
                }
            }
        );

        assert_eq!(body, expected);
    }
}

#[tokio::test]
async fn test_multiple() {
    let mut app = app().into_service();
    let request_count = 3;

    let response = {
        for i in 0..request_count {
            let request: Message = {
                let src = "c1".to_string();
                let dest = "n1".to_string();
                let body = {
                    let msg_id = i;

                    MessageBody::Generate { msg_id }
                };
                Message { src, dest, body }
            };

            let request = Request::builder()
                .method(http::Method::POST)
                .uri("/")
                .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
                .body(serde_json::to_string(&request).unwrap())
                .unwrap();

            let response = ServiceExt::<Request<String>>::ready(&mut app)
                .await
                .unwrap()
                .call(request)
                .await
                .unwrap();

            assert_eq!(response.status(), StatusCode::OK);
        }

        let request: Message = {
            let src = "c1".to_string();
            let dest = "n1".to_string();
            let body = {
                let msg_id = request_count;

                MessageBody::Generate { msg_id }
            };
            Message { src, dest, body }
        };

        let request = Request::builder()
            .method(http::Method::POST)
            .uri("/")
            .header(http::header::CONTENT_TYPE, mime::APPLICATION_JSON.as_ref())
            .body(serde_json::to_string(&request).unwrap())
            .unwrap();

        let response = ServiceExt::<Request<String>>::ready(&mut app)
            .await
            .unwrap()
            .call(request)
            .await
            .unwrap();

        assert_eq!(response.status(), StatusCode::OK);
        response
    };

    {
        let body: Value = {
            let body = response.into_body().collect().await.unwrap().to_bytes();
            serde_json::from_slice(&body).unwrap()
        };

        let expected = json!(
            {
                "src": "n1",
                "dest": "c1",
                "body": {
                    "type": "generate_ok",
                    "msg_id": request_count,
                    "in_reply_to": request_count,
                    "id": request_count
                }
            }
        );

        assert_eq!(body, expected);
    }
}