babelforce-manager-sdk 0.42.1

use std::sync::Arc;

use crate::error::{map_manager_err, ManagerError};
use crate::gen::manager::apis::configuration::Configuration;
use crate::gen::manager::apis::{agent_api, agent_group_api, manager_api};
use crate::gen::manager::models;
use crate::http::{collect_all, fetch_page, Page};
use crate::retry::{with_retry, RetryPolicy};

/// Agent management — `/api/v2/agents`, with a nested `groups` sub-resource.
pub struct AgentsResource {
    pub(crate) cfg: Arc<Configuration>,
    pub(crate) retry: RetryPolicy,
    /// Agent groups — `/api/v2/agents/groups`.
    pub groups: AgentGroupsResource,
}

impl AgentsResource {
    /// List all agents (auto-paginated).
    pub async fn list_all(&self) -> Result<Vec<models::Agent>, ManagerError> {
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = agent_api::list_agents(
                self.cfg.as_ref(),
                Some(page),
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
            )
            .await?;
            Ok((r.items, r.pagination.pages, r.pagination.current))
        })
        .await
    }

    /// List one page of agents.
    pub async fn list_page(
        &self,
        page: i32,
        per_page: Option<i32>,
    ) -> Result<Page<models::Agent>, ManagerError> {
        fetch_page(&self.retry, map_manager_err, || async move {
            let r = agent_api::list_agents(
                self.cfg.as_ref(),
                Some(page),
                per_page,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
            )
            .await?;
            Ok((
                r.items,
                r.pagination.pages,
                r.pagination.current,
                Some(r.pagination.total),
            ))
        })
        .await
    }

    /// Create an agent.
    pub async fn create(
        &self,
        body: models::RestCreateAgent,
    ) -> Result<models::AgentItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::create_agent(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get an agent by id.
    pub async fn get(&self, id: &str) -> Result<models::AgentItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::get_agent(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Update an agent.
    pub async fn update(
        &self,
        id: &str,
        body: models::RestUpdateAgent,
    ) -> Result<models::AgentItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::update_agent(self.cfg.as_ref(), id, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete an agent.
    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::delete_agent(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Update an agent's status.
    pub async fn update_status(
        &self,
        id: &str,
        status: models::UpdateAgentStatusRequest,
    ) -> Result<models::AgentStatus, ManagerError> {
        with_retry(&self.retry, false, || {
            manager_api::update_agent_status(self.cfg.as_ref(), id, Some(status.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// List agent presences.
    pub async fn presences(&self) -> Result<models::AgentPresenceListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::list_agent_presences(self.cfg.as_ref())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get an agent presence by name.
    pub async fn get_presence(
        &self,
        name: &str,
    ) -> Result<models::AgentPresenceItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::get_agent_presence(self.cfg.as_ref(), name)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Create an agent presence.
    pub async fn create_presence(
        &self,
        body: models::AgentPresenceWriteBody,
    ) -> Result<models::AgentPresenceItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::create_agent_presence(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Update an agent presence.
    pub async fn update_presence(
        &self,
        name: &str,
        body: models::AgentPresenceWriteBody,
    ) -> Result<models::AgentPresenceItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::update_agent_presence(self.cfg.as_ref(), name, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete an agent presence.
    pub async fn delete_presence(
        &self,
        name: &str,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::delete_agent_presence(self.cfg.as_ref(), name)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get an agent's total status by id.
    pub async fn get_status(
        &self,
        id: &str,
    ) -> Result<models::AgentTotalStatusResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::get_agent_status(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List available agent statuses.
    pub async fn available_statuses(
        &self,
    ) -> Result<models::AgentAvailabilityListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::list_available_agent_statuses(self.cfg.as_ref())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Enable an agent.
    pub async fn enable(&self, id: &str) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::enable_agent(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Disable an agent.
    pub async fn disable(
        &self,
        id: &str,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::disable_agent(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Hang up an agent's active call.
    pub async fn hangup_call(
        &self,
        id: &str,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::hangup_agent_call(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Perform a bulk action (e.g. `enable`, `disable`, `delete`) on multiple agents.
    pub async fn bulk_action(
        &self,
        action: &str,
        body: models::AgentBulkRequest,
    ) -> Result<models::AgentBulkResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::bulk_agent_action(self.cfg.as_ref(), action, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Export all agents in the given format.
    pub async fn export(&self, format: &str) -> Result<String, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::export_agents(self.cfg.as_ref(), format)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Import agents from a file in the given format.
    #[allow(clippy::too_many_arguments)]
    pub async fn import_agents(
        &self,
        format: &str,
        file: std::path::PathBuf,
        r#async: Option<bool>,
        create_only: Option<bool>,
        update_only: Option<bool>,
        delete_unlisted: Option<bool>,
    ) -> Result<models::AgentImportValidationResults, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::import_agents(
                self.cfg.as_ref(),
                format,
                file.clone(),
                r#async,
                create_only,
                update_only,
                delete_unlisted,
            )
        })
        .await
        .map_err(map_manager_err)
    }

    /// Validate an agent import file without applying it.
    pub async fn validate_import(
        &self,
        file: std::path::PathBuf,
    ) -> Result<models::AgentImportValidationResults, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::validate_agent_import(self.cfg.as_ref(), file.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get an agent import job by id.
    pub async fn get_import_job(
        &self,
        id: &str,
    ) -> Result<models::AgentImportJobItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_api::get_agent_import_job(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List an agent's logs (auto-paginated), optionally filtered by a `from`/`to` range.
    pub async fn logs(
        &self,
        id: &str,
        from: Option<i32>,
        to: Option<i32>,
    ) -> Result<Vec<models::AgentLogEntry>, ManagerError> {
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = agent_api::list_agent_logs(self.cfg.as_ref(), id, Some(page), None, from, to)
                .await?;
            let (pages, current) = r
                .pagination
                .as_ref()
                .map(|p| (p.pages, p.current))
                .unwrap_or((1, 1));
            Ok((r.items, pages, current))
        })
        .await
    }

    /// List logs across all agents (auto-paginated).
    pub async fn all_logs(&self) -> Result<Vec<models::AgentLogEntry>, ManagerError> {
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = agent_api::list_all_agent_logs(self.cfg.as_ref(), Some(page), None).await?;
            let (pages, current) = r
                .pagination
                .as_ref()
                .map(|p| (p.pages, p.current))
                .unwrap_or((1, 1));
            Ok((r.items, pages, current))
        })
        .await
    }

    /// Push a message to an agent (or broadcast to all agents).
    pub async fn push(
        &self,
        body: models::AgentPushRequest,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::push_to_agent(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Update an agent's password.
    pub async fn update_password(
        &self,
        id: &str,
        body: models::AgentPasswordUpdateRequest,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_api::update_agent_password(self.cfg.as_ref(), id, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }
}

/// Agent groups — `/api/v2/agents/groups`.
pub struct AgentGroupsResource {
    pub(crate) cfg: Arc<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl AgentGroupsResource {
    /// List all agent groups (auto-paginated).
    pub async fn list_all(&self) -> Result<Vec<models::AgentGroup>, ManagerError> {
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = agent_group_api::list_agent_groups(self.cfg.as_ref(), Some(page), None).await?;
            Ok((r.items, r.pagination.pages, r.pagination.current))
        })
        .await
    }

    /// Create an agent group.
    pub async fn create(
        &self,
        body: models::RestCreateAgentGroup,
    ) -> Result<models::AgentGroupItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_group_api::create_agent_group(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get an agent group by id.
    pub async fn get(&self, id: &str) -> Result<models::AgentGroupItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            agent_group_api::get_agent_group(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Update an agent group.
    pub async fn update(
        &self,
        id: &str,
        body: models::RestUpdateAgentGroup,
    ) -> Result<models::AgentGroupItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_group_api::update_agent_group(self.cfg.as_ref(), id, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete an agent group.
    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            agent_group_api::delete_agent_group(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Add an agent to a group.
    pub async fn add_agent(
        &self,
        group_id: &str,
        agent_id: &str,
    ) -> Result<models::AgentGroupAdditionResponse, ManagerError> {
        let id = uuid::Uuid::parse_str(agent_id)
            .map_err(|e| ManagerError::InvalidArgument(format!("agent_id: {e}")))?;
        let body = models::AddAgentToGroupRequest { id };
        with_retry(&self.retry, false, || {
            manager_api::add_agent_to_group(self.cfg.as_ref(), group_id, Some(body.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// Remove an agent from a group.
    pub async fn remove_agent(
        &self,
        group_id: &str,
        agent_id: &str,
    ) -> Result<models::AgentGroupItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            agent_group_api::remove_agent_from_group(self.cfg.as_ref(), group_id, agent_id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List all agents in a group (auto-paginated).
    pub async fn list_agents(&self, group_id: &str) -> Result<Vec<models::Agent>, ManagerError> {
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = agent_group_api::list_agents_in_group(
                self.cfg.as_ref(),
                group_id,
                Some(page),
                None,
            )
            .await?;
            Ok((r.items, r.pagination.pages, r.pagination.current))
        })
        .await
    }

    /// Bulk-delete agent groups by id.
    pub async fn bulk_delete(
        &self,
        ids: Vec<String>,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        let ids = ids
            .iter()
            .map(|id| {
                uuid::Uuid::parse_str(id)
                    .map_err(|e| ManagerError::InvalidArgument(format!("ids: {e}")))
            })
            .collect::<Result<Vec<_>, _>>()?;
        let body = models::BulkIdsRequest { ids };
        with_retry(&self.retry, false, || {
            agent_group_api::bulk_delete_agent_groups(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }
}