use cielago::model::{Method, variables_map};

use cielago::openapi::{import_spec, load_spec};

use cielago::store;

fn fixture_path(name: &str) -> String {

    format!("{}/tests/fixtures/{name}", env!("CARGO_MANIFEST_DIR"))

}

async fn import_fixture(name: &str, coll_name: &str) -> cielago::model::Collection {

    let doc = load_spec(&fixture_path(name)).await.unwrap();

    import_spec(&doc, coll_name, Some(fixture_path(name)))

}

#[tokio::test]

async fn imports_petstore_30() {

    let c = import_fixture("petstore30.yaml", "pets").await;

    assert_eq!(

        c.servers,

        vec![

            "https://api.pets.example.com/v1".to_string(),

            "https://staging.pets.example.com/v1".to_string()

        ]

    );

    // OAuth clientCredentials flow is detected and prefilled.

    let auth = c.auth.as_ref().expect("auth should be prefilled");

    assert_eq!(auth.token_url, "https://auth.pets.example.com/oauth/token");

    assert_eq!(auth.scopes, vec!["read:pets", "write:pets"]);

    assert!(auth.client_id.is_empty());

    assert_eq!(c.requests.len(), 4);

    let list = c.requests.iter().find(|r| r.name == "listPets").unwrap();

    assert_eq!(list.method, Method::Get);

    assert_eq!(list.path, "/pets");

    assert_eq!(list.tags, vec!["pets"]);

    // Optional query params are populated but disabled; defaults prefilled.

    let limit = list.query.iter().find(|q| q.key == "limit").unwrap();

    assert!(!limit.enabled);

    assert_eq!(limit.value, "20");

    let filter = list.query.iter().find(|q| q.key == "filter").unwrap();

    assert!(!filter.enabled);

    assert_eq!(filter.value, "");

    // Required header param is enabled with its example.

    let tenant = list

        .headers

        .iter()

        .find(|h| h.key == "X-Tenant-Id")

        .unwrap();

    assert!(tenant.enabled);

    assert_eq!(tenant.value, "acme");

    // Authored media-type example wins for the body.

    let create = c.requests.iter().find(|r| r.name == "createPet").unwrap();

    assert_eq!(create.method, Method::Post);

    let body = create.body.as_deref().unwrap();

    assert!(body.contains("\"name\": \"Fido\""), "body was: {body}");

    // $ref'd path parameter is resolved and its example prefilled.

    let get_pet = c.requests.iter().find(|r| r.name == "getPet").unwrap();

    assert_eq!(get_pet.path, "/pets/{petId}");

    let pet_id = get_pet

        .path_params

        .iter()

        .find(|p| p.key == "petId")

        .unwrap();

    assert!(pet_id.enabled);

    assert_eq!(pet_id.value, "123");

    // Summary used as name when operationId is absent; body generated from

    // schema, uuid format becomes the {{uuid}} variable.

    let order = c.requests.iter().find(|r| r.name == "Place order").unwrap();

    assert_eq!(order.tags, vec!["store"]);

    let body = order.body.as_deref().unwrap();

    assert!(body.contains("\"petId\": 1"), "body was: {body}");

    assert!(

        body.contains("\"requestId\": \"{{uuid}}\""),

        "body was: {body}"

    );

}

#[tokio::test]

async fn import_captures_docs_for_the_docs_tab() {

    let c = import_fixture("petstore30.yaml", "pets docs").await;

    let list = c.requests.iter().find(|r| r.name == "listPets").unwrap();

    assert_eq!(

        list.description.as_deref(),

        Some("Lists pets, newest first.")

    );

    let limit = list.docs.iter().find(|d| d.name == "limit").unwrap();

    assert_eq!(limit.location, "query");

    assert_eq!(limit.ty, "integer");

    assert!(!limit.required);

    assert_eq!(limit.default.as_deref(), Some("20"));

    assert_eq!(

        limit.description.as_deref(),

        Some("How many pets to return.")

    );

    // The options a field accepts are what the tab is for.

    let status = list.docs.iter().find(|d| d.name == "status").unwrap();

    assert_eq!(status.options, ["available", "pending", "sold"]);

    let tenant = list.docs.iter().find(|d| d.name == "X-Tenant-Id").unwrap();

    assert_eq!(tenant.location, "header");

    assert!(tenant.required);

    // $ref'd path parameter, documented through the reference.

    let get_pet = c.requests.iter().find(|r| r.name == "getPet").unwrap();

    let pet_id = get_pet.docs.iter().find(|d| d.name == "petId").unwrap();

    assert_eq!(pet_id.location, "path");

    assert_eq!(pet_id.ty, "integer(int64)");

    assert!(pet_id.required);

    // Body fields come from the request body schema, `required` included.

    let create = c.requests.iter().find(|r| r.name == "createPet").unwrap();

    let body: Vec<(&str, &str, bool)> = create

        .docs

        .iter()

        .filter(|d| d.location == "body")

        .map(|d| (d.name.as_str(), d.ty.as_str(), d.required))

        .collect();

    assert_eq!(

        body,

        [

            ("id", "integer(int64)", false),

            ("name", "string", true),

            ("tag", "string", false)

        ]

    );

    assert_eq!(

        create

            .docs

            .iter()

            .find(|d| d.name == "tag")

            .unwrap()

            .default

            .as_deref(),

        Some("friendly")

    );

    // Hand-made requests simply have none.

    assert!(cielago::model::SavedRequest::blank("x").docs.is_empty());

}

