//! Building and sending a [`SavedRequest`], and capturing the response.

use std::collections::HashMap;

use std::time::{Duration, Instant};

use anyhow::{Context, Result, anyhow};

use reqwest::header::{AUTHORIZATION, CONTENT_TYPE, HeaderMap, HeaderName, HeaderValue};

use super::vars::substitute;

use crate::model::{Method, SavedRequest};

#[derive(Debug, Clone)]

pub struct HttpResponse {

    pub status: u16,

    pub reason: String,

    pub elapsed: Duration,

    pub headers: Vec<(String, String)>,

    pub body: String,

    pub size: usize,

}

impl HttpResponse {

    pub fn status_line(&self) -> String {

        let ms = self.elapsed.as_millis();

        format!(

            "{} {} · {}ms · {}",

            self.status,

            self.reason,

            ms,

            human_size(self.size)

        )

    }

}

fn human_size(n: usize) -> String {

    if n < 1024 {

        format!("{n}B")

    } else if n < 1024 * 1024 {

        format!("{:.1}kB", n as f64 / 1024.0)

    } else {

        format!("{:.1}MB", n as f64 / 1024.0 / 1024.0)

    }

}

/// Send a request against `base_url`, applying `{{variable}}` substitution and

/// `{pathParam}` replacement. `bearer`, when present, sets the Authorization

/// header unless the request already defines one.

pub async fn send_request(

    client: &reqwest::Client,

    base_url: &str,

    req: &SavedRequest,

    vars: &HashMap<String, String>,

    bearer: Option<&str>,

) -> Result<HttpResponse> {

    let url = build_url(base_url, req, vars);

    let mut headers = HeaderMap::new();

    let mut has_auth = false;

    let mut has_content_type = false;

    for row in req

        .headers

        .iter()

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

    {

        let name = HeaderName::from_bytes(substitute(&row.key, vars).as_bytes())

            .map_err(|e| anyhow!("invalid header name {:?}: {e}", row.key))?;

        let value = HeaderValue::from_str(&substitute(&row.value, vars))

            .map_err(|e| anyhow!("invalid value for header {:?}: {e}", row.key))?;

        if name == AUTHORIZATION {

            has_auth = true;

        }

        if name == CONTENT_TYPE {

            has_content_type = true;

        }

        headers.insert(name, value);

    }

    let method = match req.method {

        Method::Get => reqwest::Method::GET,

        Method::Post => reqwest::Method::POST,

        Method::Put => reqwest::Method::PUT,

        Method::Patch => reqwest::Method::PATCH,

        Method::Delete => reqwest::Method::DELETE,

        Method::Head => reqwest::Method::HEAD,

        Method::Options => reqwest::Method::OPTIONS,

    };

    let query: Vec<(String, String)> = req

        .query

        .iter()

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

        .map(|r| (substitute(&r.key, vars), substitute(&r.value, vars)))

        .collect();

    let mut rb = client.request(method, &url).headers(headers).query(&query);

    if let Some(token) = bearer.filter(|_| !has_auth) {

        rb = rb.bearer_auth(token);

    }

    if let Some(body) = req.body.as_ref().filter(|b| !b.trim().is_empty()) {

        rb = rb.body(substitute(body, vars));

        if !has_content_type {

            rb = rb.header(CONTENT_TYPE, "application/json");

        }

    }

    let start = Instant::now();

    let resp = rb.send().await.context("request failed")?;

    let elapsed = start.elapsed();

    let status = resp.status();

    let reason = status.canonical_reason().unwrap_or("").to_string();

    let is_json = resp

        .headers()

        .get(CONTENT_TYPE)

        .and_then(|v| v.to_str().ok())

        .map(|ct| ct.contains("json"))

        .unwrap_or(false);

    let resp_headers: Vec<(String, String)> = resp

        .headers()

        .iter()

        .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))

        .collect();

    let bytes = resp.bytes().await.context("reading response body")?;

    let size = bytes.len();

    let raw = String::from_utf8_lossy(&bytes).into_owned();

    let body = if is_json {

        serde_json::from_str::<serde_json::Value>(&raw)

            .and_then(|v| serde_json::to_string_pretty(&v))

            .unwrap_or(raw)

    } else {

        raw

    };

    Ok(HttpResponse {

        status: status.as_u16(),

        reason,

        elapsed,

        headers: resp_headers,

        body,

        size,

    })

}

/// Build the final URL: base + path with `{{vars}}` and `{pathParams}` applied.

pub fn build_url(base_url: &str, req: &SavedRequest, vars: &HashMap<String, String>) -> String {

    let mut path = substitute(&req.path, vars);

    for row in req.path_params.iter().filter(|r| r.enabled) {

        let value = encode_path_segment(&substitute(&row.value, vars));

        path = path.replace(&format!("{{{}}}", row.key), &value);

    }

    format!(

        "{}/{}",

        base_url.trim_end_matches('/'),

        path.trim_start_matches('/')

    )

}

/// Percent-encode a path parameter value (unreserved chars kept as-is).

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

    let mut out = String::with_capacity(s.len());

    for b in s.bytes() {

        match b {

            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {

                out.push(b as char)

            }

            _ => out.push_str(&format!("%{b:02X}")),

        }

    }

    out

}