agentis_pay/mcp/

backend.rs

use std::{collections::HashMap, str::FromStr};

use anyhow::{Result, anyhow, bail};
use async_trait::async_trait;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use time::{OffsetDateTime, UtcOffset, format_description};

use agentis_pay_shared::{
    BipaClient, ClientConfig, CredentialsStore, outflow_poll_id, proto::pb,
    types::pix_payment_key::PixKeyPayment,
};

pub type PixHistoryId = String;

#[derive(Debug, Clone)]
pub enum HistoryQuery {
    List { limit: u32 },
    Detail(PixHistoryId),
}

#[derive(Debug, Clone, Serialize)]
pub struct WhoamiRecord {
    pub has_session: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires_in_seconds: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_method: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct AccountRecord {
    pub user_id: String,
    pub owner_name: String,
    pub document: String,
    pub status: String,
    pub stark_pix_account_branch: String,
    pub stark_pix_account_number: String,
    pub bipa_name: String,
    pub bipa_ispb: String,
    pub stark_pix_keys: Vec<StarkPixKeyRecord>,
}

#[derive(Debug, Clone, Serialize)]
pub struct StarkPixKeyRecord {
    pub key_type: String,
    pub key: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct BalanceRecord {
    pub available_cents: i64,
}

#[derive(Debug, Clone, Serialize)]
pub struct TransactionSummary {
    pub transaction_id: String,
    pub title: String,
    pub direction: String,
    pub amount_cents: i64,
    pub amount_formatted: String,
    pub status: String,
    pub timestamp: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct TransactionSummaryList {
    pub transactions: Vec<TransactionSummary>,
}

#[derive(Debug, Clone, Serialize)]
pub struct TransactionDetail {
    pub transaction_id: String,
    pub title: String,
    pub direction: String,
    pub amount_cents: i64,
    pub amount_formatted: String,
    pub status: String,
    pub note: Option<String>,
    pub created_at: String,
    pub updated_at: String,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub sections: Vec<TransactionSection>,
}

#[derive(Debug, Clone, Serialize)]
pub struct TransactionSection {
    pub name: String,
    pub fields: Vec<TransactionField>,
}

#[derive(Debug, Clone, Serialize)]
pub struct TransactionField {
    pub label: String,
    pub value: String,
}

#[derive(Debug, Clone, Serialize)]
pub enum HistoryRecord {
    List(TransactionSummaryList),
    Detail(TransactionDetail),
}

#[derive(Debug, Clone, Serialize)]
pub struct DepositRecord {
    pub keys: Vec<StarkPixDepositRecord>,
}

#[derive(Debug, Clone, Serialize)]
pub struct StarkPixDepositRecord {
    pub key: String,
    pub key_type: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct PixLimitRecord {
    pub daily_limit_cents: i64,
    pub nightly_limit_cents: i64,
    pub nightly_limit_available_in_up_to_hours: u32,
    pub daily_limit_available_in_up_to_hours: u32,
    pub max_available_in_up_to_hours: u32,
    pub min_available_in_up_to_hours: u32,
}

#[derive(Debug, Clone, Serialize)]
pub struct PayTransferRecord {
    pub status: String,
    pub key: String,
    pub owner_name: String,
    pub amount_brl: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema)]
pub struct PayInput {
    /// PIX key of the recipient (email, phone, CPF, CNPJ, or EVP).
    pub key: String,
    /// Amount in cents (must be > 0).
    pub amount_cents: i64,
    /// Optional payment description.
    pub note: Option<String>,
    /// Agent explanation shown to the user during payment approval.
    pub agent_message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema)]
pub struct HistoryInput {
    #[serde(default)]
    pub id: Option<String>,
    #[serde(default)]
    pub limit: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, JsonSchema)]
pub struct BrcodeDecodeInput {
    pub code: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct NoArgs {}

#[async_trait]
pub trait PixBackend: Send {
    fn set_mcp_client_name(&mut self, _name: String) {}
    fn set_jwt(&mut self, _jwt: String) {}
    async fn whoami(&mut self) -> Result<WhoamiRecord>;
    async fn account(&mut self) -> Result<AccountRecord>;
    async fn balance(&mut self) -> Result<BalanceRecord>;
    async fn history(&mut self, query: HistoryQuery) -> Result<HistoryRecord>;
    async fn deposit(&mut self) -> Result<DepositRecord>;
    async fn pix_list(&mut self) -> Result<DepositRecord> {
        self.deposit().await
    }
    async fn limits(&mut self) -> Result<PixLimitRecord>;
    async fn pay(
        &mut self,
        input: PayInput,
        idempotency_key: uuid::Uuid,
    ) -> Result<PayTransferRecord>;
}

enum BackendAuth {
    Static,
    EnvSession(Box<crate::session::EnvSession>),
    StoredCredentials(Box<CredentialsStore>),
}

pub struct RealBackend {
    config: ClientConfig,
    client: BipaClient,
    auth: BackendAuth,
    agent_name: Option<String>,
}

impl RealBackend {
    pub fn new(config: ClientConfig, client: BipaClient) -> Self {
        let agent_name = client.agent_name().map(ToString::to_string);
        Self {
            config,
            client,
            auth: BackendAuth::Static,
            agent_name,
        }
    }

