babelforce-manager-sdk 0.42.1

use std::sync::Arc;

use reqwest::header::{HeaderValue, AUTHORIZATION};

use crate::auth::Auth;
use crate::error::ManagerError;
use crate::gen::auth::apis::configuration::Configuration as AuthConfig;
use crate::gen::manager::apis::configuration::Configuration as ManagerConfig;
use crate::gen::task_automation::apis::configuration::Configuration as TaskAutomationConfig;
use crate::gen::task_schedule::apis::configuration::Configuration as TaskScheduleConfig;
use crate::gen::user::apis::configuration::Configuration as UserConfig;
use crate::resources::agents::{AgentGroupsResource, AgentsResource};
use crate::resources::applications::{ApplicationsResource, LocalAutomationsResource};
use crate::resources::auth::AuthResource;
use crate::resources::automations::AutomationsResource;
use crate::resources::babeldesk::{BabeldeskResource, BabeldeskWidgetsResource};
use crate::resources::businesshours::BusinessHoursResource;
use crate::resources::calendars::CalendarsResource;
use crate::resources::calls::{CallsResource, ReportingResource};
use crate::resources::campaigns::CampaignsResource;
use crate::resources::conferences::ConferencesResource;
use crate::resources::conversations::ConversationsResource;
use crate::resources::dashboards::DashboardsResource;
use crate::resources::dialer::{DialerBehavioursResource, DialerResource};
use crate::resources::events::EventsResource;
use crate::resources::expressions::ExpressionsResource;
use crate::resources::files::FilesResource;
use crate::resources::integrations::IntegrationsResource;
use crate::resources::logs::LogsResource;
use crate::resources::me::MeResource;
use crate::resources::metrics::MetricsResource;
use crate::resources::numbers::NumbersResource;
use crate::resources::outbound::OutboundResource;
use crate::resources::phonebook::PhonebookResource;
use crate::resources::prompts::PromptsResource;
use crate::resources::queues::{QueueSelectionsResource, QueuesResource};
use crate::resources::recordings::RecordingsResource;
use crate::resources::routing::RoutingResource;
use crate::resources::schedules::TaskSchedulesResource;
use crate::resources::sessions::SessionsResource;
use crate::resources::settings::SettingsResource;
use crate::resources::sms::SmsResource;
use crate::resources::system::SystemResource;
use crate::resources::tasks::{
    TaskMetricsResource, TaskScriptsResource, TaskSecretsResource, TaskSelectionConfigResource,
    TasksResource,
};
use crate::resources::triggers::TriggersResource;
use crate::resources::users::UsersResource;
use crate::retry::RetryPolicy;

/// Default babelforce API host. Override with [`ManagerClientBuilder::base_url`].
pub const DEFAULT_BASE_URL: &str = "https://services.babelforce.com";

