use async_trait::async_trait;
use crate::context::Context;
use crate::error::Error;
use crate::model::delete_project_response::DeleteProjectResponse;
use crate::model::error_body::ErrorBody;
use crate::model::errors_body::ErrorsBody;
use crate::model::project::Project;
use crate::model::project_action::ProjectAction;
use crate::model::project_data_request::ProjectDataRequest;
use uuid::Uuid;

pub enum ProjectError {
    Error400(ErrorsBody),
    Error401(ErrorBody),
    Error403(ErrorBody),
    Error404(ErrorBody),
    Error500(ErrorBody),
}

#[async_trait]
pub trait ProjectClient {
    async fn default_get(&self) -> Result<Project, Error<ProjectError>>;
    async fn get(&self, project_name: Option<&str>) -> Result<Vec<Project>, Error<ProjectError>>;
    async fn post(&self, value: &ProjectDataRequest) -> Result<Project, Error<ProjectError>>;
    async fn project_id_get(&self, project_id: &Uuid) -> Result<Project, Error<ProjectError>>;
    async fn project_id_delete(&self, project_id: &Uuid) -> Result<DeleteProjectResponse, Error<ProjectError>>;
    async fn project_id_actions_get(&self, project_id: &Uuid) -> Result<Vec<ProjectAction>, Error<ProjectError>>;
}

pub struct ProjectClientLive {
    pub context: Context,
}

#[async_trait]
impl ProjectClient for ProjectClientLive {
    async fn default_get(&self) -> Result<Project, Error<ProjectError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("projects")
            .push("default");

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

        {
            tracing::info!(method="get", endpoint="/v2/projects/default", url=url.to_string(), "default_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::<Project>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(ProjectError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error401(body)))
            }
            403 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error403(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error404(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn get(&self, project_name: Option<&str>) -> Result<Vec<Project>, Error<ProjectError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("projects");

        if let Some(project_name) = project_name {
            url.query_pairs_mut().append_pair("project-name", &project_name);
        }

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

        {
            tracing::info!(method="get", endpoint="/v2/projects", url=url.to_string(), "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::<Vec<Project>>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(ProjectError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error401(body)))
            }
            403 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error403(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error404(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn post(&self, value: &ProjectDataRequest) -> Result<Project, Error<ProjectError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("projects");

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

        {
            tracing::info!(method="post", endpoint="/v2/projects", url=url.to_string(), body=serde_json::to_string(value)?, "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::<Project>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(ProjectError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error401(body)))
            }
            403 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error403(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error404(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn project_id_get(&self, project_id: &Uuid) -> Result<Project, Error<ProjectError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("projects")
            .push(&project_id.to_string());

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

        {
            tracing::info!(method="get", endpoint="/v2/projects/{project_id}", url=url.to_string(), "project_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::<Project>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(ProjectError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error401(body)))
            }
            403 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error403(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error404(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn project_id_delete(&self, project_id: &Uuid) -> Result<DeleteProjectResponse, Error<ProjectError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("projects")
            .push(&project_id.to_string());

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

        {
            tracing::info!(method="delete", endpoint="/v2/projects/{project_id}", url=url.to_string(), "project_id_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::<DeleteProjectResponse>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(ProjectError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error401(body)))
            }
            403 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error403(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error404(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }

    async fn project_id_actions_get(&self, project_id: &Uuid) -> Result<Vec<ProjectAction>, Error<ProjectError>> {
        let mut url = self.context.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("v2")
            .push("projects")
            .push(&project_id.to_string())
            .push("actions");

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

        {
            tracing::info!(method="get", endpoint="/v2/projects/{project_id}/actions", url=url.to_string(), "project_id_actions_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::<Vec<ProjectAction>>().await?)
            }
            400 => {
                let body = response.json::<ErrorsBody>().await?;
                Err(Error::Item(ProjectError::Error400(body)))
            }
            401 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error401(body)))
            }
            403 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error403(body)))
            }
            404 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error404(body)))
            }
            500 => {
                let body = response.json::<ErrorBody>().await?;
                Err(Error::Item(ProjectError::Error500(body)))
            }
            _ => Err(Error::unexpected(status, response.bytes().await?)),
        }
    }
}