/**
 * Alert Triggers tRPC Router
 * Handles alert trigger configuration and management
 */

import { router, protectedProcedure, adminProcedure } from '../_core/trpc.ts';
import { z } from 'zod';
import { TRPCError } from '@trpc/server';
import { alertTriggerService } from '../services/alertTriggerService.ts';
import { alertPersistenceService } from '../services/alertPersistenceService.ts';

// Mock implementation - replace with actual database calls
const mockAlertPersistenceService = {
  logAlert: async (alert: any) => alert,
  getAlert: async (id: string) => null,
  getTemplate: async (type: string) => null,
  updateAlertStatus: async (id: string, status: string, time: number) => true,
};

const persistenceService = alertPersistenceService || mockAlertPersistenceService;

export const alertTriggersRouter = router({
  /**
   * Get all configured alert thresholds
   */
  getThresholds: protectedProcedure.query(async () => {
    return alertTriggerService.getThresholds();
  }),

  /**
   * Update alert threshold (admin only)
   */
  updateThreshold: adminProcedure
    .input(
      z.object({
        alertType: z.string(),
        metric: z.string(),
        operator: z.enum(['gt', 'lt', 'gte', 'lte', 'eq']),
        value: z.number(),
        severity: z.enum(['critical', 'warning', 'info']),
      })
    )
    .mutation(async ({ input }) => {
      alertTriggerService.updateThreshold(input.alertType, {
        metric: input.metric,
        operator: input.operator,
        value: input.value,
        severity: input.severity,
      });

      return { success: true, message: 'Threshold updated successfully' };
    }),

  /**
   * Get active alerts
   */
  getActiveAlerts: protectedProcedure.query(async () => {
    return alertTriggerService.getActiveAlerts();
  }),

  /**
   * Check metrics and trigger alerts
   */
  checkMetrics: adminProcedure.mutation(async () => {
    const alerts = await alertTriggerService.checkMetrics();
    return {
      triggered: alerts.length,
      alerts: alerts.map((a) => ({
        id: a.id,
        type: a.alertType,
        severity: a.severity,
        message: a.message,
      })),
    };
  }),

  /**
   * Resolve alert
   */
  resolveAlert: protectedProcedure
    .input(z.object({ alertId: z.string() }))
    .mutation(async ({ input }) => {
      const success = await alertTriggerService.resolveAlert(input.alertId);
      return { success, message: success ? 'Alert resolved' : 'Failed to resolve alert' };
    }),

  /**
   * Acknowledge alert
   */
  acknowledgeAlert: protectedProcedure
    .input(z.object({ alertId: z.string() }))
    .mutation(async ({ input }) => {
      const success = await alertTriggerService.acknowledgeAlert(input.alertId);
      return { success, message: success ? 'Alert acknowledged' : 'Failed to acknowledge alert' };
    }),

  /**
   * Get alert history
   */
  getAlertHistory: protectedProcedure
    .input(
      z.object({
        limit: z.number().default(50),
        offset: z.number().default(0),
        severity: z.enum(['critical', 'warning', 'info']).optional(),
        status: z.enum(['active', 'acknowledged', 'resolved']).optional(),
      })
    )
    .query(async ({ input }) => {
      // Mock implementation - would query database
      return {
        total: 156,
        alerts: [
          {
            id: 'alert-001',
            type: 'latency_critical',
            severity: 'critical',
            status: 'resolved',
            message: 'WebSocket latency exceeded 500ms',
            createdAt: Date.now() - 3600000,
            resolvedAt: Date.now() - 1800000,
          },
        ],
      };
    }),

  /**
   * Get alert statistics
   */
  getAlertStats: protectedProcedure.query(async () => {
    return {
      totalAlerts: 156,
      activeAlerts: alertTriggerService.getActiveAlerts().length,
      bySeverity: {
        critical: 2,
        warning: 8,
        info: 5,
      },
      byStatus: {
        active: 5,
        acknowledged: 8,
        resolved: 143,
      },
      averageResolutionTime: 1200000, // milliseconds
    };
  }),

  /**
   * Start continuous monitoring
   */
  startMonitoring: adminProcedure
    .input(z.object({ intervalMs: z.number().default(60000) }))
    .mutation(async ({ input }) => {
      const timer = alertTriggerService.startMonitoring(input.intervalMs);
      return {
        success: true,
        message: `Monitoring started with ${input.intervalMs}ms interval`,
        timerId: timer.ref?.toString() || 'monitoring-active',
      };
    }),

  /**
   * Get monitoring status
   */
  getMonitoringStatus: protectedProcedure.query(async () => {
    const activeAlerts = alertTriggerService.getActiveAlerts();
    return {
      isMonitoring: true,
      activeAlerts: activeAlerts.length,
      lastCheck: Date.now(),
      nextCheck: Date.now() + 60000,
    };
  }),

  /**
   * Bulk resolve alerts
   */
  bulkResolveAlerts: adminProcedure
    .input(z.object({ alertIds: z.array(z.string()) }))
    .mutation(async ({ input }) => {
      let resolved = 0;
      for (const alertId of input.alertIds) {
        if (await alertTriggerService.resolveAlert(alertId)) {
          resolved++;
        }
      }
      return { success: true, resolved, total: input.alertIds.length };
    }),

  /**
   * Bulk acknowledge alerts
   */
  bulkAcknowledgeAlerts: adminProcedure
    .input(z.object({ alertIds: z.array(z.string()) }))
    .mutation(async ({ input }) => {
      let acknowledged = 0;
      for (const alertId of input.alertIds) {
        if (await alertTriggerService.acknowledgeAlert(alertId)) {
          acknowledged++;
        }
      }
      return { success: true, acknowledged, total: input.alertIds.length };
    }),
});