pub enum InstanceError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status504,
    Status404 {
        error: String,
    },
    Status403 {
        error: String,
    },
    Status400 {
        errors: Vec<String>,
    },
    Status500 {
        golem_error: crate::model::GolemError,
    },
    Status401 {
        error: String,
    },
    Status409 {
        error: String,
    },
}

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

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

impl InstanceError {
    pub fn to_instance_endpoint_error(&self) -> Option<crate::model::InstanceEndpointError> {
        match self {
            InstanceError::Status500 { golem_error } => Some(crate::model::InstanceEndpointError::Golem { golem_error: golem_error.clone() }), 
            InstanceError::Status404 { error } => Some(crate::model::InstanceEndpointError::NotFound { error: error.clone() }), 
            InstanceError::Status504 => Some(crate::model::InstanceEndpointError::GatewayTimeout {}), 
            InstanceError::Status403 { error } => Some(crate::model::InstanceEndpointError::LimitExceeded { error: error.clone() }), 
            InstanceError::Status409 { error } => Some(crate::model::InstanceEndpointError::AlreadyExists { error: error.clone() }), 
            InstanceError::Status401 { error } => Some(crate::model::InstanceEndpointError::Unauthorized { error: error.clone() }), 
            InstanceError::Status400 { errors } => Some(crate::model::InstanceEndpointError::BadRequest { errors: errors.clone() }), 
            _ => None
        }
    }
}

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

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

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

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct InstanceEndpointErrorGolemPayload {
    #[serde(rename = "golemError")]
    pub golem_error: crate::model::GolemError,
}

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

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

#[async_trait::async_trait]
pub trait Instance {
    async fn get_instance_of_id(&self, worker_id: &str, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError>;
    async fn launch_new_instance(&self, template_id: &str, field0: crate::model::WorkerCreationRequest, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError>;
    async fn delete_instance(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<(), InstanceError>;
    async fn get_invocation_key(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InvocationKey, InstanceError>;
    async fn invoke_and_await_function(&self, template_id: &str, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&str>, field0: crate::model::InvokeParameters, authorization: &str) -> Result<crate::model::InvokeResult, InstanceError>;
    async fn invoke_function(&self, template_id: &str, worker_name: &str, function: &str, field0: crate::model::InvokeParameters, authorization: &str) -> Result<(), InstanceError>;
    async fn complete_instance_promise(&self, template_id: &str, worker_name: &str, field0: crate::model::CompleteParameters, authorization: &str) -> Result<bool, InstanceError>;
    async fn interrupt_instance(&self, template_id: &str, worker_name: &str, recover_immediately: Option<bool>, authorization: &str) -> Result<(), InstanceError>;
    async fn get_instance_metadata(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InstanceMetadata, InstanceError>;
}

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

#[async_trait::async_trait]
impl Instance for InstanceLive {
    async fn get_instance_of_id(&self, worker_id: &str, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/workers/{worker_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::ComponentInstance>().await?;
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn launch_new_instance(&self, template_id: &str, field0: crate::model::WorkerCreationRequest, authorization: &str) -> Result<crate::model::ComponentInstance, InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers"));

        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::ComponentInstance>().await?;
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

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

        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 = ();
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_invocation_key(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InvocationKey, InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/key"));

        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)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::InvocationKey>().await?;
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn invoke_and_await_function(&self, template_id: &str, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&str>, field0: crate::model::InvokeParameters, authorization: &str) -> Result<crate::model::InvokeResult, InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/invoke-and-await"));
        url.query_pairs_mut().append_pair("invocation-key", &format!("{invocation_key}"));
        url.query_pairs_mut().append_pair("function", &format!("{function}"));
        if let Some(value) = calling_convention {
            url.query_pairs_mut().append_pair("calling-convention", &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()?
            .post(url)
            .headers(headers)
            .json(&field0)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<crate::model::InvokeResult>().await?;
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn invoke_function(&self, template_id: &str, worker_name: &str, function: &str, field0: crate::model::InvokeParameters, authorization: &str) -> Result<(), InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/invoke"));
        url.query_pairs_mut().append_pair("function", &format!("{function}"));
        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 = ();
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn complete_instance_promise(&self, template_id: &str, worker_name: &str, field0: crate::model::CompleteParameters, authorization: &str) -> Result<bool, InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/complete"));

        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::<bool>().await?;
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn interrupt_instance(&self, template_id: &str, worker_name: &str, recover_immediately: Option<bool>, authorization: &str) -> Result<(), InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_name}/interrupt"));
        if let Some(value) = recover_immediately {
            url.query_pairs_mut().append_pair("recover-immediately", &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()?
            .post(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = ();
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }

    async fn get_instance_metadata(&self, template_id: &str, worker_name: &str, authorization: &str) -> Result<crate::model::InstanceMetadata, InstanceError> {
        let mut url = self.base_url.clone();
        url.set_path(&format!("v1/templates/{template_id}/workers/{worker_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::<crate::model::InstanceMetadata>().await?;
                Ok(body)
            }
            504 => Err(InstanceError::Status504), 
            404 => {
                let body = result.json::<InstanceEndpointErrorNotFoundPayload>().await?;
                Err(InstanceError::Status404 { error: body.error })
            }
            403 => {
                let body = result.json::<InstanceEndpointErrorLimitExceededPayload>().await?;
                Err(InstanceError::Status403 { error: body.error })
            }
            400 => {
                let body = result.json::<InstanceEndpointErrorBadRequestPayload>().await?;
                Err(InstanceError::Status400 { errors: body.errors })
            }
            500 => {
                let body = result.json::<InstanceEndpointErrorGolemPayload>().await?;
                Err(InstanceError::Status500 { golem_error: body.golem_error })
            }
            401 => {
                let body = result.json::<InstanceEndpointErrorUnauthorizedPayload>().await?;
                Err(InstanceError::Status401 { error: body.error })
            }
            409 => {
                let body = result.json::<InstanceEndpointErrorAlreadyExistsPayload>().await?;
                Err(InstanceError::Status409 { error: body.error })
            }
            _ => Err(InstanceError::UnexpectedStatus(result.status()))
        }
    }
}