pub enum IsEnabledError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for IsEnabledError {
    fn from(error: reqwest::Error) -> IsEnabledError {
        IsEnabledError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for IsEnabledError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> IsEnabledError {
        IsEnabledError::InvalidHeaderValue(error)
    }
}

impl IsEnabledError {
    pub fn to_whitelist_endpoint_error(&self) -> Option<crate::model::WhitelistEndpointError> {
        match self {
            IsEnabledError::Status500 { error } => Some(crate::model::WhitelistEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct WhitelistEndpointErrorInternalPayload {
    pub error: String,
}

pub enum SetEnabledError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for SetEnabledError {
    fn from(error: reqwest::Error) -> SetEnabledError {
        SetEnabledError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for SetEnabledError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> SetEnabledError {
        SetEnabledError::InvalidHeaderValue(error)
    }
}

impl SetEnabledError {
    pub fn to_whitelist_endpoint_error(&self) -> Option<crate::model::WhitelistEndpointError> {
        match self {
            SetEnabledError::Status500 { error } => Some(crate::model::WhitelistEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

pub enum GetWhitelistError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for GetWhitelistError {
    fn from(error: reqwest::Error) -> GetWhitelistError {
        GetWhitelistError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for GetWhitelistError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> GetWhitelistError {
        GetWhitelistError::InvalidHeaderValue(error)
    }
}

impl GetWhitelistError {
    pub fn to_whitelist_endpoint_error(&self) -> Option<crate::model::WhitelistEndpointError> {
        match self {
            GetWhitelistError::Status500 { error } => Some(crate::model::WhitelistEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

pub enum CountWhitelistError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for CountWhitelistError {
    fn from(error: reqwest::Error) -> CountWhitelistError {
        CountWhitelistError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for CountWhitelistError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> CountWhitelistError {
        CountWhitelistError::InvalidHeaderValue(error)
    }
}

impl CountWhitelistError {
    pub fn to_whitelist_endpoint_error(&self) -> Option<crate::model::WhitelistEndpointError> {
        match self {
            CountWhitelistError::Status500 { error } => Some(crate::model::WhitelistEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

pub enum AddToWhitelistError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for AddToWhitelistError {
    fn from(error: reqwest::Error) -> AddToWhitelistError {
        AddToWhitelistError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for AddToWhitelistError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> AddToWhitelistError {
        AddToWhitelistError::InvalidHeaderValue(error)
    }
}

impl AddToWhitelistError {
    pub fn to_whitelist_endpoint_error(&self) -> Option<crate::model::WhitelistEndpointError> {
        match self {
            AddToWhitelistError::Status500 { error } => Some(crate::model::WhitelistEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

pub enum RemoveFromWhitelistError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for RemoveFromWhitelistError {
    fn from(error: reqwest::Error) -> RemoveFromWhitelistError {
        RemoveFromWhitelistError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for RemoveFromWhitelistError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> RemoveFromWhitelistError {
        RemoveFromWhitelistError::InvalidHeaderValue(error)
    }
}

impl RemoveFromWhitelistError {
    pub fn to_whitelist_endpoint_error(&self) -> Option<crate::model::WhitelistEndpointError> {
        match self {
            RemoveFromWhitelistError::Status500 { error } => Some(crate::model::WhitelistEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

#[async_trait::async_trait]
pub trait Whitelist {
    async fn is_enabled(&self, authorization: &str) -> Result<bool, IsEnabledError>;
    async fn set_enabled(&self, field0: bool, authorization: &str) -> Result<(), SetEnabledError>;
    async fn get_whitelist(&self, skip: i32, limit: i32, authorization: &str) -> Result<Vec<crate::model::WhitelistEmail>, GetWhitelistError>;
    async fn count_whitelist(&self, authorization: &str) -> Result<i64, CountWhitelistError>;
    async fn add_to_whitelist(&self, field0: Vec<String>, authorization: &str) -> Result<(), AddToWhitelistError>;
    async fn remove_from_whitelist(&self, field0: Vec<String>, authorization: &str) -> Result<(), RemoveFromWhitelistError>;
}

#[derive(Clone, Debug)]
pub struct WhitelistLive {
    pub base_url: reqwest::Url,
}

#[async_trait::async_trait]
impl Whitelist for WhitelistLive {
    async fn is_enabled(&self, authorization: &str) -> Result<bool, IsEnabledError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/whitelist/enabled");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<bool>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<WhitelistEndpointErrorInternalPayload>().await?;
                Err(IsEnabledError::Status500 { error: body.error })
            }
            _ => Err(IsEnabledError::UnexpectedStatus(result.status()))
        }
    }

    async fn set_enabled(&self, field0: bool, authorization: &str) -> Result<(), SetEnabledError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/whitelist/enabled");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .put(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<WhitelistEndpointErrorInternalPayload>().await?;
                Err(SetEnabledError::Status500 { error: body.error })
            }
            _ => Err(SetEnabledError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_whitelist(&self, skip: i32, limit: i32, authorization: &str) -> Result<Vec<crate::model::WhitelistEmail>, GetWhitelistError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/whitelist");
        url.query_pairs_mut().append_pair("skip", &format!("{skip}"));
        url.query_pairs_mut().append_pair("limit", &format!("{limit}"));
        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<Vec<crate::model::WhitelistEmail>>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<WhitelistEndpointErrorInternalPayload>().await?;
                Err(GetWhitelistError::Status500 { error: body.error })
            }
            _ => Err(GetWhitelistError::UnexpectedStatus(result.status()))
        }
    }

    async fn count_whitelist(&self, authorization: &str) -> Result<i64, CountWhitelistError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/whitelist/count");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<i64>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<WhitelistEndpointErrorInternalPayload>().await?;
                Err(CountWhitelistError::Status500 { error: body.error })
            }
            _ => Err(CountWhitelistError::UnexpectedStatus(result.status()))
        }
    }

    async fn add_to_whitelist(&self, field0: Vec<String>, authorization: &str) -> Result<(), AddToWhitelistError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/whitelist");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<WhitelistEndpointErrorInternalPayload>().await?;
                Err(AddToWhitelistError::Status500 { error: body.error })
            }
            _ => Err(AddToWhitelistError::UnexpectedStatus(result.status()))
        }
    }

    async fn remove_from_whitelist(&self, field0: Vec<String>, authorization: &str) -> Result<(), RemoveFromWhitelistError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/whitelist/remove");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<WhitelistEndpointErrorInternalPayload>().await?;
                Err(RemoveFromWhitelistError::Status500 { error: body.error })
            }
            _ => Err(RemoveFromWhitelistError::UnexpectedStatus(result.status()))
        }
    }
}