pub enum GetComponentsOfIdError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status409 {
        component_id: uuid::Uuid,
    },
}

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

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

impl GetComponentsOfIdError {
    pub fn to_component_endpoint_error(&self) -> Option<crate::model::ComponentEndpointError> {
        match self {
            GetComponentsOfIdError::Status500 { error } => Some(crate::model::ComponentEndpointError::InternalError { error: error.clone() }), 
            GetComponentsOfIdError::Status404 { message } => Some(crate::model::ComponentEndpointError::NotFound { message: message.clone() }), 
            GetComponentsOfIdError::Status504 => Some(crate::model::ComponentEndpointError::GatewayTimeout), 
            GetComponentsOfIdError::Status403 { error } => Some(crate::model::ComponentEndpointError::LimitExceeded { error: error.clone() }), 
            GetComponentsOfIdError::Status409 { component_id } => Some(crate::model::ComponentEndpointError::AlreadyExists { component_id: component_id.clone() }), 
            GetComponentsOfIdError::Status400 { errors } => Some(crate::model::ComponentEndpointError::ArgValidationError { errors: errors.clone() }), 
            _ => None
        }
    }
}

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

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

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

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

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct ComponentEndpointErrorAlreadyExistsPayload {
    #[serde(rename = "componentId")]
    pub component_id: uuid::Uuid,
}

pub enum PutComponentError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status409 {
        component_id: uuid::Uuid,
    },
}

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

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

