reflow_api_services 0.2.0

#![allow(clippy::all, unused_imports, dead_code)]

//! Auto-generated API actors for Razorpay
//!
//! Service: Razorpay (razorpay)
//! Payment gateway for India
//!
//! Required env var: RAZORPAY_API_KEY (Basic auth credentials (user:pass))
//!
//! Generated by api-schema-gen codegen — do not edit manually.

use crate::{Actor, ActorBehavior, Message, Port};
use anyhow::{Error, Result};
use reflow_actor::{message::EncodableValue, ActorContext};
use reflow_actor_macro::actor;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::time::Duration;

const BASE_URL: &str = "https://api.razorpay.com/v1";
const ENV_KEY: &str = "RAZORPAY_API_KEY";

/// Apply authentication to the request builder.
fn apply_auth(
    config: &reflow_actor::ActorConfig,
    mut builder: reqwest::RequestBuilder,
) -> Result<reqwest::RequestBuilder> {
    let credential = config
        .get_config_or_env(ENV_KEY)
        .ok_or_else(|| anyhow::anyhow!("Missing env var: {}", ENV_KEY))?;
    builder = builder.header("Authorization", format!("Basic {}", credential));
    Ok(builder)
}

/// create order via Razorpay API
///
/// Method: POST /orders
#[actor(
    RazorpayCreateOrderActor,
    inports::<100>(amount, currency),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_order(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/orders".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("currency") {
        body.insert("currency".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /orders failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// create payment via Razorpay API
///
/// Method: POST /payments
#[actor(
    RazorpayCreatePaymentActor,
    inports::<100>(amount, currency),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_payment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/payments".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("currency") {
        body.insert("currency".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /payments failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all orders
///
/// Method: GET /orders
#[actor(
    RazorpayListOrdersActor,
    inports::<100>(from, to, count, skip, authorized, receipt),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_orders(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/orders".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("from") {
        query_pairs.push(("from", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to") {
        query_pairs.push(("to", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("authorized") {
        query_pairs.push(("authorized", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("receipt") {
        query_pairs.push(("receipt", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /orders failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific order by ID
///
/// Method: GET /orders/{order_id}
#[actor(
    RazorpayReadOrderActor,
    inports::<100>(order_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_order(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/orders/{order_id}".to_string();
    if let Some(val) = inputs.get("order_id") {
        endpoint = endpoint.replace("{{order_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /orders/{{order_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update order notes
///
/// Method: PATCH /orders/{order_id}
#[actor(
    RazorpayUpdateOrderActor,
    inports::<100>(order_id, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_update_order(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/orders/{order_id}".to_string();
    if let Some(val) = inputs.get("order_id") {
        endpoint = endpoint.replace("{{order_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.patch(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PATCH /orders/{{order_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch payments for a specific order
///
/// Method: GET /orders/{order_id}/payments
#[actor(
    RazorpayListOrderPaymentsActor,
    inports::<100>(order_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_order_payments(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/orders/{order_id}/payments".to_string();
    if let Some(val) = inputs.get("order_id") {
        endpoint = endpoint.replace("{{order_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /orders/{{order_id}}/payments failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all payments
///
/// Method: GET /payments
#[actor(
    RazorpayListPaymentsActor,
    inports::<100>(from, to, count, skip),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_payments(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/payments".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("from") {
        query_pairs.push(("from", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to") {
        query_pairs.push(("to", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /payments failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific payment by ID
///
/// Method: GET /payments/{payment_id}
#[actor(
    RazorpayReadPaymentActor,
    inports::<100>(payment_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_payment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payments/{payment_id}".to_string();
    if let Some(val) = inputs.get("payment_id") {
        endpoint = endpoint.replace("{{payment_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /payments/{{payment_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update payment notes
///
/// Method: PATCH /payments/{payment_id}
#[actor(
    RazorpayUpdatePaymentActor,
    inports::<100>(payment_id, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_update_payment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payments/{payment_id}".to_string();
    if let Some(val) = inputs.get("payment_id") {
        endpoint = endpoint.replace("{{payment_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.patch(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PATCH /payments/{{payment_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Capture an authorized payment
///
/// Method: POST /payments/{payment_id}/capture
#[actor(
    RazorpayCreatePaymentCaptureActor,
    inports::<100>(payment_id, amount, currency),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_payment_capture(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payments/{payment_id}/capture".to_string();
    if let Some(val) = inputs.get("payment_id") {
        endpoint = endpoint.replace("{{payment_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("currency") {
        body.insert("currency".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /payments/{{payment_id}}/capture failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Refund a payment
///
/// Method: POST /payments/{payment_id}/refund
#[actor(
    RazorpayCreateRefundActor,
    inports::<100>(payment_id, amount, speed, notes, receipt),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_refund(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payments/{payment_id}/refund".to_string();
    if let Some(val) = inputs.get("payment_id") {
        endpoint = endpoint.replace("{{payment_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("speed") {
        body.insert("speed".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("receipt") {
        body.insert("receipt".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /payments/{{payment_id}}/refund failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Retrieve all refunds
///
/// Method: GET /refunds
#[actor(
    RazorpayListRefundsActor,
    inports::<100>(from, to, count, skip),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_refunds(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/refunds".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("from") {
        query_pairs.push(("from", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to") {
        query_pairs.push(("to", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /refunds failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific refund by ID
///
/// Method: GET /refunds/{refund_id}
#[actor(
    RazorpayReadRefundActor,
    inports::<100>(refund_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_refund(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/refunds/{refund_id}".to_string();
    if let Some(val) = inputs.get("refund_id") {
        endpoint = endpoint.replace("{{refund_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /refunds/{{refund_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update refund notes
///
/// Method: PATCH /refunds/{refund_id}
#[actor(
    RazorpayUpdateRefundActor,
    inports::<100>(refund_id, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_update_refund(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/refunds/{refund_id}".to_string();
    if let Some(val) = inputs.get("refund_id") {
        endpoint = endpoint.replace("{{refund_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.patch(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PATCH /refunds/{{refund_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a customer
///
/// Method: POST /customers
#[actor(
    RazorpayCreateCustomerActor,
    inports::<100>(name, email, contact, fail_existing, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_customer(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/customers".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("contact") {
        body.insert("contact".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("fail_existing") {
        body.insert("fail_existing".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /customers failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all customers
///
/// Method: GET /customers
#[actor(
    RazorpayListCustomersActor,
    inports::<100>(count, skip),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_customers(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/customers".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /customers failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific customer by ID
///
/// Method: GET /customers/{customer_id}
#[actor(
    RazorpayReadCustomerActor,
    inports::<100>(customer_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_customer(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/customers/{customer_id}".to_string();
    if let Some(val) = inputs.get("customer_id") {
        endpoint = endpoint.replace("{{customer_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /customers/{{customer_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Update customer details
///
/// Method: PUT /customers/{customer_id}
#[actor(
    RazorpayUpdateCustomerActor,
    inports::<100>(customer_id, name, email, contact, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_update_customer(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/customers/{customer_id}".to_string();
    if let Some(val) = inputs.get("customer_id") {
        endpoint = endpoint.replace("{{customer_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.put(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("email") {
        body.insert("email".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("contact") {
        body.insert("contact".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("PUT /customers/{{customer_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a subscription for recurring payments
///
/// Method: POST /subscriptions
#[actor(
    RazorpayCreateSubscriptionActor,
    inports::<100>(plan_id, total_count, quantity, customer_notify, start_at, customer_id, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_subscription(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/subscriptions".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("plan_id") {
        body.insert("plan_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("total_count") {
        body.insert("total_count".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("quantity") {
        body.insert("quantity".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("customer_notify") {
        body.insert("customer_notify".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("start_at") {
        body.insert("start_at".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("customer_id") {
        body.insert("customer_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /subscriptions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all subscriptions
///
/// Method: GET /subscriptions
#[actor(
    RazorpayListSubscriptionsActor,
    inports::<100>(plan_id, from, to, count, skip),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_subscriptions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/subscriptions".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("plan_id") {
        query_pairs.push(("plan_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("from") {
        query_pairs.push(("from", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to") {
        query_pairs.push(("to", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /subscriptions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific subscription by ID
///
/// Method: GET /subscriptions/{subscription_id}
#[actor(
    RazorpayReadSubscriptionActor,
    inports::<100>(subscription_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_subscription(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/subscriptions/{subscription_id}".to_string();
    if let Some(val) = inputs.get("subscription_id") {
        endpoint = endpoint.replace("{{subscription_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /subscriptions/{{subscription_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Cancel a subscription
///
/// Method: POST /subscriptions/{subscription_id}/cancel
#[actor(
    RazorpayDeleteSubscriptionActor,
    inports::<100>(subscription_id, cancel_at_cycle_end),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_delete_subscription(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/subscriptions/{subscription_id}/cancel".to_string();
    if let Some(val) = inputs.get("subscription_id") {
        endpoint = endpoint.replace("{{subscription_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("cancel_at_cycle_end") {
        body.insert("cancel_at_cycle_end".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "POST /subscriptions/{{subscription_id}}/cancel failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Create an invoice
///
/// Method: POST /invoices
#[actor(
    RazorpayCreateInvoiceActor,
    inports::<100>(type_, date, description, customer_id, line_items, currency),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_invoice(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/invoices".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("type_") {
        body.insert("type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("date") {
        body.insert("date".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("description") {
        body.insert("description".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("customer_id") {
        body.insert("customer_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("line_items") {
        body.insert("line_items".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("currency") {
        body.insert("currency".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /invoices failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all invoices
///
/// Method: GET /invoices
#[actor(
    RazorpayListInvoicesActor,
    inports::<100>(type_, payment_id, customer_id, count, skip),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_invoices(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/invoices".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("payment_id") {
        query_pairs.push(("payment_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("customer_id") {
        query_pairs.push(("customer_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /invoices failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific invoice by ID
///
/// Method: GET /invoices/{invoice_id}
#[actor(
    RazorpayReadInvoiceActor,
    inports::<100>(invoice_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_invoice(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/invoices/{invoice_id}".to_string();
    if let Some(val) = inputs.get("invoice_id") {
        endpoint = endpoint.replace("{{invoice_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /invoices/{{invoice_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a payment link
///
/// Method: POST /payment_links
#[actor(
    RazorpayCreatePaymentLinkActor,
    inports::<100>(amount, currency, accept_partial, description, customer, expire_by, notify, callback_url, callback_method, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_payment_link(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/payment_links".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("currency") {
        body.insert("currency".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("accept_partial") {
        body.insert("accept_partial".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("description") {
        body.insert("description".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("customer") {
        body.insert("customer".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("expire_by") {
        body.insert("expire_by".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notify") {
        body.insert("notify".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("callback_url") {
        body.insert("callback_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("callback_method") {
        body.insert("callback_method".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /payment_links failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all payment links
///
/// Method: GET /payment_links
#[actor(
    RazorpayListPaymentLinksActor,
    inports::<100>(payment_id, reference_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_payment_links(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/payment_links".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("payment_id") {
        query_pairs.push(("payment_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("reference_id") {
        query_pairs.push(("reference_id", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /payment_links failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific payment link
///
/// Method: GET /payment_links/{payment_link_id}
#[actor(
    RazorpayReadPaymentLinkActor,
    inports::<100>(payment_link_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_payment_link(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payment_links/{payment_link_id}".to_string();
    if let Some(val) = inputs.get("payment_link_id") {
        endpoint = endpoint.replace("{{payment_link_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /payment_links/{{payment_link_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Update a payment link
///
/// Method: PATCH /payment_links/{payment_link_id}
#[actor(
    RazorpayUpdatePaymentLinkActor,
    inports::<100>(payment_link_id, accept_partial, amount, expire_by, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_update_payment_link(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payment_links/{payment_link_id}".to_string();
    if let Some(val) = inputs.get("payment_link_id") {
        endpoint = endpoint.replace("{{payment_link_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.patch(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("accept_partial") {
        body.insert("accept_partial".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("expire_by") {
        body.insert("expire_by".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("PATCH /payment_links/{{payment_link_id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Create a payout to a bank account or UPI
///
/// Method: POST /payouts
#[actor(
    RazorpayCreatePayoutActor,
    inports::<100>(account_number, fund_account_id, amount, currency, mode, purpose, queue_if_low_balance, reference_id, notes),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_create_payout(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/payouts".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("account_number") {
        body.insert("account_number".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("fund_account_id") {
        body.insert("fund_account_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("amount") {
        body.insert("amount".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("currency") {
        body.insert("currency".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("mode") {
        body.insert("mode".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("purpose") {
        body.insert("purpose".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("queue_if_low_balance") {
        body.insert("queue_if_low_balance".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("reference_id") {
        body.insert("reference_id".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("notes") {
        body.insert("notes".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /payouts failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific payout by ID
///
/// Method: GET /payouts/{payout_id}
#[actor(
    RazorpayReadPayoutActor,
    inports::<100>(payout_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_payout(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/payouts/{payout_id}".to_string();
    if let Some(val) = inputs.get("payout_id") {
        endpoint = endpoint.replace("{{payout_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /payouts/{{payout_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Retrieve all settlements
///
/// Method: GET /settlements
#[actor(
    RazorpayListSettlementsActor,
    inports::<100>(from, to, count, skip),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_list_settlements(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/settlements".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("from") {
        query_pairs.push(("from", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("to") {
        query_pairs.push(("to", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("count") {
        query_pairs.push(("count", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("skip") {
        query_pairs.push(("skip", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /settlements failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch a specific settlement by ID
///
/// Method: GET /settlements/{settlement_id}
#[actor(
    RazorpayReadSettlementActor,
    inports::<100>(settlement_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn razorpay_read_settlement(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/settlements/{settlement_id}".to_string();
    if let Some(val) = inputs.get("settlement_id") {
        endpoint = endpoint.replace("{{settlement_id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /settlements/{{settlement_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}