const SwiftMail = require('@swiftmails/sdk');

const client = new SwiftMail('your-api-key');

// Send an email
await client.send({
  from: 'sender@yourdomain.com',
  to: 'recipient@example.com',
  subject: 'Hello from SwiftMail',
  html: '<h1>Welcome!</h1><p>This is a test email.</p>',
  text: 'Welcome! This is a test email.'
});

const client = new SwiftMail('your-api-key', {
  // Basic config
  baseURL: 'https://api.swiftmail.com',
  timeout: 30000,
  maxRetries: 3,
  apiVersion: 'v1',
  
  // Enterprise features
  sandbox: false,                    // Enable sandbox mode
  debug: true,                       // Enable debug logging
  structuredLogs: true,              // JSON format logs
  
  // Observability hooks
  onRequest: (request) => {
    console.log('Request:', request);
  },
  onResponse: (response) => {
    console.log('Response:', response);
  },
  onError: (error) => {
    console.error('Error:', error);
  },
  
  // Circuit breaker
  failureThreshold: 0.5,             // Open circuit at 50% failure rate
  windowSize: 10,                    // Track last 10 requests
  cooldownTime: 30000,               // 30 seconds cooldown
  
  // Rate limiting
  maxConcurrentRequests: 5,          // Max 5 concurrent requests
  
  // Validation limits
  maxAttachmentSize: 10 * 1024 * 1024,  // 10MB per attachment
  maxPayloadSize: 20 * 1024 * 1024,     // 20MB total
  maxSubjectLength: 998,                 // RFC 2822 limit
});

const result = await client.send({
  from: 'sender@yourdomain.com',
  to: 'recipient@example.com',
  subject: 'Email Subject',
  html: '<p>HTML content</p>',
  text: 'Plain text content',
  replyTo: 'reply@yourdomain.com',        // Optional
  headers: { 'X-Custom': 'value' },       // Optional
  tags: ['welcome', 'onboarding'],        // Optional
  attachments: [{                         // Optional
    filename: 'document.pdf',
    content: 'base64-encoded-content',
    contentType: 'application/pdf'
  }],
  idempotencyKey: 'unique-key-123'        // Optional (auto-generated if not provided)
});

console.log(result.id);     // Email ID
console.log(result.status); // queued, processing, sent, failed

await client.sendTemplate({
  template: 'welcome-email',
  to: 'newuser@example.com',
  from: 'welcome@yourdomain.com',
  data: {
    name: 'John Doe',
    activationLink: 'https://app.example.com/activate/abc123'
  }
});

const emails = [
  {
    from: 'sender@yourdomain.com',
    to: 'user1@example.com',
    subject: 'Welcome',
    html: '<p>Welcome user 1!</p>'
  },
  {
    from: 'sender@yourdomain.com',
    to: 'user2@example.com',
    subject: 'Welcome',
    html: '<p>Welcome user 2!</p>'
  }
];

const result = await client.sendBulk(emails);
console.log(result.batchId);

const email = await client.getEmail('email-log-id');

console.log(email.status);      // queued, processing, sent, failed
console.log(email.from);
console.log(email.to);
console.log(email.subject);
console.log(email.createdAt);
console.log(email.sentAt);
console.log(email.smtpResponse);

const results = await client.listEmails({
  status: 'sent',
  to: 'recipient@example.com',
  page: 1,
  limit: 50
});

console.log(results.total);
results.emails.forEach(email => {
  console.log(`${email.to}: ${email.status}`);
});

// Fetches all pages automatically
const allEmails = await client.listAllEmails({
  status: 'sent'
});

console.log(`Total: ${allEmails.length}`);

// Add domain
const domain = await client.addDomain({ domain: 'yourdomain.com' });

console.log('Add these DNS records:');
domain.dnsRecords.forEach(record => {
  console.log(`${record.type} ${record.name} ${record.value}`);
});

// Verify domain
const verification = await client.verifyDomain(domain.id);
console.log('Verified:', verification.verified);

