#include <mailxx/mailxx.hpp>

mailxx::task<void> send_email() {
    mailxx::asio::io_context io;
    mailxx::smtp::client smtp(io, "smtp.gmail.com", 587);

    co_await smtp.async_connect();
    co_await smtp.async_starttls();
    co_await smtp.async_authenticate("user@gmail.com", "app-password", 
                                      mailxx::smtp::auth_method::login);

    mailxx::mime::message msg;
    msg.from({"Sender Name", "sender@gmail.com"});
    msg.add_recipient({"Recipient", "recipient@example.com"});
    msg.subject("Hello from mailxx!");
    msg.content("This is a test email sent with mailxx.");

    co_await smtp.async_send(msg);
    co_await smtp.async_quit();
}

#include <mailxx/mailxx.hpp>

mailxx::asio::io_context io;
mailxx::smtp::client smtp(io, "smtp.gmail.com", 587);

smtp.async_connect([&](mailxx::error_code ec) {
    if (ec) { std::cerr << "Connect failed: " << ec.message() << "\n"; return; }
    
    smtp.async_starttls([&](mailxx::error_code ec) {
        if (ec) { std::cerr << "STARTTLS failed: " << ec.message() << "\n"; return; }
        
        smtp.async_authenticate("user@gmail.com", "app-password",
                                 mailxx::smtp::auth_method::login,
                                 [&](mailxx::error_code ec) {
            if (ec) { std::cerr << "Auth failed: " << ec.message() << "\n"; return; }
            
            mailxx::mime::message msg;
            msg.from({"Sender", "sender@gmail.com"});
            msg.add_recipient({"Recipient", "recipient@example.com"});
            msg.subject("Hello from mailxx!");
            msg.content("Callback style!");
            
            smtp.async_send(msg, [&](mailxx::error_code ec) {
                if (!ec) std::cout << "Email sent!\n";
                smtp.async_quit([](auto) {});
            });
        });
    });
});

io.run();

#include <mailxx/mailxx.hpp>

mailxx::asio::io_context io;
mailxx::smtp::client smtp(io, "smtp.gmail.com", 587);

// Use mailxx::use_future token
std::future<void> fut = smtp.async_connect(mailxx::use_future);

std::thread io_thread([&]() { io.run(); });

fut.get();  // Wait for connection

auto auth_fut = smtp.async_authenticate("user@gmail.com", "app-password",
                                         mailxx::smtp::auth_method::login,
                                         mailxx::use_future);
auth_fut.get();

mailxx::mime::message msg;
// ... setup message ...

smtp.async_send(msg, mailxx::use_future).get();
smtp.async_quit(mailxx::use_future).get();

io_thread.join();

#include <mailxx/mailxx.hpp>

mailxx::asio::io_context io;
mailxx::smtp::client smtp(io, "smtp.gmail.com", 587);

// Simple blocking calls
smtp.connect();
smtp.starttls();
smtp.authenticate("user@gmail.com", "app-password", 
                   mailxx::smtp::auth_method::login);

mailxx::mime::message msg;
msg.from({"Sender Name", "sender@gmail.com"});
msg.add_recipient({"Recipient", "recipient@example.com"});
msg.subject("Hello from mailxx!");
msg.content("Synchronous style - simple and straightforward.");

smtp.send(msg);
smtp.quit();

#include <mailxx/mailxx.hpp>

mailxx::task<void> fetch_emails() {
    mailxx::asio::io_context io;
    mailxx::imap::client imap(io, "imap.gmail.com", 993);

    co_await imap.async_connect_ssl();
    co_await imap.async_authenticate("user@gmail.com", "app-password",
                                      mailxx::imap::auth_method::login);

    co_await imap.async_select("INBOX");

    // Fetch message
    auto msg = co_await imap.async_fetch(1);
    std::cout << "Subject: " << msg.subject() << "\n";
    std::cout << "From: " << msg.from().name << "\n";

    co_await imap.async_logout();
}

mailxx::imap::client imap(io, "imap.gmail.com", 993);

