/**
 * Alert Delivery Service
 * Handles sending alerts through multiple channels (Slack, PagerDuty, Email)
 */

import type { AlertLog, AlertTemplate } from '../db.alerts.schema.ts';
import { alertPersistenceService } from './alertPersistenceService.ts';

interface DeliveryResult {
  channel: 'slack' | 'email' | 'pagerduty';
  success: boolean;
  message: string;
  error?: string;
}

export class AlertDeliveryService {
  /**
   * Send alert through all configured channels
   */
  static async sendAlert(alert: AlertLog, template: AlertTemplate): Promise<DeliveryResult[]> {
    const results: DeliveryResult[] = [];

    // Send to Slack
    const slackResult = await this.sendToSlack(alert, template);
    results.push(slackResult);

    // Send to PagerDuty
    const pagerdutyResult = await this.sendToPagerDuty(alert, template);
    results.push(pagerdutyResult);

    // Send to Email
    const emailResult = await this.sendToEmail(alert, template);
    results.push(emailResult);

    return results;
  }

  /**
   * Send alert to Slack
   */
  static async sendToSlack(alert: AlertLog, template: AlertTemplate): Promise<DeliveryResult> {
    try {
      const slackWebhookUrl = process.env.SLACK_WEBHOOK_URL;
      if (!slackWebhookUrl) {
        return {
          channel: 'slack',
          success: false,
          message: 'Slack webhook not configured',
          error: 'Missing SLACK_WEBHOOK_URL environment variable',
        };
      }

      // Render template with alert data
      const variables = {
        severity: alert.severity,
        message: alert.message,
        team: alert.team || 'N/A',
        timestamp: new Date(alert.createdAt).toISOString(),
      };

      const renderedMessage = alertPersistenceService.renderTemplate(
        template.slackTemplate,
        variables
      );

      // Send to Slack
      const response = await fetch(slackWebhookUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          text: renderedMessage,
          blocks: [
            {
              type: 'section',
              text: {
                type: 'mrkdwn',
                text: renderedMessage,
              },
            },
            {
              type: 'context',
              elements: [
                {
                  type: 'mrkdwn',
                  text: `Alert ID: ${alert.id} | Team: ${alert.team || 'N/A'}`,
                },
              ],
            },
          ],
        }),
      });

      if (response.ok) {
        return {
          channel: 'slack',
          success: true,
          message: 'Alert sent to Slack successfully',
        };
      } else {
        return {
          channel: 'slack',
          success: false,
          message: 'Failed to send to Slack',
          error: `HTTP ${response.status}`,
        };
      }
    } catch (error) {
      return {
        channel: 'slack',
        success: false,
        message: 'Error sending to Slack',
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }

  /**
   * Send alert to PagerDuty
   */
  static async sendToPagerDuty(alert: AlertLog, template: AlertTemplate): Promise<DeliveryResult> {
    try {
      const pagerdutyIntegrationKey = process.env.PAGERDUTY_INTEGRATION_KEY;
      if (!pagerdutyIntegrationKey) {
        return {
          channel: 'pagerduty',
          success: false,
          message: 'PagerDuty integration not configured',
          error: 'Missing PAGERDUTY_INTEGRATION_KEY environment variable',
        };
      }

      // Render template with alert data
      const variables = {
        severity: alert.severity,
        message: alert.message,
        team: alert.team || 'N/A',
      };

      const renderedMessage = alertPersistenceService.renderTemplate(
        template.pagerdutyTemplate,
        variables
      );

      // Map severity to PagerDuty severity
      const pdSeverity = alert.severity === 'critical' ? 'critical' : 'warning';

      // Send to PagerDuty
      const response = await fetch('https://events.pagerduty.com/v2/enqueue', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          routing_key: pagerdutyIntegrationKey,
          event_action: 'trigger',
          dedup_key: alert.id,
          payload: {
            summary: renderedMessage,
            severity: pdSeverity,
            source: 'CoinKrazy Alert System',
            custom_details: {
              alert_id: alert.id,
              alert_type: alert.alertType,
              team: alert.team,
              timestamp: new Date(alert.createdAt).toISOString(),
            },
          },
        }),
      });

      if (response.ok) {
        return {
          channel: 'pagerduty',
          success: true,
          message: 'Alert sent to PagerDuty successfully',
        };
      } else {
        return {
          channel: 'pagerduty',
          success: false,
          message: 'Failed to send to PagerDuty',
          error: `HTTP ${response.status}`,
        };
      }
    } catch (error) {
      return {
        channel: 'pagerduty',
        success: false,
        message: 'Error sending to PagerDuty',
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }

  /**
   * Send alert via Email
   */
  static async sendToEmail(alert: AlertLog, template: AlertTemplate): Promise<DeliveryResult> {
    try {
      const emailRecipients = process.env.ALERT_EMAIL_RECIPIENTS;
      if (!emailRecipients) {
        return {
          channel: 'email',
          success: false,
          message: 'Email recipients not configured',
          error: 'Missing ALERT_EMAIL_RECIPIENTS environment variable',
        };
      }

      // Render template with alert data
      const variables = {
        severity: alert.severity,
        message: alert.message,
        team: alert.team || 'N/A',
        timestamp: new Date(alert.createdAt).toISOString(),
      };

      const renderedHtml = alertPersistenceService.renderTemplate(
        template.emailTemplate,
        variables
      );

      // Send email via Brevo (configured in environment)
      const brevoApiKey = process.env.BREVO_API_KEY;
      if (!brevoApiKey) {
        return {
          channel: 'email',
          success: false,
          message: 'Email service not configured',
          error: 'Missing BREVO_API_KEY',
        };
      }

      const recipients = emailRecipients.split(',').map((email) => ({
        email: email.trim(),
      }));

      const response = await fetch('https://api.brevo.com/v3/smtp/email', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'api-key': brevoApiKey,
        },
        body: JSON.stringify({
          to: recipients,
          subject: `[${alert.severity.toUpperCase()}] ${template.title}`,
          htmlContent: `
            <html>
              <body style="font-family: Arial, sans-serif; line-height: 1.6;">
                <h1 style="color: ${alert.severity === 'critical' ? '#dc2626' : '#f59e0b'};">
                  ${template.title}
                </h1>
                ${renderedHtml}
                <hr style="margin: 20px 0;">
                <p style="color: #666; font-size: 12px;">
                  Alert ID: ${alert.id}<br>
                  Team: ${alert.team || 'N/A'}<br>
                  Time: ${new Date(alert.createdAt).toISOString()}
                </p>
              </body>
            </html>
          `,
        }),
      });

      if (response.ok) {
        return {
          channel: 'email',
          success: true,
          message: `Alert sent to ${recipients.length} email recipient(s)`,
        };
      } else {
        return {
          channel: 'email',
          success: false,
          message: 'Failed to send email',
          error: `HTTP ${response.status}`,
        };
      }
    } catch (error) {
      return {
        channel: 'email',
        success: false,
        message: 'Error sending email',
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }

  /**
   * Retry failed deliveries
   */
  static async retryFailedDeliveries(): Promise<{ retried: number; successful: number }> {
    // Mock implementation - would query database for failed deliveries
    return { retried: 0, successful: 0 };
  }

  /**
   * Get delivery statistics
   */
  static getDeliveryStats(): {
    totalSent: number;
    successRate: number;
    byChannel: Record<string, { sent: number; success: number }>;
  } {
    // Mock implementation - would query database
    return {
      totalSent: 156,
      successRate: 0.94,
      byChannel: {
        slack: { sent: 52, success: 50 },
        email: { sent: 52, success: 49 },
        pagerduty: { sent: 52, success: 50 },
      },
    };
  }
}

export const alertDeliveryService = new AlertDeliveryService();