#[tokio::test]

async fn imports_31_json() {

    let c = import_fixture("api31.json", "things").await;

    assert_eq!(c.servers, vec!["https://things.example.com".to_string()]);

    assert_eq!(c.requests.len(), 1);

    let make = &c.requests[0];

    assert_eq!(make.name, "makeThing");

    let body = make.body.as_deref().unwrap();

    assert!(body.contains("\"label\": \"widget\""), "body was: {body}");

    assert!(body.contains("\"count\": 1"), "body was: {body}");

}

#[test]

fn summary_wins_over_operation_id_for_naming() {

    let doc = serde_json::json!({

        "paths": {

            "/v1/customers/{id}": {

                "get": {

                    "operationId": "CustomerControllerV1_retrieveCustomerById",

                    "summary": "Get customer",

                    "tags": ["customers"]

                }

            },

            "/v1/health": { "get": { "operationId": "healthCheck" } },

            "/v1/ping": { "get": {} }

        }

    });

    let c = import_spec(&doc, "svc", None);

    let cust = c

        .requests

        .iter()

        .find(|r| r.path.contains("customers"))

        .unwrap();

    assert_eq!(cust.name, "Get customer");

    assert_eq!(cust.summary.as_deref(), Some("Get customer"));

    assert_eq!(

        cust.operation_id.as_deref(),

        Some("CustomerControllerV1_retrieveCustomerById")

    );

    // operationId is the fallback when there's no summary.

    let health = c.requests.iter().find(|r| r.path == "/v1/health").unwrap();

    assert_eq!(health.name, "healthCheck");

    assert_eq!(health.summary, None);

    // Neither present: METHOD + path.

    let ping = c.requests.iter().find(|r| r.path == "/v1/ping").unwrap();

    assert_eq!(ping.name, "GET /v1/ping");

}

#[test]

fn label_mode_selects_the_displayed_text() {

    use cielago::model::LabelMode;

    let doc = serde_json::json!({

        "paths": {

            "/v1/customers/{id}": {

                "get": { "operationId": "CustomerControllerV1_get", "summary": "Get customer" }

            }

        }

    });

    let c = import_spec(&doc, "svc", None);

    let r = &c.requests[0];

    assert_eq!(r.label(LabelMode::Name), "Get customer");

    assert_eq!(r.label(LabelMode::Summary), "Get customer");

    assert_eq!(r.label(LabelMode::Path), "/v1/customers/{id}");

    // No summary: Summary mode falls back to the name rather than blanking.

    let mut bare = cielago::model::SavedRequest::blank("hand made");

    bare.path = "/thing".into();

    assert_eq!(bare.label(LabelMode::Summary), "hand made");

    assert_eq!(bare.label(LabelMode::Path), "/thing");

}

#[tokio::test]

async fn collection_survives_save_load_roundtrip() {

    let c = import_fixture("petstore30.yaml", "pets roundtrip").await;

    let dir = tempfile::tempdir().unwrap();

    let path = dir.path().join("coll.json");

    std::fs::write(&path, serde_json::to_string_pretty(&c).unwrap()).unwrap();

    let back = store::load_collection_path(&path.to_path_buf()).unwrap();

    assert_eq!(back.requests.len(), 4);

    assert_eq!(

        back.auth.unwrap().token_url,

        "https://auth.pets.example.com/oauth/token"

    );

}

#[tokio::test]

async fn update_replaces_routes_but_keeps_everything_else() {

    let mut c = import_fixture("petstore30.yaml", "pets").await;

    assert_eq!(c.requests.len(), 4);

    // User customisations that an update must preserve.

    c.variables

        .push(cielago::model::KeyValueRow::new("tenant", "acme", true));

    let auth = c.auth.as_mut().unwrap();

    auth.client_id = "my-id".into();

    auth.client_secret = "my-secret".into();

    c.active_server = 1;

    c.last_request = Some(c.requests[0].id);

    let servers = c.servers.clone();

    // Routes come from a different spec.

    let imported = import_fixture("api31.json", "pets").await;

    c.replace_requests_from(imported);

    // Requests were replaced wholesale by the new spec's...

    assert_eq!(c.requests.len(), 1);

    assert_eq!(c.requests[0].path, "/things");

    // ...and the now-stale selection pointer was dropped.

    assert!(c.last_request.is_none());

    // Everything else is exactly as the user left it.

    assert_eq!(c.servers, servers);

    assert_eq!(c.active_server, 1);

    let tenant = c.variables.iter().find(|v| v.key == "tenant").unwrap();

    assert_eq!(tenant.value, "acme");

    let auth = c.auth.as_ref().unwrap();

    assert_eq!(auth.token_url, "https://auth.pets.example.com/oauth/token");

    assert_eq!(auth.client_id, "my-id");

    assert_eq!(auth.client_secret, "my-secret");

}

#[test]

fn variables_map_respects_enabled() {

    let vars = vec![

        cielago::model::KeyValueRow::new("a", "1", true),

        cielago::model::KeyValueRow::new("b", "2", false),

        cielago::model::KeyValueRow::new("", "3", true),

    ];

    let map = variables_map(&vars);

    assert_eq!(map.get("a").unwrap(), "1");

    assert!(!map.contains_key("b"));

    assert!(!map.contains_key(""));

}