use shunt_rs::prelude::*;
use shunt_rs::lettre::{AsyncTransport, Message};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ShuntConfig::default();
    let store = Arc::new(FileStore::new(&config));
    let transport = ShuntEmailTransport::new(store, config);

    let email = Message::builder()
        .from("sender@example.com".parse()?)
        .to("recipient@example.com".parse()?)
        .subject("Hello from Shunt!")
        .body("This email was shunted to your browser.".to_string())?;

    // Email is saved locally and opened in your browser
    transport.send(email).await?;

    Ok(())
}

use shunt_rs::prelude::*;
use shunt_rs::lettre::{AsyncTransport, Message, AsyncSmtpTransport, Tokio1Executor};
use std::sync::Arc;

enum AppTransport {
    Smtp(AsyncSmtpTransport<Tokio1Executor>),
    Shunt(ShuntEmailTransport),
}

fn build_transport() -> AppTransport {
    if cfg!(debug_assertions) {
        let config = ShuntConfig::default();
        let store = Arc::new(FileStore::new(&config));
        AppTransport::Shunt(ShuntEmailTransport::new(store, config))
    } else {
        AppTransport::Smtp(
            AsyncSmtpTransport::<Tokio1Executor>::relay("smtp.example.com")
                .unwrap()
                .build()
        )
    }
}

use shunt_rs::prelude::*;
use std::collections::HashMap;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ShuntConfig::default();
    let store = Arc::new(FileStore::new(&config));
    let sms = SmsInterceptor::new(store, config);

    // SMS is saved locally and opened in your browser
    sms.send_sms(
        "+1234567890",
        "+0987654321",
        "Your verification code is 123456",
        HashMap::from([
            ("campaign".to_string(), "signup-verification".to_string()),
        ]),
    ).await?;

    Ok(())
}

use shunt_rs::prelude::*;
use std::collections::HashMap;
use async_trait::async_trait;

struct TwilioSender {
    account_sid: String,
    auth_token: String,
}

#[async_trait]
impl SmsSender for TwilioSender {
    type Error = reqwest::Error;

    async fn send_sms(
        &self,
        from: &str,
        to: &str,
        body: &str,
        _metadata: HashMap<String, String>,
    ) -> Result<(), Self::Error> {
        // Your real Twilio API call here
        todo!()
    }
}

// In development, use SmsInterceptor instead of TwilioSender

use shunt_rs::prelude::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ShuntConfig::default();
    let store = Arc::new(FileStore::new(&config));

    println!("Shunt preview server running at {}", config.web_url());

    // Starts web UI at http://localhost:9876
    start_server(store, config).await?;

    Ok(())
}

let config = ShuntConfig::new()
    .storage_dir("tmp/my_messages")  // Default: "tmp/shunt"
    .open_browser(false)              // Default: true (auto-open browser on shunt)
    .web_port(3000)                   // Default: 9876
    .web_host("0.0.0.0");            // Default: "127.0.0.1"