/**
 * Alert Persistence Service
 * Handles database operations for alerts, logs, and templates
 */

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

interface CreateAlertInput {
  alertType: string;
  severity: 'critical' | 'warning' | 'info';
  message: string;
  team?: string;
}

interface UpdateAlertInput {
  status?: 'active' | 'acknowledged' | 'resolved';
  acknowledgedAt?: number;
  resolvedAt?: number;
  escalationCount?: number;
}

interface CreateTemplateInput {
  alertType: string;
  title: string;
  description?: string;
  slackTemplate: string;
  emailTemplate: string;
  pagerdutyTemplate: string;
  variables?: string[];
  severity: 'critical' | 'warning' | 'info';
}

export class AlertPersistenceService {
  /**
   * Create a new alert log entry
   */
  static createAlert(input: CreateAlertInput): AlertLog {
    const now = Date.now();
    const id = `alert-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    return {
      id,
      alertType: input.alertType,
      severity: input.severity,
      message: input.message,
      status: 'active',
      team: input.team,
      escalationCount: 0,
      acknowledgedAt: undefined,
      resolvedAt: undefined,
      createdAt: now,
      updatedAt: now,
    } as AlertLog;
  }

  /**
   * Update alert status
   */
  static updateAlert(alert: AlertLog, updates: UpdateAlertInput): AlertLog {
    return {
      ...alert,
      ...updates,
      updatedAt: Date.now(),
    };
  }

  /**
   * Log alert delivery attempt
   */
  static logDelivery(
    alertId: string,
    channel: 'slack' | 'email' | 'pagerduty',
    recipient: string,
    success: boolean,
    error?: string
  ): AlertDeliveryLog {
    const id = `delivery-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    return {
      id,
      alertId,
      channel,
      status: success ? 'sent' : 'failed',
      recipient,
      error,
      retryCount: 0,
      nextRetryAt: success ? undefined : Date.now() + 5 * 60 * 1000, // 5 min retry
      sentAt: success ? Date.now() : undefined,
      createdAt: Date.now(),
    } as AlertDeliveryLog;
  }

  /**
   * Create notification template
   */
  static createTemplate(input: CreateTemplateInput): AlertTemplate {
    const now = Date.now();
    const id = `template-${input.alertType}-${Date.now()}`;

    return {
      id,
      alertType: input.alertType,
      title: input.title,
      description: input.description,
      slackTemplate: input.slackTemplate,
      emailTemplate: input.emailTemplate,
      pagerdutyTemplate: input.pagerdutyTemplate,
      variables: input.variables ? JSON.stringify(input.variables) : '[]',
      severity: input.severity,
      enabled: 1,
      createdAt: now,
      updatedAt: now,
    } as AlertTemplate;
  }

  /**
   * Get template for alert type
   */
  static getTemplateForAlertType(alertType: string): AlertTemplate | null {
    // Mock implementation - would query database
    const defaultTemplates: Record<string, AlertTemplate> = {
      latency_critical: {
        id: 'template-latency-critical',
        alertType: 'latency_critical',
        title: 'Critical Latency Alert',
        description: 'WebSocket latency exceeded threshold',
        slackTemplate: '🚨 *Critical Latency Alert*\nLatency: {{latency}}ms\nThreshold: {{threshold}}ms',
        emailTemplate: '<h2>Critical Latency Alert</h2><p>Latency: {{latency}}ms</p>',
        pagerdutyTemplate: 'Critical Latency: {{latency}}ms',
        variables: '["latency","threshold"]',
        severity: 'critical',
        enabled: 1,
        createdAt: Date.now(),
        updatedAt: Date.now(),
      },
      delivery_failure: {
        id: 'template-delivery-failure',
        alertType: 'delivery_failure',
        title: 'Delivery Failure Alert',
        description: 'Email/SMS delivery rate degraded',
        slackTemplate: '⚠️ *Delivery Failure Alert*\nSuccess Rate: {{successRate}}%\nChannel: {{channel}}',
        emailTemplate: '<h2>Delivery Failure Alert</h2><p>Success Rate: {{successRate}}%</p>',
        pagerdutyTemplate: 'Delivery Failure: {{channel}} at {{successRate}}%',
        variables: '["successRate","channel"]',
        severity: 'warning',
        enabled: 1,
        createdAt: Date.now(),
        updatedAt: Date.now(),
      },
      forecast_accuracy_degrading: {
        id: 'template-forecast-accuracy',
        alertType: 'forecast_accuracy_degrading',
        title: 'Forecast Accuracy Degraded',
        description: 'Revenue forecast model accuracy below threshold',
        slackTemplate: '📊 *Forecast Accuracy Alert*\nAccuracy: {{accuracy}}%\nThreshold: {{threshold}}%',
        emailTemplate: '<h2>Forecast Accuracy Alert</h2><p>Accuracy: {{accuracy}}%</p>',
        pagerdutyTemplate: 'Forecast Accuracy: {{accuracy}}%',
        variables: '["accuracy","threshold"]',
        severity: 'warning',
        enabled: 1,
        createdAt: Date.now(),
        updatedAt: Date.now(),
      },
    };

    return defaultTemplates[alertType] || null;
  }

  /**
   * Render template with variables
   */
  static renderTemplate(template: string, variables: Record<string, string | number>): string {
    let rendered = template;
    Object.entries(variables).forEach(([key, value]) => {
      rendered = rendered.replace(new RegExp(`{{${key}}}`, 'g'), String(value));
    });
    return rendered;
  }

  /**
   * Record template usage
   */
  static recordTemplateUsage(
    templateId: string,
    alertId: string,
    success: boolean,
    acknowledgedWithin?: number,
    resolvedWithin?: number
  ): AlertTemplateUsage {
    const id = `usage-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    return {
      id,
      templateId,
      alertId,
      usedAt: Date.now(),
      deliverySuccess: success ? 1 : 0,
      acknowledgedWithin,
      resolvedWithin,
    } as AlertTemplateUsage;
  }

  /**
   * Get template effectiveness metrics
   */
  static getTemplateMetrics(templateId: string): {
    totalUsed: number;
    successRate: number;
    avgAcknowledgeTime: number;
    avgResolveTime: number;
  } {
    // Mock implementation - would query database
    return {
      totalUsed: 42,
      successRate: 0.95,
      avgAcknowledgeTime: 5, // minutes
      avgResolveTime: 15, // minutes
    };
  }

  /**
   * Get alert history with filters
   */
  static getAlertHistory(filters: {
    severity?: string;
    status?: string;
    team?: string;
    limit?: number;
  }): AlertLog[] {
    // Mock implementation - would query database
    const mockAlerts: AlertLog[] = [
      {
        id: 'alert-001',
        alertType: 'latency_critical',
        severity: 'critical',
        message: 'WebSocket latency exceeded 500ms threshold',
        status: 'resolved',
        team: 'ops',
        escalationCount: 2,
        acknowledgedAt: Date.now() - 10 * 60 * 1000,
        resolvedAt: Date.now() - 5 * 60 * 1000,
        createdAt: Date.now() - 15 * 60 * 1000,
        updatedAt: Date.now() - 5 * 60 * 1000,
      },
    ];

    return mockAlerts.filter((alert) => {
      if (filters.severity && alert.severity !== filters.severity) return false;
      if (filters.status && alert.status !== filters.status) return false;
      if (filters.team && alert.team !== filters.team) return false;
      return true;
    });
  }
}

export const alertPersistenceService = new AlertPersistenceService();