use bstr::BString;

use crate::protocol::{Context, ContextOptions};

/// Indicates key or values contain errors that can't be encoded.
#[derive(Debug, thiserror::Error)]
#[expect(missing_docs)]
pub enum Error {
    #[error("{key:?}={value:?} must not contain null bytes or newlines neither in key nor in value.")]
    Encoding { key: String, value: BString },
}

impl Context {
    /// Create a context containing `url`, encoded and decoded according to `options`.
    pub fn from_url(url: impl Into<BString>, options: ContextOptions) -> Self {
        Context {
            options,
            url: Some(url.into()),
            ..Default::default()
        }
    }
}

mod access {
    use bstr::BString;

    use crate::protocol::Context;

    impl Context {
        /// Clear all fields that are considered secret.
        pub fn clear_secrets(&mut self) {
            let Context {
                options: _,
                protocol: _,
                host: _,
                path: _,
                username: _,
                password,
                oauth_refresh_token,
                password_expiry_utc: _,
                url: _,
                quit: _,
            } = self;

            *password = None;
            *oauth_refresh_token = None;
        }
        /// Replace existing secrets with the word `<redacted>`.
        pub fn redacted(mut self) -> Self {
            let Context {
                options: _,
                protocol: _,
                host: _,
                path: _,
                username: _,
                password,
                oauth_refresh_token,
                password_expiry_utc: _,
                url: _,
                quit: _,
            } = &mut self;
            for secret in [password, oauth_refresh_token].into_iter().flatten() {
                *secret = "<redacted>".into();
            }
            self
        }

        /// Convert all relevant fields into a URL for consumption.
        pub fn to_url(&self) -> Option<BString> {
            use bstr::{ByteSlice, ByteVec};
            let mut buf: BString = self.protocol.clone()?.into();
            buf.push_str(b"://");
            if let Some(user) = &self.username {
                buf.push_str(user);
                buf.push(b'@');
            }
            if let Some(host) = &self.host {
                buf.push_str(host);
            }
            if let Some(path) = &self.path {
                if !path.starts_with_str("/") {
                    buf.push(b'/');
                }
                buf.push_str(path);
            }
            buf.into()
        }
        /// Compute a prompt to obtain the given value.
        pub fn to_prompt(&self, field: &str) -> String {
            match self.to_url() {
                Some(url) => format!("{field} for {url}: "),
                None => format!("{field}: "),
            }
        }
    }
}

mod mutate {
    use bstr::ByteSlice;

    use crate::{protocol, protocol::Context};

    /// In-place mutation
    impl Context {
        /// Destructure the url at our `url` field into parts like protocol, host, username and path and store
        /// them in our respective fields. If `use_http_path` is set, http paths are significant even though
        /// normally this isn't the case.
        #[expect(
            clippy::result_large_err,
            reason = "will be removed once `gix-error` is used consistently"
        )]
        pub fn destructure_url_in_place(&mut self, use_http_path: bool) -> Result<&mut Self, protocol::Error> {
            if self.url.is_none() {
                self.url = Some(self.to_url().ok_or(protocol::Error::UrlMissing)?);
            }

            let url = gix_url::parse(self.url.as_ref().expect("URL is present after check above").as_ref())?;
            self.protocol = Some(url.scheme.as_str().into());
            self.username = url.user().map(ToOwned::to_owned);
            self.password = url.password().map(ToOwned::to_owned);
            self.host = url.host().map(ToOwned::to_owned).map(|mut host| {
                let port = url.port.filter(|port| {
                    url.scheme
                        .default_port()
                        .is_none_or(|default_port| *port != default_port)
                });
                if let Some(port) = port {
                    use std::fmt::Write;
                    write!(host, ":{port}").expect("infallible");
                }
                host
            });
            if !matches!(url.scheme, gix_url::Scheme::Http | gix_url::Scheme::Https) || use_http_path {
                let path = url.path.trim_with(|b| b == '/');
                self.path = (!path.is_empty()).then(|| path.into());
            }
            Ok(self)
        }
    }
}

mod serde;
pub use self::serde::decode;