    pub fn with_env_session(
        config: ClientConfig,
        client: BipaClient,
        session: crate::session::EnvSession,
    ) -> Self {
        let agent_name = client.agent_name().map(ToString::to_string);
        Self {
            config,
            client,
            auth: BackendAuth::EnvSession(Box::new(session)),
            agent_name,
        }
    }

    pub fn with_stored_credentials(
        config: ClientConfig,
        client: BipaClient,
        credentials: CredentialsStore,
    ) -> Self {
        let agent_name = credentials
            .agent_name()
            .map(ToString::to_string)
            .or_else(|| client.agent_name().map(ToString::to_string));
        Self {
            config,
            client,
            auth: BackendAuth::StoredCredentials(Box::new(credentials)),
            agent_name,
        }
    }

    async fn ensure_session(&mut self) -> Result<()> {
        match &mut self.auth {
            BackendAuth::Static => {}
            BackendAuth::EnvSession(session) => {
                crate::session::ensure_valid_env_session(&self.config, &mut self.client, session)
                    .await?;
            }
            BackendAuth::StoredCredentials(credentials) => {
                crate::session::ensure_valid_session(&self.config, &mut self.client, credentials)
                    .await?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct MockBackend {
    whoami_result: WhoamiRecord,
    account_result: AccountRecord,
    balance_result: BalanceRecord,
    history_list: Vec<TransactionSummary>,
    history_details: HashMap<PixHistoryId, TransactionDetail>,
    deposit_result: DepositRecord,
    limits_result: PixLimitRecord,
    pay_result: PayTransferRecord,
    pay_inputs: std::sync::Arc<std::sync::Mutex<Vec<PayInput>>>,
    mcp_client_name: std::sync::Arc<std::sync::Mutex<Option<String>>>,
}

impl Default for MockBackend {
    fn default() -> Self {
        Self::fixture()
    }
}

impl MockBackend {
    pub fn fixture() -> Self {
        Self {
            whoami_result: WhoamiRecord {
                has_session: true,
                agent_name: Some("agentis-test".to_string()),
                expires_at: Some(agentis_pay_shared::unix_timestamp_seconds() + 3600),
                expires_in_seconds: Some(3600),
                auth_method: Some("oauth".to_string()),
            },
            account_result: AccountRecord {
                user_id: "user-123".to_string(),
                owner_name: "Alice Cooper".to_string(),
                document: "123.456.789-00".to_string(),
                status: "active".to_string(),
                stark_pix_account_branch: "0001".to_string(),
                stark_pix_account_number: "12345-6".to_string(),
                bipa_name: "Bipa IP".to_string(),
                bipa_ispb: "40910463".to_string(),
                stark_pix_keys: vec![
                    StarkPixKeyRecord {
                        key_type: "cpf".to_string(),
                        key: "12345678900".to_string(),
                    },
                    StarkPixKeyRecord {
                        key_type: "phone".to_string(),
                        key: "5511999999999".to_string(),
                    },
                ],
            },
            balance_result: BalanceRecord {
                available_cents: 9_876_500,
            },
            history_list: vec![
                TransactionSummary {
                    transaction_id: "tx-001".to_string(),
                    title: "Alice Cooper".to_string(),
                    direction: "credit".to_string(),
                    amount_cents: 1250,
                    amount_formatted: "+R$ 12,50".to_string(),
                    status: "confirmed".to_string(),
                    timestamp: "2026-02-28T00:00:00Z".to_string(),
                    description: None,
                },
                TransactionSummary {
                    transaction_id: "tx-002".to_string(),
                    title: "Coffee Shop".to_string(),
                    direction: "debit".to_string(),
                    amount_cents: 500,
                    amount_formatted: "-R$ 5,00".to_string(),
                    status: "confirmed".to_string(),
                    timestamp: "2026-02-28T01:00:00Z".to_string(),
                    description: Some("morning coffee".to_string()),
                },
            ],
            history_details: HashMap::from([
                (
                    "tx-001".to_string(),
                    TransactionDetail {
                        transaction_id: "tx-001".to_string(),
                        title: "Alice Cooper".to_string(),
                        direction: "credit".to_string(),
                        amount_cents: 1250,
                        amount_formatted: "+R$ 12,50".to_string(),
                        status: "confirmed".to_string(),
                        note: Some("mock transfer".to_string()),
                        created_at: "2026-02-28T00:00:00Z".to_string(),
                        updated_at: "2026-02-28T00:00:00Z".to_string(),
                        sections: vec![],
                    },
                ),
                (
                    "tx-002".to_string(),
                    TransactionDetail {
                        transaction_id: "tx-002".to_string(),
                        title: "Coffee Shop".to_string(),
                        direction: "debit".to_string(),
                        amount_cents: 500,
                        amount_formatted: "-R$ 5,00".to_string(),
                        status: "confirmed".to_string(),
                        note: None,
                        created_at: "2026-02-28T01:00:00Z".to_string(),
                        updated_at: "2026-02-28T01:00:00Z".to_string(),
                        sections: vec![],
                    },
                ),
            ]),
            deposit_result: DepositRecord {
                keys: vec![
                    StarkPixDepositRecord {
                        key: "alice@example.com".to_string(),
                        key_type: "email".to_string(),
                    },
                    StarkPixDepositRecord {
                        key: "5511999999999".to_string(),
                        key_type: "phone".to_string(),
                    },
                ],
            },
            limits_result: PixLimitRecord {
                daily_limit_cents: 2_000_000,
                nightly_limit_cents: 2_000_000,
                nightly_limit_available_in_up_to_hours: 6,
                daily_limit_available_in_up_to_hours: 24,
                max_available_in_up_to_hours: 24,
                min_available_in_up_to_hours: 0,
            },
            pay_result: PayTransferRecord {
                status: "awaiting_approval".to_string(),
                key: "alice@example.com".to_string(),
                owner_name: "Alice Cooper".to_string(),
                amount_brl: "R$ 10,00".to_string(),
                note: Some("mock payment".to_string()),
                message: None,
            },
            pay_inputs: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
            mcp_client_name: std::sync::Arc::new(std::sync::Mutex::new(None)),
        }
    }

    pub fn pay_inputs(&self) -> std::sync::MutexGuard<'_, Vec<PayInput>> {
        self.pay_inputs
            .lock()
            .expect("pay input lock must not be poisoned")
    }

    pub fn mcp_client_name(&self) -> Option<String> {
        self.mcp_client_name
            .lock()
            .expect("mcp_client_name lock must not be poisoned")
            .clone()
    }
}

#[async_trait]
impl PixBackend for MockBackend {
    fn set_mcp_client_name(&mut self, name: String) {
        *self
            .mcp_client_name
            .lock()
            .expect("mcp_client_name lock must not be poisoned") = Some(name);
    }

    async fn whoami(&mut self) -> Result<WhoamiRecord> {
        Ok(self.whoami_result.clone())
    }

    async fn account(&mut self) -> Result<AccountRecord> {
        Ok(self.account_result.clone())
    }

    async fn balance(&mut self) -> Result<BalanceRecord> {
        Ok(self.balance_result.clone())
    }

    async fn history(&mut self, query: HistoryQuery) -> Result<HistoryRecord> {
        match query {
            HistoryQuery::List { limit } => Ok(HistoryRecord::List(TransactionSummaryList {
                transactions: self
                    .history_list
                    .iter()
                    .take(limit as usize)
                    .cloned()
                    .collect(),
            })),
            HistoryQuery::Detail(id) => self
                .history_details
                .get(&id)
                .cloned()
                .map(HistoryRecord::Detail)
                .ok_or_else(|| anyhow!("transaction not found")),
        }
    }

    async fn deposit(&mut self) -> Result<DepositRecord> {
        Ok(self.deposit_result.clone())
    }

    async fn limits(&mut self) -> Result<PixLimitRecord> {
        Ok(self.limits_result.clone())
    }

    async fn pay(
        &mut self,
        input: PayInput,
        _idempotency_key: uuid::Uuid,
    ) -> Result<PayTransferRecord> {
        if input.amount_cents <= 0 {
            bail!("amount_cents must be greater than zero");
        }
        if input.agent_message.trim().is_empty() {
            bail!("agent_message is required");
        }

        let mut calls = self
            .pay_inputs
            .lock()
            .expect("pay input lock must not be poisoned");

        calls.push(input.clone());
        Ok(PayTransferRecord {
            status: "awaiting_approval".to_string(),
            key: input.key,
            owner_name: self.pay_result.owner_name.clone(),
            amount_brl: crate::display::cents_to_brl(input.amount_cents),
            note: input.note,
            message: Some(
                "Payment submitted. The user must approve this operation in the Bipa app. \
                 Use agentispay_history to check the transaction status."
                    .to_string(),
            ),
        })
    }
}

#[async_trait]
impl PixBackend for RealBackend {
    fn set_mcp_client_name(&mut self, _name: String) {}

    fn set_jwt(&mut self, jwt: String) {
        self.client.set_jwt(jwt);
    }

    async fn whoami(&mut self) -> Result<WhoamiRecord> {
        self.ensure_session().await?;
        let has_session = self
            .client
            .jwt()
            .is_some_and(|value: &str| !value.trim().is_empty());

        let (expires_at, expires_in_seconds, auth_method) = match &self.auth {
            BackendAuth::StoredCredentials(creds) => {
                let exp = creds.jwt_expires_at();
                let remaining =
                    exp.map(|e| (e - agentis_pay_shared::unix_timestamp_seconds()).max(0));
                let method = if has_session {
                    if creds.oauth_client_id().is_some() {
                        Some("oauth".to_string())
                    } else {
                        Some("pin".to_string())
                    }
                } else {
                    None
                };
                (exp, remaining, method)
            }
            BackendAuth::EnvSession(session) => {
                let exp = session.jwt_expires_at();
                let remaining =
                    exp.map(|e| (e - agentis_pay_shared::unix_timestamp_seconds()).max(0));
                (exp, remaining, Some("env".to_string()))
            }
            BackendAuth::Static => (None, None, Some("static".to_string())),
        };

        Ok(WhoamiRecord {
            has_session,
            agent_name: self.agent_name.clone(),
            expires_at,
            expires_in_seconds,
            auth_method,
        })
    }

    async fn account(&mut self) -> Result<AccountRecord> {
        self.ensure_session().await?;
        let user = self.client.load_user_cli().await?;
        Ok(AccountRecord {
            user_id: user.user_id.to_string(),
            owner_name: user.owner_name,
            document: user.document,
            status: user.status,
            stark_pix_account_branch: user.stark_pix_account_branch,
            stark_pix_account_number: user.stark_pix_account_number,
            bipa_name: "Bipa IP".to_string(),
            bipa_ispb: "40910463".to_string(),
            stark_pix_keys: user
                .stark_pix_keys
                .into_iter()
                .map(|key| StarkPixKeyRecord {
                    key_type: key.key_type,
                    key: key.key,
                })
                .collect(),
        })
    }

    async fn balance(&mut self) -> Result<BalanceRecord> {
        self.ensure_session().await?;
        let balances = self.client.balances().await?;
        let available_cents = if balances.available_cents != 0 {
            balances.available_cents
        } else {
            balances.cents
        };
        Ok(BalanceRecord { available_cents })
    }

    async fn history(&mut self, query: HistoryQuery) -> Result<HistoryRecord> {
        self.ensure_session().await?;
        match query {
            HistoryQuery::List { limit } => {
                let response = self
                    .client
                    .list_pix_transactions(limit as i32, None)
                    .await?;
                let transactions = response
                    .items
                    .into_iter()
                    .map(|tx| {
                        let direction = pix_flow_direction(tx.flow);
                        let title = pix_title(&tx, direction.as_str());
                        let amount_cents = tx.amount_cents;
                        let amount_formatted =
                            format_amount(amount_with_sign(amount_cents, direction.as_str()));
                        let description = tx.description.filter(|d| !d.is_empty());
                        TransactionSummary {
                            transaction_id: tx.id,
                            title,
                            amount_formatted,
                            direction,
                            amount_cents,
                            status: pix_status_label(tx.status),
                            timestamp: format_timestamp_brt(tx.created_at),
                            description,
                        }
                    })
                    .collect();
                Ok(HistoryRecord::List(TransactionSummaryList { transactions }))
            }
            HistoryQuery::Detail(id) => {
                let tx = self.client.get_pix_transaction(&id).await?;
                let direction = pix_flow_direction(tx.flow);
                let title = pix_title(&tx, direction.as_str());
                let description = tx.description.filter(|d| !d.is_empty());
                let amount_cents = tx.amount_cents;

                let mut sections = Vec::new();

                let mut sender_fields = vec![
                    TransactionField {
                        label: "Nome".to_string(),
                        value: tx.sender_name,
                    },
                    TransactionField {
                        label: "CPF/CNPJ".to_string(),
                        value: tx.sender_tax_id,
                    },
                ];
                if !tx.sender_bank_code.is_empty() {
                    sender_fields.push(TransactionField {
                        label: "Instituição".to_string(),
                        value: tx.sender_bank_code,
                    });
                }

                let mut receiver_fields = vec![
                    TransactionField {
                        label: "Nome".to_string(),
                        value: tx.receiver_name,
                    },
                    TransactionField {
                        label: "CPF/CNPJ".to_string(),
                        value: tx.receiver_tax_id,
                    },
                ];
                if !tx.receiver_bank_code.is_empty() {
                    receiver_fields.push(TransactionField {
                        label: "Instituição".to_string(),
                        value: tx.receiver_bank_code,
                    });
                }

                sections.push(TransactionSection {
                    name: "Remetente".to_string(),
                    fields: sender_fields,
                });
                sections.push(TransactionSection {
                    name: "Destinatário".to_string(),
                    fields: receiver_fields,
                });

                if !tx.end_to_end_id.is_empty() {
                    sections.push(TransactionSection {
                        name: "Detalhes".to_string(),
                        fields: vec![TransactionField {
                            label: "End-to-end ID".to_string(),
                            value: tx.end_to_end_id,
                        }],
                    });
                }

                Ok(HistoryRecord::Detail(TransactionDetail {
                    transaction_id: tx.id,
                    title,
                    amount_formatted: format_amount(amount_with_sign(amount_cents, &direction)),
                    direction,
                    amount_cents,
                    status: pix_status_label(tx.status),
                    note: description,
                    created_at: format_timestamp_brt(tx.created_at),
                    updated_at: String::new(),
                    sections,
                }))
            }
        }
    }

    async fn deposit(&mut self) -> Result<DepositRecord> {
        self.ensure_session().await?;
        let keys = self.client.list_stark_pix_keys().await?;
        let mut entries = Vec::new();

        if let Some(evp) = keys.evp {
            entries.push(StarkPixDepositRecord {
                key: evp.value,
                key_type: "evp".to_string(),
            });
        }

        if let Some(cpf) = keys.cpf
            && let Some((value, kind)) = extract_value_and_kind(cpf)
        {
            entries.push(StarkPixDepositRecord {
                key: value,
                key_type: format!("cpf_{kind}"),
            });
        }
        if let Some(email) = keys.email
            && let Some((value, kind)) = extract_value_and_kind(email)
        {
            entries.push(StarkPixDepositRecord {
                key: value,
                key_type: format!("email_{kind}"),
            });
        }
        if let Some(phone) = keys.phone
            && let Some((value, kind)) = extract_value_and_kind(phone)
        {
            entries.push(StarkPixDepositRecord {
                key: value,
                key_type: format!("phone_{kind}"),
            });
        }
        if let Some(cnpj) = keys.cnpj
            && let Some((value, kind)) = extract_value_and_kind(cnpj)
        {
            entries.push(StarkPixDepositRecord {
                key: value,
                key_type: format!("cnpj_{kind}"),
            });
        }

        Ok(DepositRecord { keys: entries })
    }

    async fn limits(&mut self) -> Result<PixLimitRecord> {
        self.ensure_session().await?;
        let limits = self.client.get_pix_limits().await?;
        Ok(PixLimitRecord {
            daily_limit_cents: limits.daily_limit_cents,
            nightly_limit_cents: limits.nightly_limit_cents,
            nightly_limit_available_in_up_to_hours: limits
                .nightly_limit_available_in_up_to_hours
                .unwrap_or_default(),
            daily_limit_available_in_up_to_hours: limits
                .daily_limit_available_in_up_to_hours
                .unwrap_or_default(),
            max_available_in_up_to_hours: limits.max_available_in_up_to_hours,
            min_available_in_up_to_hours: limits.min_available_in_up_to_hours,
        })
    }

    async fn pay(
        &mut self,
        input: PayInput,
        idempotency_key: uuid::Uuid,
    ) -> Result<PayTransferRecord> {
        self.ensure_session().await?;
        if input.amount_cents <= 0 {
            bail!("amount_cents must be greater than zero");
        }
        if input.agent_message.trim().is_empty() {
            bail!("agent_message is required");
        }
        let pix_key =
            PixKeyPayment::from_str(&input.key).map_err(|e| anyhow!("invalid pix key: {e}"))?;

        let recipient = consulted_key(&self.client.consult_stark_pix_key(&pix_key).await?)?;
        let note = input.note.clone();
        let owner_name = recipient.name.clone().unwrap_or_default();

        let response = self
            .client
            .request_stark_pix_outflow_with_request_id(
                recipient.stark_pix_key_consultation_id,
                input.amount_cents,
                input.note,
                input.agent_message.as_str(),
                idempotency_key,
            )
            .await?;

        // Check for immediate terminal errors (AboveMax, InsufficientFunds, etc.)
        // but do NOT poll for approval — the user approves in-app.
        let status = match outflow_poll_id(&response)? {
            Some(_) => "awaiting_approval",
            None => "scheduled",
        };

        Ok(PayTransferRecord {
            status: status.to_string(),
            key: input.key,
            owner_name,
            amount_brl: crate::display::cents_to_brl(input.amount_cents),
            note,
            message: Some(
                "Payment submitted. The user must approve this operation in the Bipa app. \
                 Use agentispay_history to check the transaction status."
                    .to_string(),
            ),
        })
    }
}

fn pix_flow_direction(flow: i32) -> String {
    match flow {
        f if f == pb::PixTransactionFlow::In as i32 => "credit".to_string(),
        f if f == pb::PixTransactionFlow::Out as i32 => "debit".to_string(),
        _ => "n/a".to_string(),
    }
}

fn pix_status_label(status: i32) -> String {
    match status {
        s if s == pb::PixTransactionStatus::Created as i32 => "created".to_string(),
        s if s == pb::PixTransactionStatus::Pending as i32 => "pending".to_string(),
        s if s == pb::PixTransactionStatus::Succeeded as i32 => "succeeded".to_string(),
        s if s == pb::PixTransactionStatus::Failed as i32 => "failed".to_string(),
        _ => "unspecified".to_string(),
    }
}

fn pix_title(tx: &pb::PixTransaction, direction: &str) -> String {
    let counterparty = match direction {
        "credit" => &tx.sender_name,
        "debit" => &tx.receiver_name,
        _ => &tx.receiver_name,
    };

    if counterparty.is_empty() {
        match direction {
            "credit" => "Pix recebido".to_string(),
            "debit" => "Pagamento Pix".to_string(),
            _ => "Pix".to_string(),
        }
    } else {
        counterparty.clone()
    }
}

fn amount_with_sign(amount_cents: i64, direction: &str) -> i64 {
    match direction {
        "debit" => -(amount_cents.unsigned_abs() as i64),
        "credit" => amount_cents.unsigned_abs() as i64,
        _ => amount_cents,
    }
}

fn format_amount(value: i64) -> String {
    let cents: u64 = value.unsigned_abs();
    let integer = cents / 100;
    let fractional = cents % 100;
    let mut groups = Vec::new();
    let mut remaining = integer;

    loop {
        groups.push((remaining % 1000).to_string());
        remaining /= 1000;
        if remaining == 0 {
            break;
        }
    }

    groups.reverse();
    let mut formatted = String::new();
    for (index, group) in groups.iter().enumerate() {
        if index == 0 {
            formatted.push_str(group);
        } else {
            formatted.push('.');
            formatted.push_str(&format!("{group:0>3}"));
        }
    }

    let amount = format!("R$ {formatted},{fractional:02}");
    if value < 0 {
        format!("-{amount}")
    } else if value > 0 {
        format!("+{amount}")
    } else {
        amount
    }
}

fn format_timestamp_brt(unix_seconds: u64) -> String {
    let brt = UtcOffset::from_hms(-3, 0, 0).expect("valid BRT offset");
    let Ok(dt) = OffsetDateTime::from_unix_timestamp(unix_seconds as i64) else {
        return unix_seconds.to_string();
    };
    let dt = dt.to_offset(brt);
    let fmt =
        format_description::parse("[day]/[month]/[year] [hour]:[minute]").expect("valid format");
    dt.format(&fmt).unwrap_or_else(|_| unix_seconds.to_string())
}

fn extract_value_and_kind(key: pb::list_stark_pix_keys_response::Key) -> Option<(String, String)> {
    match key.kind {
        Some(pb::list_stark_pix_keys_response::key::Kind::Claimed(claimed)) => {
            Some((claimed.value, "claimed".to_string()))
        }
        Some(pb::list_stark_pix_keys_response::key::Kind::Owned(owned)) => {
            Some((owned.value, "owned".to_string()))
        }
        None => None,
    }
}

fn consulted_key(
    response: &pb::ConsultStarkPixKeyResponse,
) -> Result<pb::consult_stark_pix_key_response::Found> {
    match response.outcome.as_ref() {
        Some(pb::consult_stark_pix_key_response::Outcome::Found(found)) => Ok(found.clone()),
        Some(pb::consult_stark_pix_key_response::Outcome::NotFound(_)) => {
            bail!("recipient key was not found")
        }
        Some(pb::consult_stark_pix_key_response::Outcome::Failed(_)) => {
            bail!("recipient key lookup failed")
        }
        Some(pb::consult_stark_pix_key_response::Outcome::TooManyRequests(_)) => {
            bail!("recipient key lookup was rate-limited")
        }
        Some(pb::consult_stark_pix_key_response::Outcome::FraudulentPixKey(_)) => {
            bail!("recipient key is flagged as fraudulent")
        }
        None => bail!("recipient key response was empty"),
    }
}