pub enum GetDefaultProjectError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status404 {
        message: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status403 {
        error: String,
    },
    Status500 {
        error: String,
    },
}

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

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

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

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

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

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

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

pub enum GetProjectsError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status404 {
        message: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status403 {
        error: String,
    },
    Status500 {
        error: String,
    },
}

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

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

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

pub enum PostProjectError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status404 {
        message: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status403 {
        error: String,
    },
    Status500 {
        error: String,
    },
}

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

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

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

pub enum GetProjectError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status404 {
        message: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status403 {
        error: String,
    },
    Status500 {
        error: String,
    },
}

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

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

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

pub enum DeleteProjectError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status404 {
        message: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status403 {
        error: String,
    },
    Status500 {
        error: String,
    },
}

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

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

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

#[async_trait::async_trait]
pub trait Project {
    async fn get_default_project(&self, authorization: &str) -> Result<crate::model::Project, GetDefaultProjectError>;
    async fn get_projects(&self, project_name: Option<&str>, authorization: &str) -> Result<Vec<crate::model::Project>, GetProjectsError>;
    async fn post_project(&self, field0: crate::model::ProjectDataRequest, authorization: &str) -> Result<crate::model::Project, PostProjectError>;
    async fn get_project(&self, project_id: &str, authorization: &str) -> Result<crate::model::Project, GetProjectError>;
    async fn delete_project(&self, project_id: &str, authorization: &str) -> Result<(), DeleteProjectError>;
}

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

#[async_trait::async_trait]
impl Project for ProjectLive {
    async fn get_default_project(&self, authorization: &str) -> Result<crate::model::Project, GetDefaultProjectError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/projects/default");

        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::<crate::model::Project>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(GetDefaultProjectError::Status404 { message: body.message })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(GetDefaultProjectError::Status400 { errors: body.errors })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(GetDefaultProjectError::Status403 { error: body.error })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(GetDefaultProjectError::Status500 { error: body.error })
            }
            _ => Err(GetDefaultProjectError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_projects(&self, project_name: Option<&str>, authorization: &str) -> Result<Vec<crate::model::Project>, GetProjectsError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/projects");
        if let Some(value) = project_name {
            url.query_pairs_mut().append_pair("project-name", &format!("{value}"));
        }
        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::Project>>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(GetProjectsError::Status404 { message: body.message })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(GetProjectsError::Status400 { errors: body.errors })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(GetProjectsError::Status403 { error: body.error })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(GetProjectsError::Status500 { error: body.error })
            }
            _ => Err(GetProjectsError::UnexpectedStatus(result.status()))
        }
    }

    async fn post_project(&self, field0: crate::model::ProjectDataRequest, authorization: &str) -> Result<crate::model::Project, PostProjectError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/projects");

        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::<crate::model::Project>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(PostProjectError::Status404 { message: body.message })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(PostProjectError::Status400 { errors: body.errors })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(PostProjectError::Status403 { error: body.error })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(PostProjectError::Status500 { error: body.error })
            }
            _ => Err(PostProjectError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_project(&self, project_id: &str, authorization: &str) -> Result<crate::model::Project, GetProjectError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/projects/{project_id}"));

        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::<crate::model::Project>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(GetProjectError::Status404 { message: body.message })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(GetProjectError::Status400 { errors: body.errors })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(GetProjectError::Status403 { error: body.error })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(GetProjectError::Status500 { error: body.error })
            }
            _ => Err(GetProjectError::UnexpectedStatus(result.status()))
        }
    }

    async fn delete_project(&self, project_id: &str, authorization: &str) -> Result<(), DeleteProjectError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/projects/{project_id}"));

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .delete(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<()>().await?;
                Ok(body)
            }
            404 => {
                let body = result.json::<ProjectEndpointErrorNotFoundPayload>().await?;
                Err(DeleteProjectError::Status404 { message: body.message })
            }
            400 => {
                let body = result.json::<ProjectEndpointErrorArgValidationPayload>().await?;
                Err(DeleteProjectError::Status400 { errors: body.errors })
            }
            403 => {
                let body = result.json::<ProjectEndpointErrorLimitExceededPayload>().await?;
                Err(DeleteProjectError::Status403 { error: body.error })
            }
            500 => {
                let body = result.json::<ProjectEndpointErrorInternalPayload>().await?;
                Err(DeleteProjectError::Status500 { error: body.error })
            }
            _ => Err(DeleteProjectError::UnexpectedStatus(result.status()))
        }
    }
}