//! Decompose a URL typed or pasted into the URL bar. This is the inverse of

//! [`super::client`]'s `build_url`: that composes `base + path + query` into a

//! request, this splits a pasted URL back into the pieces a

//! [`crate::model::SavedRequest`] stores.

use url::Url;

use crate::model::KeyValueRow;

/// The pieces a URL-bar entry decomposes into.

#[derive(Debug, Clone, Default, PartialEq, Eq)]

pub struct UrlParts {

    /// Origin (`scheme://host[:port]`) when an absolute http(s) URL was pasted;

    /// `None` for a bare path, which is what the field normally holds.

    pub origin: Option<String>,

    /// Always leading-slash (or a `{{var}}` template), relative to `origin`.

    pub path: String,

    /// `None` when the input had no `?` at all, meaning "leave the existing

    /// query rows alone"; `Some(rows)` when it did, even if empty — a bare `?`

    /// clears them.

    pub query: Option<Vec<KeyValueRow>>,

}

pub fn split_url_input(input: &str) -> UrlParts {

    let input = input.trim();

    if input.is_empty() {

        return UrlParts {

            origin: None,

            path: "/".into(),

            query: None,

        };

    }

    // `Url::parse` succeeds for anything with a scheme, including nonsense like

    // `localhost:8080/pets` (scheme `localhost`, path `8080/pets`), so the

    // scheme and host checks are load-bearing rather than cosmetic.

    if let Ok(u) = Url::parse(input)

        && matches!(u.scheme(), "http" | "https")

        && u.host().is_some()

    {

        return UrlParts {

            origin: Some(u.origin().ascii_serialization()),

            path: restore_braces(u.path()),

            query: u.query().map(parse_query),

            // The fragment is deliberately dropped: it is never sent to a server.

        };

    }

    let no_fragment = input.split_once('#').map_or(input, |(head, _)| head);

    let (path, query) = match no_fragment.split_once('?') {

        Some((p, q)) => (p, Some(parse_query(q))),

        None => (no_fragment, None),

    };

    // `{{baseUrl}}/pets` is a template, not a relative path — leave it verbatim.

    let path = if path.is_empty() {

        "/".to_string()

    } else if path.starts_with('/') || path.starts_with("{{") {

        path.to_string()

    } else {

        format!("/{path}")

    };

    UrlParts {

        origin: None,

        path,

        query,

    }

}

/// Undo the `url` crate's percent-encoding of `{` and `}`, which are in its

/// path encode set — so `/pets/{id}` comes back as `/pets/%7Bid%7D` and would

/// break both `{pathParam}` replacement and `{{variable}}` substitution. Only

/// the braces are restored; a blanket decode would corrupt segments the user

/// percent-encoded on purpose.

fn restore_braces(s: &str) -> String {

    s.replace("%7B", "{")

        .replace("%7b", "{")

        .replace("%7D", "}")

        .replace("%7d", "}")

}

/// Query string to enabled rows. Values are decoded here and re-encoded by

/// `build_url`'s `.query(&pairs)`, so they round-trip.

fn parse_query(raw: &str) -> Vec<KeyValueRow> {

    url::form_urlencoded::parse(raw.as_bytes())

        .map(|(k, v)| KeyValueRow::new(k.as_ref(), v.as_ref(), true))

        .filter(|r| !r.key.is_empty())

        .collect()

}

#[cfg(test)]

mod tests {

    use super::*;

    fn rows(parts: &UrlParts) -> Vec<(String, String)> {

        parts

            .query

            .as_ref()

            .map(|q| q.iter().map(|r| (r.key.clone(), r.value.clone())).collect())

            .unwrap_or_default()

    }

    #[test]

    fn splits_a_full_url() {

        let p = split_url_input("https://api.example.com/v1/pets?limit=10");

        assert_eq!(p.origin.as_deref(), Some("https://api.example.com"));

        assert_eq!(p.path, "/v1/pets");

        assert_eq!(rows(&p), vec![("limit".to_string(), "10".to_string())]);

    }

    #[test]

    fn bare_path_has_no_origin() {

        let p = split_url_input("/v1/pets");

        assert_eq!(p.origin, None);

        assert_eq!(p.path, "/v1/pets");

        assert_eq!(p.query, None);

    }

    #[test]

    fn relative_path_gains_a_leading_slash() {

        assert_eq!(split_url_input("pets/42").path, "/pets/42");

    }

    #[test]

    fn host_with_port_and_no_scheme_is_relative() {

        // `Url::parse` accepts this with scheme "localhost"; we must not.

        let p = split_url_input("localhost:8080/pets");

        assert_eq!(p.origin, None);

        assert_eq!(p.path, "/localhost:8080/pets");

    }

    #[test]

    fn keeps_brace_placeholders_unencoded() {

        let p = split_url_input("https://api.example.com/pets/{petId}/photos");

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

    }

    #[test]

    fn keeps_double_brace_variables_in_a_relative_path() {

        let p = split_url_input("{{prefix}}/pets");

        assert_eq!(p.origin, None);

        assert_eq!(p.path, "{{prefix}}/pets");

    }

    #[test]

    fn drops_the_fragment() {

        assert_eq!(

            split_url_input("https://api.example.com/pets#section").path,

            "/pets"

        );

        assert_eq!(split_url_input("/pets#section").path, "/pets");

        assert_eq!(split_url_input("/pets?a=1#section").path, "/pets");

        assert_eq!(

            rows(&split_url_input("/pets?a=1#section")),

            vec![("a".to_string(), "1".to_string())]

        );

    }

    #[test]

    fn empty_input_becomes_root_path() {

        let p = split_url_input("   ");

        assert_eq!(p.path, "/");

        assert_eq!(p.origin, None);

        assert_eq!(p.query, None);

    }

    #[test]

    fn absent_question_mark_leaves_query_none() {

        assert_eq!(split_url_input("https://api.example.com/pets").query, None);

        assert_eq!(split_url_input("/pets").query, None);

    }

    #[test]

    fn bare_question_mark_clears_the_query() {

        assert_eq!(split_url_input("/pets?").query, Some(Vec::new()));

        assert_eq!(

            split_url_input("https://api.example.com/pets?").query,

            Some(Vec::new())

        );

    }

    #[test]

    fn decodes_query_values() {

        let p = split_url_input("/search?q=hello%20world&tag=a%2Bb");

        assert_eq!(

            rows(&p),

            vec![

                ("q".to_string(), "hello world".to_string()),

                ("tag".to_string(), "a+b".to_string()),

            ]

        );

    }

    #[test]

    fn default_ports_are_dropped_from_the_origin() {

        assert_eq!(

            split_url_input("https://api.example.com:443/pets")

                .origin

                .as_deref(),

            Some("https://api.example.com")

        );

        assert_eq!(

            split_url_input("http://localhost:8080/pets")

                .origin

                .as_deref(),

            Some("http://localhost:8080")

        );

    }

    #[test]

    fn query_rows_are_enabled_and_skip_empty_keys() {

        let p = split_url_input("/pets?a=1&=2&b");

        let q = p.query.unwrap();

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

        assert!(q.iter().all(|r| r.enabled));

        assert_eq!(q[1].key, "b");

        assert_eq!(q[1].value, "");

    }

}