//! End-to-end: TUI action → async send task → response/token state update.

use std::path::PathBuf;

use cielago::app::App;

use cielago::model::{Collection, KeyValueRow, Method, OAuthConfig, SavedRequest};

use cielago::store::AppConfig;

use wiremock::matchers::{method, path};

use wiremock::{Mock, MockServer, ResponseTemplate};

fn app_with(base_url: String) -> App {

    let mut c = Collection::new("test");

    c.servers = vec![base_url];

    let mut req = SavedRequest::blank("get thing");

    req.method = Method::Get;

    req.path = "/things/1".into();

    req.headers

        .push(KeyValueRow::new("X-Request-Id", "{{uuid}}", true));

    c.requests = vec![req];

    App::new(

        c,

        PathBuf::from("/tmp/cielago-test.json"),

        AppConfig::default(),

    )

}

#[tokio::test]

async fn send_from_app_updates_response_pane() {

    let server = MockServer::start().await;

    Mock::given(method("GET"))

        .and(path("/things/1"))

        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({"id": 1})))

        .mount(&server)

        .await;

    let mut app = app_with(server.uri());

    assert!(app.response.is_none());

    app.send_selected();

    assert!(app.sending);

    let outcome = app.rx.recv().await.expect("send outcome");

    app.handle_outcome(outcome);

    assert!(!app.sending);

    let resp = app.response.as_ref().expect("response recorded");

    assert_eq!(resp.status, 200);

    assert!(resp.body.contains("\"id\": 1"));

    assert!(app.status.contains("200"));

    // {{uuid}} was substituted in the outgoing header.

    let received = server.received_requests().await.unwrap();

    let id = received[0]

        .headers

        .get("x-request-id")

        .unwrap()

        .to_str()

        .unwrap();

    assert!(uuid::Uuid::parse_str(id).is_ok(), "got {id}");

}

#[test]

fn url_input_leading_verb_sets_method() {

    let mut app = app_with("http://example.com".into());

    app.select_request(0);

    // A leading verb sets the method and is stripped from the path.

    app.apply_url_input("post /pets");

    assert_eq!(app.collection.requests[0].method, Method::Post);

    assert_eq!(app.collection.requests[0].path, "/pets");

    // A bare path leaves the method untouched.

    app.apply_url_input("/pets/1");

    assert_eq!(app.collection.requests[0].method, Method::Post);

    assert_eq!(app.collection.requests[0].path, "/pets/1");

    // A lone verb with no remainder is a path, not a method.

    app.apply_url_input("delete");

    assert_eq!(app.collection.requests[0].method, Method::Post);

    assert_eq!(app.collection.requests[0].path, "/delete");

}

#[tokio::test]

async fn send_with_oauth_fetches_and_caches_token() {

    let server = MockServer::start().await;

    Mock::given(method("POST"))

        .and(path("/token"))

        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({

            "access_token": "cached-tok",

            "expires_in": 3600

        })))

        .expect(1) // fetched once, then cached

        .mount(&server)

        .await;

    Mock::given(method("GET"))

        .and(path("/things/1"))

        .respond_with(ResponseTemplate::new(200))

        .expect(2)

        .mount(&server)

        .await;

    let mut app = app_with(server.uri());

    app.collection.auth = Some(OAuthConfig {

        token_url: format!("{}/token", server.uri()),

        client_id: "id".into(),

        client_secret: "secret".into(),

        scopes: vec![],

        auth_style: cielago::model::AuthStyle::Basic,

        ..Default::default()

    });

    // First send: fetches a token.

    app.send_selected();

    let outcome = app.rx.recv().await.unwrap();

    app.handle_outcome(outcome);

    assert_eq!(app.response.as_ref().unwrap().status, 200);

    assert!(app.token.is_some());

    // Second send: reuses the cached token (token endpoint expect(1)).

    app.send_selected();

    let outcome = app.rx.recv().await.unwrap();

    app.handle_outcome(outcome);

    assert_eq!(app.response.as_ref().unwrap().status, 200);

    // Both API calls carried the bearer token.

    let received = server.received_requests().await.unwrap();

    let api_calls: Vec<_> = received

        .iter()

        .filter(|r| r.url.path() == "/things/1")

        .collect();

    assert_eq!(api_calls.len(), 2);

    for r in api_calls {

        assert_eq!(

            r.headers.get("authorization").unwrap().to_str().unwrap(),

            "Bearer cached-tok"

        );

    }

}

#[tokio::test]

async fn send_without_server_shows_status_error() {

    let mut app = app_with("".into());

    app.collection.servers.clear();

    app.send_selected();

    assert!(!app.sending);

    assert!(app.status.contains("No server configured"));

}

// After naming a new request, the flow chains into the URL edit prefilled

// with the default method so `GET ` is shown awaiting a route.

#[test]

fn new_request_chains_to_url_prefilled_with_method() {

    let mut app = app_with("http://example.com".into());

    app.start_edit(cielago::app::EditTarget::NewRequest);

    app.input.set("make thing");

    app.commit_edit();

    assert_eq!(app.editing, Some(cielago::app::EditTarget::Url));

    assert_eq!(app.input.buf, "GET ");

}