// List domains
const domains = await client.listDomains();

// Add to suppression list
await client.suppressEmail('bounced@example.com', 'hard_bounce');

// List suppressions
const suppressions = await client.listSuppressions({ page: 1, limit: 50 });

// Remove from suppression list
await client.unsuppressEmail('bounced@example.com');

// In your webhook handler
app.post('/webhook', (req, res) => {
  const signature = req.headers['x-swiftmail-signature'];
  const payload = req.body;
  const secret = 'your-webhook-secret';
  
  if (client.verifyWebhook(signature, payload, secret)) {
    // Webhook is authentic
    console.log('Event:', payload.event);
    res.sendStatus(200);
  } else {
    // Invalid signature
    res.sendStatus(401);
  }
});

// Auto-generated key (recommended)
await client.send({
  from: 'orders@shop.com',
  to: 'customer@example.com',
  subject: 'Order Confirmation',
  html: '<p>Your order has been confirmed</p>'
});

// Custom key (for critical operations)
await client.send({
  from: 'orders@shop.com',
  to: 'customer@example.com',
  subject: 'Order Confirmation',
  html: '<p>Your order has been confirmed</p>',
  idempotencyKey: `order-${orderId}-confirmation`
});

// Check circuit state
console.log(client.getCircuitState()); // CLOSED, OPEN, or HALF_OPEN

// Circuit opens automatically when failure rate exceeds threshold
// Prevents cascading failures
// Auto-recovers after cooldown period

// Monitor queue
console.log('Queue size:', client.getQueueSize());
console.log('Running requests:', client.getRunningRequests());

// Requests are automatically queued when limit is reached
const promises = emails.map(email => client.send(email));
await Promise.all(promises); // Only 5 run concurrently (configurable)

const client = new SwiftMail('api-key', {
  onRequest: (request) => {
    // Send to DataDog, New Relic, etc.
    datadog.increment('swiftmail.request');
  },
  onResponse: (response) => {
    // Track successful requests
    datadog.increment('swiftmail.success');
  },
  onError: (error) => {
    // Send to Sentry, Rollbar, etc.
    sentry.captureException(error);
  }
});

const testClient = new SwiftMail('api-key', {
  sandbox: true
});

const result = await testClient.send({
  from: 'test@example.com',
  to: 'user@example.com',
  subject: 'Test',
  html: '<p>This will NOT be sent</p>'
});

console.log(result);
// { id: 'mock_uuid', status: 'queued', sandbox: true }

try {
  await client.send({
    from: 'invalid-email',
    to: 'user@example.com',
    subject: 'Test',
    html: '<p>Test</p>'
  });
} catch (error) {
  console.log('Message:', error.message);
  console.log('Code:', error.code);           // INVALID_EMAIL, MISSING_FIELD, etc.
  console.log('Status:', error.status);       // HTTP status code
  console.log('Request ID:', error.requestId); // For support
  console.log('Retryable:', error.retryable); // true/false
  
  if (error.retryable) {
    // Can retry manually if needed
  }
}

// Order confirmations, payment receipts, etc.
await client.send({
  from: 'orders@shop.com',
  to: customer.email,
  subject: 'Order Confirmation',
  html: orderTemplate,
  idempotencyKey: `order-${orderId}`
});

const client = new SwiftMail('api-key', {
  onError: (error) => {
    if (!error.retryable) {
      // Alert on non-retryable errors
      alerting.notify('SwiftMail error', error);
    }
  }
});

if (client.getCircuitState() === 'OPEN') {
  // Fallback: queue for later or use backup service
  await queueForLater(email);
} else {
  await client.send(email);
}

// SDK validates automatically, but you can pre-validate
if (!email.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)) {
  throw new Error('Invalid email');
}

const client = new SwiftMail(
  process.env.SWIFTMAIL_API_KEY,
  {
    sandbox: process.env.NODE_ENV !== 'production'
  }
);