/// The babelforce manager SDK client. Build one with [`ManagerClient::connect`] (or
/// [`ManagerClient::builder`]) and use its resource namespaces.
pub struct ManagerClient {
    /// User management — `/api/v2/users`.
    pub users: UsersResource,
    /// Agent management — `/api/v2/agents` (with a nested `groups` sub-resource).
    pub agents: AgentsResource,
    /// The authenticated principal — current user, accounts, password reset (`/api/v2/user`).
    pub me: MeResource,
    /// Call reporting & control — `/api/v2/calls` (with a nested `reporting` sub-resource).
    pub calls: CallsResource,
    /// SMS records — `/api/v2/sms`.
    pub sms: SmsResource,
    /// Service (phone) numbers — `/api/v2/numbers`.
    pub numbers: NumbersResource,
    /// Conferences — `/api/v2/conferences`.
    pub conferences: ConferencesResource,
    /// Queues — `/api/v2/queues` (with a nested `selections` sub-resource).
    pub queues: QueuesResource,
    /// Call recordings — `/api/v2/recordings` (bulk actions and per-recording flagging).
    pub recordings: RecordingsResource,
    /// Routing rules — `/api/v2/routings`.
    pub routing: RoutingResource,
    /// Workflow triggers — `/api/v2/triggers`.
    pub triggers: TriggersResource,
    /// Global automations (event triggers) — `/api/v2/events/triggers`.
    pub automations: AutomationsResource,
    /// Integrations — `/api/v2/integrations`.
    pub integrations: IntegrationsResource,
    /// Outbound lists & leads — `/api/v2/outbound/lists`.
    pub outbound: OutboundResource,
    /// Phonebook entries — `/api/v2/phonebook`.
    pub phonebook: PhonebookResource,
    /// Outbound campaigns — `/api/v2/outbound/campaigns`.
    pub campaigns: CampaignsResource,
    /// Business hours — `/api/v2/business-hours`.
    pub business_hours: BusinessHoursResource,
    /// Calendars — `/api/v2/calendars`.
    pub calendars: CalendarsResource,
    /// Conversations — `/api/v2/conversations` (with events & session variables).
    pub conversations: ConversationsResource,
    /// Reporting dashboards — `/api/v2/dashboards` (with per-dashboard user management).
    pub dashboards: DashboardsResource,
    /// Dialer runtime & reporting — `/api/v2/dialer` (with a nested `behaviours` sub-resource).
    pub dialer: DialerResource,
    /// Call/automation sessions — `/api/v2/sessions`.
    pub sessions: SessionsResource,
    /// Audio prompts — `/api/v2/prompts`.
    pub prompts: PromptsResource,
    /// Babeldesk dashboards — `/api/v2/babeldesk` (with a nested `widgets` sub-resource).
    pub babeldesk: BabeldeskResource,
    /// Event definitions & custom events — `/api/v2/events`.
    pub events: EventsResource,
    /// Expressions catalog & evaluator — `/api/v2/expressions`.
    pub expressions: ExpressionsResource,
    /// Stored files — `/api/v2/files` (recordings, prompts, backups).
    pub files: FilesResource,
    /// Audit & live logs.
    pub logs: LogsResource,
    /// Metrics — `/api/v2/metrics`.
    pub metrics: MetricsResource,
    /// System & reference data — health checks, server time, timezones, tags, templates.
    pub system: SystemResource,
    /// Global settings — `/api/v2/settings`, grouped by scope.
    pub settings: SettingsResource,
    /// Applications — `/api/v2/applications` (with a nested `local_automations` sub-resource).
    pub applications: ApplicationsResource,
    /// Task automation (v3) — `/api/v3/tasks` (with nested scripts/secrets/selection_config/metrics).
    pub tasks: TasksResource,
    /// Task schedules (v3) — `/api/v3/schedules`.
    pub schedules: TaskSchedulesResource,
    /// OAuth 2.0 — `/oauth/authorize`, `/oauth/token`, `/oauth/revoke`.
    pub auth: AuthResource,
}

impl ManagerClient {
    /// Connect with default settings (base URL [`DEFAULT_BASE_URL`], retries on).
    pub async fn connect(auth: Auth) -> Result<Self, ManagerError> {
        Self::builder(auth).connect().await
    }

    /// Start building a client to customise the base URL or retry policy.
    pub fn builder(auth: Auth) -> ManagerClientBuilder {
        ManagerClientBuilder {
            base_url: DEFAULT_BASE_URL.to_string(),
            auth,
            retry: RetryPolicy::default(),
        }
    }
}

/// Builder for [`ManagerClient`].
pub struct ManagerClientBuilder {
    base_url: String,
    auth: Auth,
    retry: RetryPolicy,
}

impl ManagerClientBuilder {
    /// Override the base URL (e.g. a per-customer host). Defaults to [`DEFAULT_BASE_URL`].
    pub fn base_url(mut self, url: impl Into<String>) -> Self {
        self.base_url = url.into();
        self
    }

    /// Override the retry policy. Defaults to [`RetryPolicy::default`].
    pub fn retry(mut self, policy: RetryPolicy) -> Self {
        self.retry = policy;
        self
    }

