reflow_api_services 0.2.1

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

//! Auto-generated API actors for Giphy
//!
//! Service: Giphy (giphy)
//! Search and share GIFs
//!
//! Required env var: GIPHY_API_KEY (API key)
//!
//! Generated by api-schema-gen codegen — do not edit manually.

use crate::{Actor, ActorBehavior, ClientBuilderExt, 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.giphy.com/v1";
const ENV_KEY: &str = "GIPHY_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.query(&[("api_key", &credential)]);
    Ok(builder)
}

/// search gifs via Giphy API
///
/// Method: GET /gifs/search
#[actor(
    GiphySearchGifsActor,
    inports::<100>(q, limit, offset),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_search_gifs(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/gifs/search".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("q") {
        query_pairs.push(("q", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", 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 /gifs/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// read gif via Giphy API
///
/// Method: GET /gifs/{gif_id}
#[actor(
    GiphyReadGifActor,
    inports::<100>(gif_id),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_read_gif(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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 /gifs/{{gif_id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a list of the most relevant and engaging trending GIFs
///
/// Method: GET /gifs/trending
#[actor(
    GiphyListGifsActor,
    inports::<100>(api_key, limit, offset, rating, random_id, bundle, country_code, region, remove_low_contrast),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_gifs(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/gifs/trending".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("rating") {
        query_pairs.push(("rating", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("random_id") {
        query_pairs.push(("random_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("bundle") {
        query_pairs.push(("bundle", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("country_code") {
        query_pairs.push(("country_code", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("region") {
        query_pairs.push(("region", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("remove_low_contrast") {
        query_pairs.push(("remove_low_contrast", 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 /gifs/trending failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a list of the most relevant and engaging trending stickers
///
/// Method: GET /stickers/trending
#[actor(
    GiphyListStickersActor,
    inports::<100>(api_key, limit, offset, rating, random_id, bundle, country_code, region, remove_low_contrast),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_stickers(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/stickers/trending".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("rating") {
        query_pairs.push(("rating", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("random_id") {
        query_pairs.push(("random_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("bundle") {
        query_pairs.push(("bundle", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("country_code") {
        query_pairs.push(("country_code", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("region") {
        query_pairs.push(("region", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("remove_low_contrast") {
        query_pairs.push(("remove_low_contrast", 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 /stickers/trending failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search GIPHY's library of stickers by entering a word or phrase
///
/// Method: GET /stickers/search
#[actor(
    GiphySearchStickersActor,
    inports::<100>(api_key, q, limit, offset, rating, lang, random_id, bundle, country_code, region, remove_low_contrast),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_search_stickers(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/stickers/search".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("q") {
        query_pairs.push(("q", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("rating") {
        query_pairs.push(("rating", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("lang") {
        query_pairs.push(("lang", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("random_id") {
        query_pairs.push(("random_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("bundle") {
        query_pairs.push(("bundle", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("country_code") {
        query_pairs.push(("country_code", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("region") {
        query_pairs.push(("region", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("remove_low_contrast") {
        query_pairs.push(("remove_low_contrast", 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 /stickers/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Converts words and phrases to the perfect sticker using GIPHY's algorithm
///
/// Method: GET /stickers/translate
#[actor(
    GiphyReadStickerActor,
    inports::<100>(api_key, s, rating, random_id, country_code, region),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_read_sticker(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/stickers/translate".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("s") {
        query_pairs.push(("s", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("rating") {
        query_pairs.push(("rating", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("random_id") {
        query_pairs.push(("random_id", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("country_code") {
        query_pairs.push(("country_code", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("region") {
        query_pairs.push(("region", 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 /stickers/translate failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Generates a unique anonymous user ID for analytics tracking
///
/// Method: GET /randomid
#[actor(
    GiphyReadRandomIdActor,
    inports::<100>(api_key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_read_random_id(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", 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 /randomid failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Upload a GIF or video file to GIPHY (note: uses upload.giphy.com host)
///
/// Method: POST /gifs
#[actor(
    GiphyUploadGifActor,
    inports::<100>(api_key, file, source_image_url, username, tags, source_post_url, country_code, region),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_upload_gif(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        body.insert("api_key".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("file") {
        body.insert("file".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("source_image_url") {
        body.insert("source_image_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("username") {
        body.insert("username".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("tags") {
        body.insert("tags".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("source_post_url") {
        body.insert("source_post_url".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("country_code") {
        body.insert("country_code".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("region") {
        body.insert("region".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 /gifs failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a list of GIF categories on the GIPHY network
///
/// Method: GET /gifs/categories
#[actor(
    GiphyListGifCategoriesActor,
    inports::<100>(api_key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_gif_categories(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/gifs/categories".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", 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 /gifs/categories failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a list of valid tag terms that complete the given tag (autocomplete)
///
/// Method: GET /gifs/search/tags
#[actor(
    GiphySearchGifTagsActor,
    inports::<100>(api_key, q, limit, offset),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_search_gif_tags(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/gifs/search/tags".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("q") {
        query_pairs.push(("q", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", 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 /gifs/search/tags failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns all GIPHY channels matching the query term
///
/// Method: GET /channels/search
#[actor(
    GiphySearchChannelsActor,
    inports::<100>(api_key, q, limit, offset),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_search_channels(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/channels/search".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("q") {
        query_pairs.push(("q", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", 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 /channels/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a list of tag terms related to the given tag (search suggestions)
///
/// Method: GET /tags/related/{term}
#[actor(
    GiphyListTagSuggestionsActor,
    inports::<100>(term, api_key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_tag_suggestions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", 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 /tags/related/{{term}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Returns a list of the most popular trending search terms on the GIPHY network
///
/// Method: GET /trending/searches
#[actor(
    GiphyListTrendingSearchesActor,
    inports::<100>(api_key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_trending_searches(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/trending/searches".to_string();

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", 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 /trending/searches failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch GIF objects for the set of GIPHY Emoji (note: uses /v2/emoji path)
///
/// Method: GET /emoji
#[actor(
    GiphyListEmojisActor,
    inports::<100>(api_key, limit, offset),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_emojis(context: ActorContext) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("limit") {
        query_pairs.push(("limit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", 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 /emoji failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Fetch variations associated with a given emoji (note: uses /v2/emoji path)
///
/// Method: GET /emoji/{gif_id}/variations
#[actor(
    GiphyListEmojiVariationsActor,
    inports::<100>(gif_id, api_key),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn giphy_list_emoji_variations(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

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

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

    let client = reqwest::Client::builder()
        .timeout_compat(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("api_key") {
        query_pairs.push(("api_key", 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 /emoji/{{gif_id}}/variations failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}