//

use std::{cell::RefCell, ops::Deref, rc::Rc, sync::Arc};

use reqwest::{Body, Client};
use tokio::sync::Mutex;

use crate::net::{Method, Request, RequestBuilder, Response, Url};

use super::{Error, Result};

/// A list of planned requests and responses
type Plans = Vec<Plan>;

/// A planned request and the response to return
///
/// Contains a list of the criteria that a request must meet before being considered a match.
#[derive(Debug)]
struct Plan {
    match_request: Vec<MatchRequest>,
    response: Response,
}
impl Plan {
    fn matches(&self, request: &Request) -> bool {
        self.match_request.iter().all(|criteria| match criteria {
            MatchRequest::Method(method) => request.method() == method,
            MatchRequest::Url(uri) => request.url() == uri,
            MatchRequest::Header { name, value } => {
                request
                    .headers()
                    .iter()
                    .any(|(request_header_name, request_header_value)| {
                        let Ok(request_header_value) = request_header_value.to_str() else {
                            return false;
                        };
                        request_header_name.as_str() == name && request_header_value == value
                    })
            }
            MatchRequest::Body(body) => {
                request.body().and_then(Body::as_bytes) == Some(body.as_bytes())
            }
        })
    }
}

/// An abstraction for the network
#[derive(Debug, Clone, Default)]
pub struct Net {
    plans: Option<Arc<Mutex<RefCell<Plans>>>>,
}
impl Net {
    /// Creates a new unmocked [Net] for creating real network requests.
    pub(super) const fn new() -> Self {
        Self { plans: None }
    }
}
impl Net {
    /// Helper to create a default [Client].
    ///
    /// # Example
    ///
    /// ```rust
    /// # use kxio::net::Result;
    /// let net = kxio::net::new();
    /// let client = net.client();
    /// let request = client.get("https://hyper.rs");
    /// ```
    pub fn client(&self) -> Client {
        Default::default()
    }

    /// Constructs the Request and sends it to the target URL, returning a
    /// future Response.
    ///
    /// # Errors
    ///
    /// This method fails if there was an error while sending request,
    /// redirect loop was detected or redirect limit was exhausted.
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use kxio::net::Result;
    /// # async fn run() -> Result<()> {
    /// let net = kxio::net::new();
    /// let request = net.client().get("https://hyper.rs");
    /// let response = net.send(request).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn send(&self, request: impl Into<RequestBuilder>) -> Result<Response> {
        let Some(plans) = &self.plans else {
            return request.into().send().await.map_err(Error::from);
        };
        let request = request.into().build()?;
        let index = plans
            .lock()
            .await
            .deref()
            .borrow()
            .iter()
            .position(|plan| plan.matches(&request));
        match index {
            Some(i) => {
                let response = plans.lock().await.borrow_mut().remove(i).response;
                Ok(response)
            }
            None => Err(Error::UnexpectedMockRequest(request)),
        }
    }
}
impl MockNet {
    pub async fn try_from(net: Net) -> std::result::Result<Self, super::Error> {
        match &net.plans {
            Some(plans) => Ok(MockNet {
                plans: Rc::new(RefCell::new(plans.lock().await.take())),
            }),
            None => Err(super::Error::NetIsNotAMock),
        }
    }
}

/// A struct for defining the expected requests and their responses that should be made
/// during a test.
///
/// When the [MockNet] goes out of scope it will verify that all expected requests were consumed,
/// otherwise it will `panic`.
///
/// # Example
///
/// ```rust
/// use kxio::net::{Method, Url};
/// # use kxio::net::Result;
/// # #[tokio::main]
/// # async fn run() -> Result<()> {
/// let mock_net = kxio::net::mock();
/// let client = mock_net.client();
/// // define an expected requet, and the response that should be returned
/// mock_net.on(Method::GET)
///     .url(Url::parse("https://hyper.rs")?)
///     .respond(mock_net.response().status(200).body("Ok")?);
/// let net: kxio::net::Net = mock_net.into();
/// // use 'net' in your program, by passing it as a reference
///
/// // In some rare cases you don't want to assert that all expected requests were made.
/// // You should recover the `MockNet` from the `Net` and `MockNet::reset` it.
/// let mock_net = kxio::net::MockNet::try_from(net).await?;
/// mock_net.reset(); // only if explicitly needed
/// # Ok(())
/// # }
/// ```
#[derive(Debug, Clone, Default)]
pub struct MockNet {
    plans: Rc<RefCell<Plans>>,
}
impl MockNet {
    /// Helper to create a default [Client].
    ///
    /// # Example
    ///
    /// ```rust
    /// let mock_net = kxio::net::mock();
    /// let client = mock_net.client();
    /// let request = client.get("https://hyper.rs");
    /// ```
    pub fn client(&self) -> Client {
        Default::default()
    }