impl PutComponentError {
    pub fn to_component_endpoint_error(&self) -> Option<crate::model::ComponentEndpointError> {
        match self {
            PutComponentError::Status500 { error } => Some(crate::model::ComponentEndpointError::InternalError { error: error.clone() }), 
            PutComponentError::Status404 { message } => Some(crate::model::ComponentEndpointError::NotFound { message: message.clone() }), 
            PutComponentError::Status504 => Some(crate::model::ComponentEndpointError::GatewayTimeout), 
            PutComponentError::Status403 { error } => Some(crate::model::ComponentEndpointError::LimitExceeded { error: error.clone() }), 
            PutComponentError::Status409 { component_id } => Some(crate::model::ComponentEndpointError::AlreadyExists { component_id: component_id.clone() }), 
            PutComponentError::Status400 { errors } => Some(crate::model::ComponentEndpointError::ArgValidationError { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum GetComponentsError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status409 {
        component_id: uuid::Uuid,
    },
}

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

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

impl GetComponentsError {
    pub fn to_component_endpoint_error(&self) -> Option<crate::model::ComponentEndpointError> {
        match self {
            GetComponentsError::Status500 { error } => Some(crate::model::ComponentEndpointError::InternalError { error: error.clone() }), 
            GetComponentsError::Status404 { message } => Some(crate::model::ComponentEndpointError::NotFound { message: message.clone() }), 
            GetComponentsError::Status504 => Some(crate::model::ComponentEndpointError::GatewayTimeout), 
            GetComponentsError::Status403 { error } => Some(crate::model::ComponentEndpointError::LimitExceeded { error: error.clone() }), 
            GetComponentsError::Status409 { component_id } => Some(crate::model::ComponentEndpointError::AlreadyExists { component_id: component_id.clone() }), 
            GetComponentsError::Status400 { errors } => Some(crate::model::ComponentEndpointError::ArgValidationError { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum PostComponentError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status409 {
        component_id: uuid::Uuid,
    },
}

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

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

impl PostComponentError {
    pub fn to_component_endpoint_error(&self) -> Option<crate::model::ComponentEndpointError> {
        match self {
            PostComponentError::Status500 { error } => Some(crate::model::ComponentEndpointError::InternalError { error: error.clone() }), 
            PostComponentError::Status404 { message } => Some(crate::model::ComponentEndpointError::NotFound { message: message.clone() }), 
            PostComponentError::Status504 => Some(crate::model::ComponentEndpointError::GatewayTimeout), 
            PostComponentError::Status403 { error } => Some(crate::model::ComponentEndpointError::LimitExceeded { error: error.clone() }), 
            PostComponentError::Status409 { component_id } => Some(crate::model::ComponentEndpointError::AlreadyExists { component_id: component_id.clone() }), 
            PostComponentError::Status400 { errors } => Some(crate::model::ComponentEndpointError::ArgValidationError { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum DownloadComponentError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status409 {
        component_id: uuid::Uuid,
    },
}

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

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

impl DownloadComponentError {
    pub fn to_component_endpoint_error(&self) -> Option<crate::model::ComponentEndpointError> {
        match self {
            DownloadComponentError::Status500 { error } => Some(crate::model::ComponentEndpointError::InternalError { error: error.clone() }), 
            DownloadComponentError::Status404 { message } => Some(crate::model::ComponentEndpointError::NotFound { message: message.clone() }), 
            DownloadComponentError::Status504 => Some(crate::model::ComponentEndpointError::GatewayTimeout), 
            DownloadComponentError::Status403 { error } => Some(crate::model::ComponentEndpointError::LimitExceeded { error: error.clone() }), 
            DownloadComponentError::Status409 { component_id } => Some(crate::model::ComponentEndpointError::AlreadyExists { component_id: component_id.clone() }), 
            DownloadComponentError::Status400 { errors } => Some(crate::model::ComponentEndpointError::ArgValidationError { errors: errors.clone() }), 
            _ => None
        }
    }
}

pub enum GetLatestComponentError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        message: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        error: String,
    },
    Status409 {
        component_id: uuid::Uuid,
    },
}

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

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

impl GetLatestComponentError {
    pub fn to_component_endpoint_error(&self) -> Option<crate::model::ComponentEndpointError> {
        match self {
            GetLatestComponentError::Status500 { error } => Some(crate::model::ComponentEndpointError::InternalError { error: error.clone() }), 
            GetLatestComponentError::Status404 { message } => Some(crate::model::ComponentEndpointError::NotFound { message: message.clone() }), 
            GetLatestComponentError::Status504 => Some(crate::model::ComponentEndpointError::GatewayTimeout), 
            GetLatestComponentError::Status403 { error } => Some(crate::model::ComponentEndpointError::LimitExceeded { error: error.clone() }), 
            GetLatestComponentError::Status409 { component_id } => Some(crate::model::ComponentEndpointError::AlreadyExists { component_id: component_id.clone() }), 
            GetLatestComponentError::Status400 { errors } => Some(crate::model::ComponentEndpointError::ArgValidationError { errors: errors.clone() }), 
            _ => None
        }
    }
}

#[async_trait::async_trait]
pub trait Component {
    async fn get_components_of_id(&self, template_id: &str, authorization: &str) -> Result<Vec<crate::model::Component>, GetComponentsOfIdError>;
    async fn put_component(&self, template_id: &str, template: Vec<u8>, authorization: &str) -> Result<crate::model::Component, PutComponentError>;
    async fn get_components(&self, project_id: &str, template_name: &str, authorization: &str) -> Result<Vec<crate::model::Component>, GetComponentsError>;
    async fn post_component(&self, field0: crate::model::ComponentQuery, template: Vec<u8>, authorization: &str) -> Result<crate::model::Component, PostComponentError>;
    async fn download_component(&self, template_id: &str, version: &str, authorization: &str) -> Result<Vec<u8>, DownloadComponentError>;
    async fn get_latest_component(&self, template_id: &str, authorization: &str) -> Result<i32, GetLatestComponentError>;
}

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

#[async_trait::async_trait]
impl Component for ComponentLive {
    async fn get_components_of_id(&self, template_id: &str, authorization: &str) -> Result<Vec<crate::model::Component>, GetComponentsOfIdError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_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::<Vec<crate::model::Component>>().await?;
                Ok(body)
            }
            504 => Err(GetComponentsOfIdError::Status504), 
            404 => {
                let body = result.json::<ComponentEndpointErrorNotFoundPayload>().await?;
                Err(GetComponentsOfIdError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ComponentEndpointErrorLimitExceededPayload>().await?;
                Err(GetComponentsOfIdError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ComponentEndpointErrorArgValidationErrorPayload>().await?;
                Err(GetComponentsOfIdError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ComponentEndpointErrorInternalErrorPayload>().await?;
                Err(GetComponentsOfIdError::Status500 { error: body.error })
            }
            409 => {
                let body = result.json::<ComponentEndpointErrorAlreadyExistsPayload>().await?;
                Err(GetComponentsOfIdError::Status409 { component_id: body.component_id })
            }
            _ => Err(GetComponentsOfIdError::UnexpectedStatus(result.status()))
        }
    }

    async fn put_component(&self, template_id: &str, template: Vec<u8>, authorization: &str) -> Result<crate::model::Component, PutComponentError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/upload"));

        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(&template)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::Component>().await?;
                Ok(body)
            }
            504 => Err(PutComponentError::Status504), 
            404 => {
                let body = result.json::<ComponentEndpointErrorNotFoundPayload>().await?;
                Err(PutComponentError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ComponentEndpointErrorLimitExceededPayload>().await?;
                Err(PutComponentError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ComponentEndpointErrorArgValidationErrorPayload>().await?;
                Err(PutComponentError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ComponentEndpointErrorInternalErrorPayload>().await?;
                Err(PutComponentError::Status500 { error: body.error })
            }
            409 => {
                let body = result.json::<ComponentEndpointErrorAlreadyExistsPayload>().await?;
                Err(PutComponentError::Status409 { component_id: body.component_id })
            }
            _ => Err(PutComponentError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_components(&self, project_id: &str, template_name: &str, authorization: &str) -> Result<Vec<crate::model::Component>, GetComponentsError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/templates");
        url.query_pairs_mut().append_pair("project-id", &format!("{project_id}"));
        url.query_pairs_mut().append_pair("template-name", &format!("{template_name}"));
        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::Component>>().await?;
                Ok(body)
            }
            504 => Err(GetComponentsError::Status504), 
            404 => {
                let body = result.json::<ComponentEndpointErrorNotFoundPayload>().await?;
                Err(GetComponentsError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ComponentEndpointErrorLimitExceededPayload>().await?;
                Err(GetComponentsError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ComponentEndpointErrorArgValidationErrorPayload>().await?;
                Err(GetComponentsError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ComponentEndpointErrorInternalErrorPayload>().await?;
                Err(GetComponentsError::Status500 { error: body.error })
            }
            409 => {
                let body = result.json::<ComponentEndpointErrorAlreadyExistsPayload>().await?;
                Err(GetComponentsError::Status409 { component_id: body.component_id })
            }
            _ => Err(GetComponentsError::UnexpectedStatus(result.status()))
        }
    }

    async fn post_component(&self, field0: crate::model::ComponentQuery, template: Vec<u8>, authorization: &str) -> Result<crate::model::Component, PostComponentError> {
        let mut url = self.base_url.clone();
        url.set_path("v1/templates");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let form = reqwest::multipart::Form::new()
            .part("field0", reqwest::multipart::Part::text(serde_json::to_string(&field0).expect("Failed to serialize value to JSON")).mime_str("application/json")?)
            .part("template", reqwest::multipart::Part::bytes(template).mime_str("application/octet-stream")?);
        let result = reqwest::Client::builder()
            .build()?
            .post(url)
            .headers(headers)
            .multipart(form)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::Component>().await?;
                Ok(body)
            }
            504 => Err(PostComponentError::Status504), 
            404 => {
                let body = result.json::<ComponentEndpointErrorNotFoundPayload>().await?;
                Err(PostComponentError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ComponentEndpointErrorLimitExceededPayload>().await?;
                Err(PostComponentError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ComponentEndpointErrorArgValidationErrorPayload>().await?;
                Err(PostComponentError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ComponentEndpointErrorInternalErrorPayload>().await?;
                Err(PostComponentError::Status500 { error: body.error })
            }
            409 => {
                let body = result.json::<ComponentEndpointErrorAlreadyExistsPayload>().await?;
                Err(PostComponentError::Status409 { component_id: body.component_id })
            }
            _ => Err(PostComponentError::UnexpectedStatus(result.status()))
        }
    }

    async fn download_component(&self, template_id: &str, version: &str, authorization: &str) -> Result<Vec<u8>, DownloadComponentError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/download"));
        url.query_pairs_mut().append_pair("version", &format!("{version}"));
        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.bytes().await?.to_vec();
                Ok(body)
            }
            504 => Err(DownloadComponentError::Status504), 
            404 => {
                let body = result.json::<ComponentEndpointErrorNotFoundPayload>().await?;
                Err(DownloadComponentError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ComponentEndpointErrorLimitExceededPayload>().await?;
                Err(DownloadComponentError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ComponentEndpointErrorArgValidationErrorPayload>().await?;
                Err(DownloadComponentError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ComponentEndpointErrorInternalErrorPayload>().await?;
                Err(DownloadComponentError::Status500 { error: body.error })
            }
            409 => {
                let body = result.json::<ComponentEndpointErrorAlreadyExistsPayload>().await?;
                Err(DownloadComponentError::Status409 { component_id: body.component_id })
            }
            _ => Err(DownloadComponentError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_latest_component(&self, template_id: &str, authorization: &str) -> Result<i32, GetLatestComponentError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/latest"));

        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::<i32>().await?;
                Ok(body)
            }
            504 => Err(GetLatestComponentError::Status504), 
            404 => {
                let body = result.json::<ComponentEndpointErrorNotFoundPayload>().await?;
                Err(GetLatestComponentError::Status404 { message: body.message })
            }
            403 => {
                let body = result.json::<ComponentEndpointErrorLimitExceededPayload>().await?;
                Err(GetLatestComponentError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<ComponentEndpointErrorArgValidationErrorPayload>().await?;
                Err(GetLatestComponentError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<ComponentEndpointErrorInternalErrorPayload>().await?;
                Err(GetLatestComponentError::Status500 { error: body.error })
            }
            409 => {
                let body = result.json::<ComponentEndpointErrorAlreadyExistsPayload>().await?;
                Err(GetLatestComponentError::Status409 { component_id: body.component_id })
            }
            _ => Err(GetLatestComponentError::UnexpectedStatus(result.status()))
        }
    }
}