use assert2::let_assert;
//
use kxio::net::{Error, MatchOn, Net};

#[tokio::test]
async fn test_get_url() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client.get(url).build().expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("Get OK")
        .expect("request body");

    net.on(request)
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    let response = Net::from(net)
        .send(client.get(url))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "Get OK");
}

#[tokio::test]
async fn test_get_wrong_url() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client.get(url).build().expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("Get OK")
        .expect("request body");

    net.on(request)
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    let_assert!(
        Err(Error::UnexpectedMockRequest(invalid_request)) =
            net.send(client.get("https://some.other.url/")).await
    );

    //then
    assert_eq!(invalid_request.url().to_string(), "https://some.other.url/");

    // remove pending unmatched request - we never meant to match against it
    net.reset().expect("reset");
}

#[tokio::test]
async fn test_post_url() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client.post(url).build().expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("Post OK")
        .expect("request body");

    net.on(request)
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    let response = Net::from(net)
        .send(client.post(url))
        .await
        .expect("reponse");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "Post OK");
}

#[tokio::test]
async fn test_post_by_method() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client.post(url).build().expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("Post OK")
        .expect("request body");

    net.on(request)
        .match_on(vec![
            MatchOn::Method,
            // MatchOn::Url
        ])
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    // This request is a different url - but should still match
    let response = Net::from(net)
        .send(client.post("https://some.other.url"))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "Post OK");
}

#[tokio::test]
async fn test_post_by_url() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client.post(url).build().expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("Post OK")
        .expect("request body");

    net.on(request)
        .match_on(vec![
            // MatchOn::Method,
            MatchOn::Url,
        ])
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    // This request is a GET, not POST - but should still match
    let response = Net::from(net)
        .send(client.get(url))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(response.bytes().await.expect("response body"), "Post OK");
}

#[tokio::test]
async fn test_post_by_body() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client
        .post(url)
        .body("match on body")
        .build()
        .expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("response body")
        .expect("request body");

    net.on(request)
        .match_on(vec![
            // MatchOn::Method,
            // MatchOn::Url
            MatchOn::Body,
        ])
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    // This request is a GET, not POST - but should still match
    let response = Net::from(net)
        .send(client.get("https://some.other.url").body("match on body"))
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("response body"),
        "response body"
    );
}

#[tokio::test]
async fn test_post_by_headers() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client
        .post(url)
        .body("foo")
        .header("test", "match")
        .build()
        .expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("response body")
        .expect("request body");

    net.on(request)
        .match_on(vec![
            // MatchOn::Method,
            // MatchOn::Url
            MatchOn::Headers,
        ])
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    // This request is a GET, not POST - but should still match
    let response = Net::from(net)
        .send(
            client
                .get("https://some.other.url")
                .body("match on body")
                .header("test", "match"),
        )
        .await
        .expect("response");

    //then
    assert_eq!(response.status(), http::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("response body"),
        "response body"
    );
}

#[tokio::test]
#[should_panic]
async fn test_unused_post() {
    //given
    let net = kxio::net::mock();
    let client = net.client();

    let url = "https://www.example.com";
    let request = client.post(url).build().expect("build request");
    let my_response = net
        .response()
        .status(200)
        .body("Post OK")
        .expect("request body");

    net.on(request)
        .respond(my_response.into())
        .expect("on request, respond");

    //when
    // don't send the planned request
    // let _response = Net::from(net).send(client.post(url)).await.expect("send");

    //then
    // Drop implementation for net should panic
}