Audience

use lettr::Lettr;

let client = Lettr::new("your-api-key");

client.audience.contacts;    // individual contacts
client.audience.lists;       // contact lists
client.audience.topics;      // subscription topics
client.audience.properties;  // custom contact properties
client.audience.segments;    // dynamic segments

use std::collections::HashMap;
use lettr::audience::contacts::{
    CreateAudienceContactOptions, ListAudienceContactsOptions, UpdateAudienceContactOptions,
    AudienceContactStatus, UpdateAudienceContactStatus,
};

// Create (optionally attach to a list and set properties)
let options = CreateAudienceContactOptions::new("jane@example.com")
    .with_list_id("list-uuid")
    .with_properties(HashMap::from([
        ("first_name".to_string(), "Jane".to_string()),
        ("plan".to_string(), "pro".to_string()),
    ]));
let contact = client.audience.contacts.create(options).await?;
println!("{} {} {:?}", contact.id, contact.email, contact.status);

// List with filters
let page = client.audience.contacts.list(
    ListAudienceContactsOptions::new()
        .page(1)
        .per_page(50)
        .search("jane")
        .status(AudienceContactStatus::Subscribed)
        .list_id("list-uuid"),
).await?;

// Get, update, delete
client.audience.contacts.get("contact-uuid").await?;
client.audience.contacts.update(
    "contact-uuid",
    UpdateAudienceContactOptions::new().with_status(UpdateAudienceContactStatus::Unsubscribed),
).await?;
client.audience.contacts.delete("contact-uuid").await?;

use lettr::audience::contacts::{CreateAudienceContactOptions, DoubleOptInConfig};

let options = CreateAudienceContactOptions::new("jane@example.com")
    .with_double_opt_in(DoubleOptInConfig::new(
        "hello@example.com",
        "Confirm your subscription",
        "email-confirmation",
        "https://example.com/confirmed",
    ));
client.audience.contacts.create(options).await?;

use lettr::audience::contacts::BulkCreateAudienceContactsOptions;

client.audience.contacts.bulk_create(
    BulkCreateAudienceContactsOptions::new(vec![
        "a@example.com".to_string(),
        "b@example.com".to_string(),
    ])
    .with_list_ids(vec!["list-uuid".to_string()]),
).await?;

use std::collections::HashMap;
use lettr::audience::contacts::{
    AudienceTopicSubscription, BulkAudienceContactRow, BulkCreateAudienceContactsOptions,
};

let result = client.audience.contacts.bulk_create(
    BulkCreateAudienceContactsOptions::for_contacts(vec![
        BulkAudienceContactRow::new("cara@example.com")
            .with_properties(HashMap::from([("plan".to_string(), "pro".to_string())]))
            .with_list_ids(vec!["vip-list-uuid".to_string()])
            .with_topics(vec![AudienceTopicSubscription::opt_in("newsletter-uuid")]),
        BulkAudienceContactRow::new("dan@example.com")
            .with_topics(vec![AudienceTopicSubscription::opt_out("promos-uuid")]),
    ])
    .with_list_ids(vec!["everyone-list-uuid".to_string()])
    .with_update_existing(false),
).await?;

println!("{} {} {}", result.created, result.already_existed, result.updated);

if result.has_errors() {
    for e in &result.errors {
        // index is zero-based into the rows you submitted
        println!("row {} ({:?}): {:?} — {}", e.index, e.email, e.error_code, e.error);
    }
}

// Every contact that exists after the request, in submission order
let ids = result.contact_ids();
let cara_id = result.id_for("cara@example.com"); // case-insensitive lookup

use lettr::audience::contacts::{BulkContactListMembershipOptions, BulkContactTopicMembershipOptions};

// Single list / topic membership
client.audience.contacts.attach_to_list("contact-uuid", "list-uuid").await?;
client.audience.contacts.detach_from_list("contact-uuid", "list-uuid").await?;
client.audience.contacts.subscribe_to_topic("contact-uuid", "topic-uuid").await?;
client.audience.contacts.unsubscribe_from_topic("contact-uuid", "topic-uuid").await?;

// Bulk list membership (cartesian product of contact_ids × list_ids)
let options = BulkContactListMembershipOptions::new()
    .with_contact_ids(vec!["c1".to_string(), "c2".to_string()])
    .with_list_ids(vec!["l1".to_string(), "l2".to_string()]);
client.audience.contacts.bulk_attach_to_lists(options).await?;

// Bulk topic membership (cartesian product of contact_ids × topic_ids)
let options = BulkContactTopicMembershipOptions::new()
    .with_contact_ids(vec!["c1".to_string(), "c2".to_string()])
    .with_topic_ids(vec!["t1".to_string()]);
let sub = client.audience.contacts.bulk_subscribe_to_topics(options.clone()).await?;
println!("{} {} {}", sub.subscribed, sub.already_subscribed, sub.total_pairs);

let unsub = client.audience.contacts.bulk_unsubscribe_from_topics(options).await?;
println!("{} {}", unsub.unsubscribed, unsub.total_pairs);

use lettr::audience::lists::{CreateAudienceListOptions, UpdateAudienceListOptions, BulkDeleteAudienceListsOptions};

let list = client.audience.lists.create(CreateAudienceListOptions::new("Newsletter")).await?;
println!("{} {} {}", list.id, list.name, list.contacts_count);

client.audience.lists.get("list-uuid").await?;
client.audience.lists.update(
    "list-uuid",
    UpdateAudienceListOptions::new().with_name("Weekly digest"),
).await?;
client.audience.lists.delete("list-uuid").await?;

// Bulk delete
client.audience.lists.bulk_delete(
    BulkDeleteAudienceListsOptions::new(vec!["l1".to_string(), "l2".to_string()]),
).await?;

use lettr::audience::segments::{
    CreateAudienceSegmentOptions, SegmentConditionsInput, SegmentConditionGroup,
    SegmentCondition, SegmentOperator,
};

let conditions = SegmentConditionsInput::new(vec![
    SegmentConditionGroup::new(vec![
        SegmentCondition::new("email", SegmentOperator::EndsWith, "@example.com"),
        SegmentCondition::new("plan", SegmentOperator::Equals, "pro"),
    ]),
]);

client.audience.segments.create(
    CreateAudienceSegmentOptions::new("Pro users at example.com", conditions)
        .with_list_id("list-uuid"),
).await?;

client.audience.segments.get("segment-uuid").await?;
client.audience.segments.delete("segment-uuid").await?;

use lettr::audience::topics::{CreateAudienceTopicOptions, AudienceTopicDefaultSubscription, AudienceTopicVisibility};

client.audience.topics.create(
    CreateAudienceTopicOptions::new("Product updates")
        .with_description("Occasional product news")
        .with_default_subscription(AudienceTopicDefaultSubscription::OptIn)  // immutable after creation
        .with_visibility(AudienceTopicVisibility::Public),
).await?;

client.audience.topics.get("topic-uuid").await?;
client.audience.topics.delete("topic-uuid").await?;

use lettr::audience::properties::{CreateAudiencePropertyOptions, AudiencePropertyType};

client.audience.properties.create(
    CreateAudiencePropertyOptions::new("plan", AudiencePropertyType::String)  // String, Number, Boolean, Date, Json
        .with_fallback_value("free"),
).await?;

client.audience.properties.get("property-uuid").await?;
client.audience.properties.delete("property-uuid").await?;