reflow_api_services 0.2.0

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

//! Auto-generated API actors for Google Sheets
//!
//! Service: Google Sheets (google_sheets)
//! Cloud-based spreadsheet application
//!
//! Required env var: GOOGLE_SHEETS_API_KEY (OAuth2 access token)
//!
//! 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://sheets.googleapis.com/v4";
const ENV_KEY: &str = "GOOGLE_SHEETS_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!("Bearer {}", credential));
    Ok(builder)
}

/// read values via Google Sheets API
///
/// Method: GET /spreadsheets/{spreadsheetId}/values/{range}
#[actor(
    GoogleSheetsReadValuesActor,
    inports::<100>(spreadsheetId, range),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_read_values(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values/{range}".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("range") {
        endpoint = endpoint.replace("{{range}}", &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 /spreadsheets/{{spreadsheetId}}/values/{{range}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// update values via Google Sheets API
///
/// Method: PUT /spreadsheets/{spreadsheetId}/values/{range}
#[actor(
    GoogleSheetsUpdateValuesActor,
    inports::<100>(spreadsheetId, range, values),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_update_values(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values/{range}".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("range") {
        endpoint = endpoint.replace("{{range}}", &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("values") {
        body.insert("values".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 /spreadsheets/{{spreadsheetId}}/values/{{range}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// create spreadsheet via Google Sheets API
///
/// Method: POST /spreadsheets
#[actor(
    GoogleSheetsCreateSpreadsheetActor,
    inports::<100>(title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_create_spreadsheet(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/spreadsheets".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("title") {
        body.insert("title".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 /spreadsheets failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns the spreadsheet at the given ID
///
/// Method: GET /spreadsheets/{spreadsheetId}
#[actor(
    GoogleSheetsReadSpreadsheetActor,
    inports::<100>(spreadsheetId, ranges, includeGridData),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_read_spreadsheet(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("ranges") {
        query_pairs.push(("ranges", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeGridData") {
        query_pairs.push(("includeGridData", 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 /spreadsheets/{{spreadsheetId}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a range of values from a spreadsheet
///
/// Method: GET /spreadsheets/{spreadsheetId}/values/{range}
#[actor(
    GoogleSheetsReadSpreadsheetValuesActor,
    inports::<100>(spreadsheetId, range, majorDimension, valueRenderOption, dateTimeRenderOption),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_read_spreadsheet_values(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values/{range}".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("range") {
        endpoint = endpoint.replace("{{range}}", &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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("majorDimension") {
        query_pairs.push(("majorDimension", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("valueRenderOption") {
        query_pairs.push(("valueRenderOption", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("dateTimeRenderOption") {
        query_pairs.push(("dateTimeRenderOption", 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 /spreadsheets/{{spreadsheetId}}/values/{{range}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Sets values in a range of a spreadsheet
///
/// Method: PUT /spreadsheets/{spreadsheetId}/values/{range}
#[actor(
    GoogleSheetsUpdateSpreadsheetValuesActor,
    inports::<100>(spreadsheetId, range, valueInputOption, includeValuesInResponse, values, majorDimension),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_update_spreadsheet_values(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values/{range}".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("range") {
        endpoint = endpoint.replace("{{range}}", &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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("valueInputOption") {
        query_pairs.push(("valueInputOption", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeValuesInResponse") {
        query_pairs.push(("includeValuesInResponse", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("values") {
        body.insert("values".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("majorDimension") {
        body.insert("majorDimension".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 /spreadsheets/{{spreadsheetId}}/values/{{range}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Sets values in one or more ranges of a spreadsheet
///
/// Method: POST /spreadsheets/{spreadsheetId}/values:batchUpdate
#[actor(
    GoogleSheetsUpdateSpreadsheetValuesBatchActor,
    inports::<100>(spreadsheetId, valueInputOption, data, includeValuesInResponse),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_update_spreadsheet_values_batch(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values:batchUpdate".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("valueInputOption") {
        body.insert("valueInputOption".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("data") {
        body.insert("data".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("includeValuesInResponse") {
        body.insert("includeValuesInResponse".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 /spreadsheets/{{spreadsheetId}}/values:batchUpdate failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Returns one or more ranges of values from a spreadsheet
///
/// Method: GET /spreadsheets/{spreadsheetId}/values:batchGet
#[actor(
    GoogleSheetsReadSpreadsheetValuesBatchActor,
    inports::<100>(spreadsheetId, ranges, majorDimension, valueRenderOption),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_read_spreadsheet_values_batch(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values:batchGet".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("ranges") {
        query_pairs.push(("ranges", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("majorDimension") {
        query_pairs.push(("majorDimension", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("valueRenderOption") {
        query_pairs.push(("valueRenderOption", 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 /spreadsheets/{{spreadsheetId}}/values:batchGet failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Clears values from a spreadsheet
///
/// Method: POST /spreadsheets/{spreadsheetId}/values/{range}:clear
#[actor(
    GoogleSheetsDeleteSpreadsheetValuesActor,
    inports::<100>(spreadsheetId, range),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_delete_spreadsheet_values(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values/{range}:clear".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("range") {
        endpoint = endpoint.replace("{{range}}", &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 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 /spreadsheets/{{spreadsheetId}}/values/{{range}}:clear failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Clears one or more ranges of values from a spreadsheet
///
/// Method: POST /spreadsheets/{spreadsheetId}/values:batchClear
#[actor(
    GoogleSheetsDeleteSpreadsheetValuesBatchActor,
    inports::<100>(spreadsheetId, ranges),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_delete_spreadsheet_values_batch(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values:batchClear".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("ranges") {
        body.insert("ranges".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 /spreadsheets/{{spreadsheetId}}/values:batchClear failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Applies one or more updates to the spreadsheet
///
/// Method: POST /spreadsheets/{spreadsheetId}:batchUpdate
#[actor(
    GoogleSheetsUpdateSpreadsheetActor,
    inports::<100>(spreadsheetId, requests, includeSpreadsheetInResponse, responseRanges),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_update_spreadsheet(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}:batchUpdate".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("requests") {
        body.insert("requests".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("includeSpreadsheetInResponse") {
        body.insert(
            "includeSpreadsheetInResponse".to_string(),
            val.clone().into(),
        );
    }
    if let Some(val) = inputs.get("responseRanges") {
        body.insert("responseRanges".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 /spreadsheets/{{spreadsheetId}}:batchUpdate failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Returns the spreadsheet at the given ID, filtered by data filters
///
/// Method: POST /spreadsheets/{spreadsheetId}:getByDataFilter
#[actor(
    GoogleSheetsReadSpreadsheetByDataFilterActor,
    inports::<100>(spreadsheetId, dataFilters, includeGridData),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_read_spreadsheet_by_data_filter(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}:getByDataFilter".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("dataFilters") {
        body.insert("dataFilters".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("includeGridData") {
        body.insert("includeGridData".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 /spreadsheets/{{spreadsheetId}}:getByDataFilter failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Sets values in one or more ranges of a spreadsheet identified by data filters
///
/// Method: POST /spreadsheets/{spreadsheetId}/values:batchUpdateByDataFilter
#[actor(
    GoogleSheetsUpdateSpreadsheetValuesBatchByDataFilterActor,
    inports::<100>(spreadsheetId, valueInputOption, data),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_update_spreadsheet_values_batch_by_data_filter(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values:batchUpdateByDataFilter".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("valueInputOption") {
        body.insert("valueInputOption".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("data") {
        body.insert("data".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 /spreadsheets/{{spreadsheetId}}/values:batchUpdateByDataFilter failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Returns one or more ranges of values from a spreadsheet based on data filters
///
/// Method: POST /spreadsheets/{spreadsheetId}/values:batchGetByDataFilter
#[actor(
    GoogleSheetsReadSpreadsheetValuesBatchByDataFilterActor,
    inports::<100>(spreadsheetId, dataFilters, majorDimension, valueRenderOption),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_read_spreadsheet_values_batch_by_data_filter(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values:batchGetByDataFilter".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("dataFilters") {
        body.insert("dataFilters".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("majorDimension") {
        body.insert("majorDimension".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("valueRenderOption") {
        body.insert("valueRenderOption".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 /spreadsheets/{{spreadsheetId}}/values:batchGetByDataFilter failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Clears one or more ranges of values from a spreadsheet using data filters
///
/// Method: POST /spreadsheets/{spreadsheetId}/values:batchClearByDataFilter
#[actor(
    GoogleSheetsDeleteSpreadsheetValuesBatchByDataFilterActor,
    inports::<100>(spreadsheetId, dataFilters),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_delete_spreadsheet_values_batch_by_data_filter(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values:batchClearByDataFilter".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &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("dataFilters") {
        body.insert("dataFilters".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 /spreadsheets/{{spreadsheetId}}/values:batchClearByDataFilter failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Appends values to a spreadsheet after a table of data
///
/// Method: POST /spreadsheets/{spreadsheetId}/values/{range}:append
#[actor(
    GoogleSheetsUpdateSpreadsheetValuesAppendActor,
    inports::<100>(spreadsheetId, range, valueInputOption, insertDataOption, values),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn google_sheets_update_spreadsheet_values_append(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/spreadsheets/{spreadsheetId}/values/{range}:append".to_string();
    if let Some(val) = inputs.get("spreadsheetId") {
        endpoint = endpoint.replace("{{spreadsheetId}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("range") {
        endpoint = endpoint.replace("{{range}}", &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 query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("valueInputOption") {
        query_pairs.push(("valueInputOption", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("insertDataOption") {
        query_pairs.push(("insertDataOption", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("values") {
        body.insert("values".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 /spreadsheets/{{spreadsheetId}}/values/{{range}}:append failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}