    /// Build the client, resolving a password grant into a bearer token if needed.
    pub async fn connect(self) -> Result<ManagerClient, ManagerError> {
        let base = self.base_url.trim_end_matches('/').to_string();

        let mut headers = self.auth.static_headers();
        let resolved_token = match &self.auth {
            Auth::Password { user, pass } => Some(
                fetch_token(
                    &base,
                    &[
                        ("grant_type", "password"),
                        ("username", user),
                        ("password", pass),
                        ("client_id", "manager"),
                    ],
                )
                .await?,
            ),
            Auth::ClientCredentials {
                client_id,
                client_secret,
            } => Some(
                fetch_token(
                    &base,
                    &[
                        ("grant_type", "client_credentials"),
                        ("client_id", client_id),
                        ("client_secret", client_secret),
                    ],
                )
                .await?,
            ),
            Auth::RefreshToken {
                refresh_token,
                client_id,
            } => Some(
                fetch_token(
                    &base,
                    &[
                        ("grant_type", "refresh_token"),
                        ("refresh_token", refresh_token),
                        ("client_id", client_id),
                    ],
                )
                .await?,
            ),
            Auth::Bearer { .. } => None,
        };
        if let Some(token) = resolved_token {
            headers.insert(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {token}"))
                    .map_err(|e| ManagerError::Network(e.to_string()))?,
            );
        }

        let http = reqwest::Client::builder()
            .default_headers(headers)
            .build()
            .map_err(|e| ManagerError::Network(e.to_string()))?;

        let user_agent =
            Some(concat!("babelforce-manager-sdk-rust/", env!("CARGO_PKG_VERSION")).to_string());

        let cfg = Arc::new(ManagerConfig {
            base_path: base.clone(),
            user_agent: user_agent.clone(),
            client: http.clone(),
            basic_auth: None,
            oauth_access_token: None,
            bearer_access_token: None,
            api_key: None,
        });

        // The other specs live on the same host and share the auth-configured reqwest client.
        let user_cfg = Arc::new(UserConfig {
            base_path: base.clone(),
            user_agent: user_agent.clone(),
            client: http.clone(),
            basic_auth: None,
            oauth_access_token: None,
            bearer_access_token: None,
            api_key: None,
        });
        let task_automation_cfg = Arc::new(TaskAutomationConfig {
            base_path: base.clone(),
            user_agent: user_agent.clone(),
            client: http.clone(),
            basic_auth: None,
            oauth_access_token: None,
            bearer_access_token: None,
            api_key: None,
        });
        let task_schedule_cfg = Arc::new(TaskScheduleConfig {
            base_path: base.clone(),
            user_agent: user_agent.clone(),
            client: http.clone(),
            basic_auth: None,
            oauth_access_token: None,
            bearer_access_token: None,
            api_key: None,
        });
        // OAuth endpoints carry their credentials in the request body, but share the same host/client.
        let auth_cfg = Arc::new(AuthConfig {
            base_path: base,
            user_agent,
            client: http,
            basic_auth: None,
            oauth_access_token: None,
            bearer_access_token: None,
            api_key: None,
        });

        Ok(ManagerClient {
            users: UsersResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            agents: AgentsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                groups: AgentGroupsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            me: MeResource {
                cfg: user_cfg,
                retry: self.retry.clone(),
            },
            calls: CallsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                reporting: ReportingResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            sms: SmsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            numbers: NumbersResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            conferences: ConferencesResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            queues: QueuesResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                selections: QueueSelectionsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            recordings: RecordingsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            routing: RoutingResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            triggers: TriggersResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            automations: AutomationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            integrations: IntegrationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            outbound: OutboundResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            phonebook: PhonebookResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            campaigns: CampaignsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            business_hours: BusinessHoursResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            calendars: CalendarsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            conversations: ConversationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            dashboards: DashboardsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            dialer: DialerResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                behaviours: DialerBehavioursResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            sessions: SessionsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            prompts: PromptsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            babeldesk: BabeldeskResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                widgets: BabeldeskWidgetsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            events: EventsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            expressions: ExpressionsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            files: FilesResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            logs: LogsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            metrics: MetricsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            system: SystemResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            settings: SettingsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            applications: ApplicationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                local_automations: LocalAutomationsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            tasks: TasksResource {
                cfg: task_automation_cfg.clone(),
                retry: self.retry.clone(),
                scripts: TaskScriptsResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
                secrets: TaskSecretsResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
                selection_config: TaskSelectionConfigResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
                metrics: TaskMetricsResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            schedules: TaskSchedulesResource {
                cfg: task_schedule_cfg,
                retry: self.retry.clone(),
            },
            auth: AuthResource {
                cfg: auth_cfg,
                retry: self.retry.clone(),
            },
        })
    }
}

/// POST an OAuth2 token request to `{base}/oauth/token` with the given form params (a `password` or
/// `client_credentials` grant) and return its `access_token`.
async fn fetch_token(base: &str, params: &[(&str, &str)]) -> Result<String, ManagerError> {
    #[derive(serde::Deserialize)]
    struct Token {
        access_token: String,
    }
    let resp = reqwest::Client::new()
        .post(format!("{base}/oauth/token"))
        .form(params)
        .send()
        .await
        .map_err(|e| ManagerError::Network(e.to_string()))?;
    let status = resp.status();
    let body = resp
        .text()
        .await
        .map_err(|e| ManagerError::Network(e.to_string()))?;
    if !status.is_success() {
        return Err(ManagerError::from_response(status.as_u16(), body));
    }
    let token: Token =
        serde_json::from_str(&body).map_err(|e| ManagerError::Decode(e.to_string()))?;
    Ok(token.access_token)
}