use async_trait::async_trait;
use crate::Context;
use crate::Error;
use crate::model::CallingConvention;
use crate::model::CompleteParameters;
use crate::model::DeleteWorkerResponse;
use crate::model::ErrorBody;
use crate::model::ErrorsBody;
use crate::model::GolemErrorBody;
use crate::model::InterruptResponse;
use crate::model::InvocationKey;
use crate::model::InvokeParameters;
use crate::model::InvokeResponse;
use crate::model::InvokeResult;
use crate::model::ResumeResponse;
use crate::model::VersionedWorkerId;
use crate::model::WorkerCreationRequest;
use crate::model::WorkerMetadata;
use uuid::Uuid;

pub enum WorkerError {
    Error400(ErrorsBody),
    Error404(ErrorBody),
    Error409(ErrorBody),
    Error500(GolemErrorBody),
}

#[async_trait]
pub trait WorkerClient {
    async fn workers_worker_id_get(&self, worker_id: &str) -> Result<VersionedWorkerId, Error<WorkerError>>;
    async fn template_id_workers_post(&self, template_id: &Uuid, value: &WorkerCreationRequest) -> Result<VersionedWorkerId, Error<WorkerError>>;
    async fn template_id_workers_worker_name_get(&self, template_id: &Uuid, worker_name: &str) -> Result<WorkerMetadata, Error<WorkerError>>;
    async fn template_id_workers_worker_name_delete(&self, template_id: &Uuid, worker_name: &str) -> Result<DeleteWorkerResponse, Error<WorkerError>>;
    async fn template_id_workers_worker_name_key_post(&self, template_id: &Uuid, worker_name: &str) -> Result<InvocationKey, Error<WorkerError>>;
    async fn template_id_workers_worker_name_invoke_and_await_post(&self, template_id: &Uuid, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&CallingConvention>, value: &InvokeParameters) -> Result<InvokeResult, Error<WorkerError>>;
    async fn template_id_workers_worker_name_invoke_post(&self, template_id: &Uuid, worker_name: &str, function: &str, value: &InvokeParameters) -> Result<InvokeResponse, Error<WorkerError>>;
    async fn template_id_workers_worker_name_complete_post(&self, template_id: &Uuid, worker_name: &str, value: &CompleteParameters) -> Result<bool, Error<WorkerError>>;
    async fn template_id_workers_worker_name_interrupt_post(&self, template_id: &Uuid, worker_name: &str, recovery_immediately: Option<bool>) -> Result<InterruptResponse, Error<WorkerError>>;
    async fn template_id_workers_worker_name_resume_post(&self, template_id: &Uuid, worker_name: &str) -> Result<ResumeResponse, Error<WorkerError>>;
}

pub struct WorkerClientLive {
    pub context: Context,
}

#[async_trait]
impl WorkerClient for WorkerClientLive {
    async fn workers_worker_id_get(&self, worker_id: &str) -> Result<VersionedWorkerId, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push("workers")
            .push(worker_id);

        let mut request = self
            .context
            .client
            .get(url.clone());

        {
            tracing::info!(method="get", endpoint="/v2/templates/workers/{worker_id}", url=url.to_string(), "workers_worker_id_get");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<VersionedWorkerId>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_post(&self, template_id: &Uuid, value: &WorkerCreationRequest) -> Result<VersionedWorkerId, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers");

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers", url=url.to_string(), body=serde_json::to_string(value)?, "template_id_workers_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        request = request.json(value);

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<VersionedWorkerId>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_get(&self, template_id: &Uuid, worker_name: &str) -> Result<WorkerMetadata, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name);

        let mut request = self
            .context
            .client
            .get(url.clone());

        {
            tracing::info!(method="get", endpoint="/v2/templates/{template_id}/workers/{worker_name}", url=url.to_string(), "template_id_workers_worker_name_get");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<WorkerMetadata>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_delete(&self, template_id: &Uuid, worker_name: &str) -> Result<DeleteWorkerResponse, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name);

        let mut request = self
            .context
            .client
            .delete(url.clone());

        {
            tracing::info!(method="delete", endpoint="/v2/templates/{template_id}/workers/{worker_name}", url=url.to_string(), "template_id_workers_worker_name_delete");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<DeleteWorkerResponse>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_key_post(&self, template_id: &Uuid, worker_name: &str) -> Result<InvocationKey, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name)
            .push("key");

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers/{worker_name}/key", url=url.to_string(), "template_id_workers_worker_name_key_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<InvocationKey>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_invoke_and_await_post(&self, template_id: &Uuid, worker_name: &str, invocation_key: &str, function: &str, calling_convention: Option<&CallingConvention>, value: &InvokeParameters) -> Result<InvokeResult, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name)
            .push("invoke-and-await");

        url.query_pairs_mut().append_pair("invocation-key", &invocation_key);

        url.query_pairs_mut().append_pair("function", &function);

        if let Some(calling_convention) = calling_convention {
            url.query_pairs_mut().append_pair("calling-convention", &calling_convention.to_string());
        }

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers/{worker_name}/invoke-and-await", url=url.to_string(), body=serde_json::to_string(value)?, "template_id_workers_worker_name_invoke_and_await_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        request = request.json(value);

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<InvokeResult>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_invoke_post(&self, template_id: &Uuid, worker_name: &str, function: &str, value: &InvokeParameters) -> Result<InvokeResponse, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name)
            .push("invoke");

        url.query_pairs_mut().append_pair("function", &function);

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers/{worker_name}/invoke", url=url.to_string(), body=serde_json::to_string(value)?, "template_id_workers_worker_name_invoke_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        request = request.json(value);

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<InvokeResponse>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_complete_post(&self, template_id: &Uuid, worker_name: &str, value: &CompleteParameters) -> Result<bool, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name)
            .push("complete");

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers/{worker_name}/complete", url=url.to_string(), body=serde_json::to_string(value)?, "template_id_workers_worker_name_complete_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        request = request.json(value);

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<bool>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_interrupt_post(&self, template_id: &Uuid, worker_name: &str, recovery_immediately: Option<bool>) -> Result<InterruptResponse, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name)
            .push("interrupt");

        if let Some(recovery_immediately) = recovery_immediately {
            url.query_pairs_mut().append_pair("recovery-immediately", &recovery_immediately.to_string());
        }

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers/{worker_name}/interrupt", url=url.to_string(), "template_id_workers_worker_name_interrupt_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<InterruptResponse>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn template_id_workers_worker_name_resume_post(&self, template_id: &Uuid, worker_name: &str) -> Result<ResumeResponse, Error<WorkerError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("templates")
            .push(&template_id.to_string())
            .push("workers")
            .push(worker_name)
            .push("resume");

        let mut request = self
            .context
            .client
            .post(url.clone());

        {
            tracing::info!(method="post", endpoint="/v2/templates/{template_id}/workers/{worker_name}/resume", url=url.to_string(), "template_id_workers_worker_name_resume_post");
        }

        if let Some(token) = self.context.bearer_token() {
            request = request.bearer_auth(token);
        }

        let response = request.send().await?;

        let status = response.status().as_u16();
        match status {
            200 => {
                Ok(response.json::<ResumeResponse>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(WorkerError::Error400(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error404(body)))
            }
            409 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(WorkerError::Error409(body)))
            }
            500 => {
                let body = response.json::<GolemErrorBody>().await?;
                Err(Error::Item(WorkerError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }
}