    /// Specify an expected request.
    ///
    /// # Example
    ///
    /// ```rust
    /// use kxio::net::{Method, Url};
    /// # use kxio::net::Result;
    /// # fn run() -> Result<()> {
    /// let mock_net = kxio::net::mock();
    /// let client = mock_net.client();
    /// mock_net.on(Method::GET)
    ///     .url(Url::parse("https://hyper.rs")?)
    ///     .respond(mock_net.response().status(200).body("Ok")?);
    /// # Ok(())
    /// # }
    /// ```
    pub fn on(&self, method: impl Into<Method>) -> WhenRequest {
        WhenRequest::new(self, method)
    }

    fn _when(&self, plan: Plan) {
        self.plans.borrow_mut().push(plan);
    }

    /// Creates a [http::response::Builder] to be extended and returned by a mocked network request.
    pub fn response(&self) -> http::response::Builder {
        Default::default()
    }

    /// Clears all the expected requests and responses from the [MockNet].
    ///
    /// When the [MockNet] goes out of scope it will assert that all expected requests and
    /// responses were consumed. If there are any left unconsumed, then it will `panic`.
    ///
    /// # Example
    ///
    /// ```rust
    /// # use kxio::net::Result;
    /// # #[tokio::main]
    /// # async fn run() -> Result<()> {
    /// # let mock_net = kxio::net::mock();
    /// # let net: kxio::net::Net = mock_net.into();
    /// let mock_net = kxio::net::MockNet::try_from(net).await?;
    /// mock_net.reset(); // only if explicitly needed
    /// # Ok(())
    /// # }
    /// ```
    pub fn reset(&self) {
        self.plans.take();
    }
}
impl From<MockNet> for Net {
    fn from(mock_net: MockNet) -> Self {
        Self {
            // keep the original `inner` around to allow it's Drop impelmentation to run when we go
            // out of scope at the end of the test
            plans: Some(Arc::new(Mutex::new(RefCell::new(mock_net.plans.take())))),
        }
    }
}

impl Drop for MockNet {
    fn drop(&mut self) {
        assert!(self.plans.borrow().is_empty())
    }
}
impl Drop for Net {
    fn drop(&mut self) {
        if let Some(plans) = &self.plans {
            assert!(plans.try_lock().expect("lock plans").take().is_empty())
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MatchRequest {
    Method(Method),
    Url(Url),
    Header { name: String, value: String },
    Body(String),
}

#[derive(Debug, Clone)]
pub struct WhenRequest<'net> {
    net: &'net MockNet,
    match_on: Vec<MatchRequest>,
}

impl<'net> WhenRequest<'net> {
    pub fn url(mut self, url: impl Into<Url>) -> Self {
        self.match_on.push(MatchRequest::Url(url.into()));
        self
    }
    pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
        self.match_on.push(MatchRequest::Header {
            name: name.into(),
            value: value.into(),
        });
        self
    }
    pub fn body(mut self, body: impl Into<String>) -> Self {
        self.match_on.push(MatchRequest::Body(body.into()));
        self
    }
    pub fn respond<T>(self, response: http::Response<T>)
    where
        T: Into<reqwest::Body>,
    {
        self.net._when(Plan {
            match_request: self.match_on,
            response: response.into(),
        });
    }

    fn new(net: &'net MockNet, method: impl Into<Method>) -> Self {
        Self {
            net,
            match_on: vec![MatchRequest::Method(method.into())],
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn is_normal<T: Sized + Send + Sync + Unpin>() {}

    #[test]
    fn normal_types() {
        is_normal::<Net>();
        // is_normal::<MockNet>(); // only used in test setup - no need to be Send or Sync
        is_normal::<MatchRequest>();
        is_normal::<Plan>();
        // is_normal::<WhenRequest>(); // only used in test setup - no need to be Send or Sync
    }
}