imap.async_connect_ssl([&](mailxx::error_code ec) {
    if (ec) return;
    
    imap.async_authenticate("user@gmail.com", "app-password",
                             mailxx::imap::auth_method::login,
                             [&](mailxx::error_code ec) {
        if (ec) return;
        
        imap.async_select("INBOX", [&](mailxx::error_code ec, 
                                        const mailxx::imap::mailbox_info& info) {
            std::cout << "Messages: " << info.exists << "\n";
            std::cout << "Unseen: " << info.unseen << "\n";
            
            // Fetch with progress callback
            mailxx::imap::fetch_options opts;
            opts.on_progress = [](size_t bytes, size_t total) {
                std::cout << "Progress: " << (bytes * 100 / total) << "%\n";
            };
            
            imap.async_fetch(1, opts, [&](mailxx::error_code ec, 
                                           mailxx::mime::message msg) {
                if (!ec) {
                    std::cout << "Subject: " << msg.subject() << "\n";
                }
            });
        });
    });
});

// Coroutine style
auto result = co_await imap.async_idle(std::chrono::minutes(29));

if (result == mailxx::imap::idle_result::new_mail) {
    std::cout << "New message arrived!\n";
}

// Callback style with event handler
imap.async_idle(std::chrono::minutes(29), 
    [](mailxx::error_code ec, mailxx::imap::idle_result result) {
        if (result == mailxx::imap::idle_result::new_mail) {
            std::cout << "New message arrived!\n";
        }
    });

#include <mailxx/pool/smtp_pool.hpp>

mailxx::pool::pool_config config{
    .min_connections = 2,
    .max_connections = 10,
    .connection_timeout = std::chrono::seconds(30),
    .idle_timeout = std::chrono::minutes(5)
};

mailxx::pool::smtp_pool pool(io, "smtp.example.com", 587, config);

// Coroutine style
auto conn = co_await pool.async_acquire();
co_await conn->async_send(message);
// Connection automatically returned to pool

// Callback style
pool.async_acquire([&](mailxx::error_code ec, 
                        mailxx::pool::connection_handle conn) {
    if (ec) return;
    
    conn->async_send(message, [conn](mailxx::error_code ec) {
        // conn automatically returned when handle is destroyed
        if (!ec) std::cout << "Sent via pooled connection\n";
    });
});

#include <mailxx/pool/rate_limiter.hpp>

// 100 emails per hour
mailxx::pool::rate_limiter limiter(100, std::chrono::hours(1));

// Coroutine style
for (const auto& msg : messages) {
    co_await limiter.async_acquire();  // Wait if rate limit exceeded
    co_await smtp.async_send(msg);
}

// Callback style  
void send_next(size_t index) {
    if (index >= messages.size()) return;
    
    limiter.async_acquire([&, index](mailxx::error_code ec) {
        smtp.async_send(messages[index], [&, index](mailxx::error_code ec) {
            send_next(index + 1);  // Chain next send
        });
    });
}
send_next(0);

// Synchronous check (non-blocking)
if (limiter.try_acquire()) {
    smtp.send(msg);
} else {
    std::cout << "Rate limit exceeded, retry in " 
              << limiter.time_until_available().count() << "ms\n";
}

mailxx::smtp::dsn_options dsn{
    .notify = mailxx::smtp::dsn_notify::success | 
              mailxx::smtp::dsn_notify::failure,
    .return_type = mailxx::smtp::dsn_return::headers,
    .envid = "unique-envelope-id"
};

// Coroutine
co_await smtp.async_send(msg, dsn);

// Callback
smtp.async_send(msg, dsn, [](mailxx::error_code ec) {
    if (!ec) std::cout << "Sent with DSN request\n";
});

// Synchronous
smtp.send(msg, dsn);

// All these are equivalent ways to connect:
smtp.connect();                                         // Sync
smtp.async_connect([](auto ec) { /* ... */ });         // Callback
co_await smtp.async_connect(mailxx::use_awaitable);    // Coroutine
smtp.async_connect(mailxx::use_future).get();          // Future
auto op = smtp.async_connect(mailxx::deferred);        // Deferred
std::move(op)(handler);                                // Execute later

import mailxx;           // Import everything
// or selectively:
import mailxx.smtp;      // Only SMTP
import mailxx.mime;      // Only MIME

int main() {
    mailxx::smtp::client smtp(io, "smtp.gmail.com", 587);
    // ...
}