/**
 * Monitoring and Alerting tRPC Router
 * Provides endpoints for real-time monitoring, metrics, and health status
 */

import { router, protectedProcedure } from '../_core/trpc.ts';
import { z } from 'zod';
import { websocketMonitoringService } from '../services/websocketMonitoring.ts';

export const monitoringRouter = router({
  /**
   * Get current WebSocket metrics
   */
  getMetrics: protectedProcedure
    .input(z.object({ hours: z.number().default(24) }))
    .query(({ input }) => {
      const metrics = websocketMonitoringService.getMetrics(input.hours);
      const latest = metrics[metrics.length - 1];

      return {
        latest,
        average: {
          connections: websocketMonitoringService.getAverageConnections(input.hours),
          latency: websocketMonitoringService.getAverageLatency(input.hours),
        },
        peak: {
          connections: websocketMonitoringService.getPeakConnections(input.hours),
        },
        history: metrics,
      };
    }),

  /**
   * Get delivery failure statistics
   */
  getDeliveryFailures: protectedProcedure
    .input(z.object({ hours: z.number().default(24) }))
    .query(({ input }) => {
      return websocketMonitoringService.getDeliveryFailureRate(input.hours);
    }),

  /**
   * Get forecast accuracy summary
   */
  getForecastAccuracy: protectedProcedure
    .input(z.object({ hours: z.number().default(24) }))
    .query(({ input }) => {
      return websocketMonitoringService.getForecastAccuracySummary(input.hours);
    }),

  /**
   * Get overall health status
   */
  getHealthStatus: protectedProcedure.query(() => {
    return websocketMonitoringService.getHealthStatus();
  }),

  /**
   * Record WebSocket metrics (called by monitoring service)
   */
  recordMetrics: protectedProcedure
    .input(
      z.object({
        activeConnections: z.number(),
        activityFeedConnections: z.number(),
        revenueForecastConnections: z.number(),
        messagesSent: z.number(),
        messagesReceived: z.number(),
        averageLatency: z.number(),
        errorCount: z.number(),
      })
    )
    .mutation(({ input }) => {
      websocketMonitoringService.recordMetrics(input);
      return { success: true };
    }),

  /**
   * Record delivery alert
   */
  recordDeliveryAlert: protectedProcedure
    .input(
      z.object({
        type: z.enum(['email_failure', 'sms_failure', 'forecast_error']),
        severity: z.enum(['low', 'medium', 'high', 'critical']),
        message: z.string(),
        details: z.any().optional(),
      })
    )
    .mutation(({ input }) => {
      websocketMonitoringService.recordDeliveryAlert(input);
      return { success: true };
    }),

  /**
   * Record forecast accuracy alert
   */
  recordAccuracyAlert: protectedProcedure
    .input(
      z.object({
        modelType: z.string(),
        accuracy: z.number(),
        threshold: z.number(),
        drift: z.number(),
        recommendation: z.string(),
      })
    )
    .mutation(({ input }) => {
      websocketMonitoringService.recordAccuracyAlert(input);
      return { success: true };
    }),

  /**
   * Get connection health timeline
   */
  getConnectionTimeline: protectedProcedure
    .input(z.object({ hours: z.number().default(24) }))
    .query(({ input }) => {
      const metrics = websocketMonitoringService.getMetrics(input.hours);
      return metrics.map((m) => ({
        timestamp: m.timestamp,
        activeConnections: m.activeConnections,
        activityFeedConnections: m.activityFeedConnections,
        revenueForecastConnections: m.revenueForecastConnections,
        averageLatency: m.averageLatency,
        errorCount: m.errorCount,
      }));
    }),

  /**
   * Get delivery performance metrics
   */
  getDeliveryPerformance: protectedProcedure
    .input(z.object({ hours: z.number().default(24) }))
    .query(({ input }) => {
      const failures = websocketMonitoringService.getDeliveryFailureRate(input.hours);
      const successRate = 100 - (failures.totalFailures > 0 ? (failures.totalFailures / 100) * 100 : 0);

      return {
        emailSuccessRate: 100 - (failures.emailFailures > 0 ? (failures.emailFailures / 100) * 100 : 0),
        smsSuccessRate: 100 - (failures.smsFailures > 0 ? (failures.smsFailures / 100) * 100 : 0),
        overallSuccessRate: successRate,
        totalFailures: failures.totalFailures,
        emailFailures: failures.emailFailures,
        smsFailures: failures.smsFailures,
      };
    }),

  /**
   * Get forecast model performance
   */
  getModelPerformance: protectedProcedure
    .input(z.object({ hours: z.number().default(24) }))
    .query(({ input }) => {
      const summary = websocketMonitoringService.getForecastAccuracySummary(input.hours);
      return summary.map((model) => ({
        modelType: model.modelType,
        currentAccuracy: model.currentAccuracy,
        avgAccuracy: model.avgAccuracy,
        trend: model.trend,
        status:
          model.currentAccuracy >= 85
            ? 'excellent'
            : model.currentAccuracy >= 75
              ? 'good'
              : model.currentAccuracy >= 65
                ? 'fair'
                : 'poor',
      }));
    }),
});