#[derive(Debug)]
pub enum ProjectPolicyError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status401 {
        message: String,
    },
}

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

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

impl ProjectPolicyError {
    pub fn to_project_endpoint_error(&self) -> Option<crate::model::ProjectEndpointError> {
        match self {
            ProjectPolicyError::Status500 { error } => Some(crate::model::ProjectEndpointError::Internal { error: error.clone() }), 
            ProjectPolicyError::Status404 { message } => Some(crate::model::ProjectEndpointError::NotFound { message: message.clone() }), 
            ProjectPolicyError::Status403 { error } => Some(crate::model::ProjectEndpointError::LimitExceeded { error: error.clone() }), 
            ProjectPolicyError::Status401 { message } => Some(crate::model::ProjectEndpointError::Unauthorized { message: message.clone() }), 
            ProjectPolicyError::Status400 { errors } => Some(crate::model::ProjectEndpointError::ArgValidation { errors: errors.clone() }), 
            _ => None
        }
    }
}

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

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

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct ProjectEndpointErrorArgValidationPayload {
    pub errors: Vec<String>,
}

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

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

#[async_trait::async_trait]
pub trait ProjectPolicy {
    async fn get_project_policies(&self, project_policy_id: &str, authorization: &str) -> Result<crate::model::ProjectPolicy, ProjectPolicyError>;
    async fn post_project_policy(&self, field0: crate::model::ProjectPolicyData, authorization: &str) -> Result<crate::model::ProjectPolicy, ProjectPolicyError>;
}

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

#[async_trait::async_trait]
impl ProjectPolicy for ProjectPolicyLive {
    async fn get_project_policies(&self, project_policy_id: &str, authorization: &str) -> Result<crate::model::ProjectPolicy, ProjectPolicyError> {
        let mut url = self.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("project-policies")
            .push(project_policy_id);

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        {
            let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
            tracing::info!(method="get", url=url.to_string(), headers=?headers_vec, body="<no_body>", "get_project_policies");
        }
        let mut builder = reqwest::Client::builder();
        if self.allow_insecure {
            builder = builder.danger_accept_invalid_certs(true);
        }
        let client = builder.build()?;
        let result = client
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::ProjectPolicy>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(ProjectPolicyError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(ProjectPolicyError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(ProjectPolicyError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(ProjectPolicyError::Status500 { error: body.error })
            }
            401 => {
                let body = result.json::<ProjectEndpointErrorUnauthorizedPayload>().await?;
                Err(ProjectPolicyError::Status401 { message: body.message })
            }
            _ => Err(ProjectPolicyError::UnexpectedStatus(result.status()))
        }
    }

    async fn post_project_policy(&self, field0: crate::model::ProjectPolicyData, authorization: &str) -> Result<crate::model::ProjectPolicy, ProjectPolicyError> {
        let mut url = self.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v1")
            .push("project-policies");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        {
            let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
            tracing::info!(method="post", url=url.to_string(), headers=?headers_vec, body=serde_json::to_string(&field0).unwrap(), "post_project_policy");
        }
        let mut builder = reqwest::Client::builder();
        if self.allow_insecure {
            builder = builder.danger_accept_invalid_certs(true);
        }
        let client = builder.build()?;
        let result = client
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::ProjectPolicy>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(ProjectPolicyError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(ProjectPolicyError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(ProjectPolicyError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(ProjectPolicyError::Status500 { error: body.error })
            }
            401 => {
                let body = result.json::<ProjectEndpointErrorUnauthorizedPayload>().await?;
                Err(ProjectPolicyError::Status401 { message: body.message })
            }
            _ => Err(ProjectPolicyError::UnexpectedStatus(result.status()))
        }
    }
}