// WebSocket manager removed - using in-memory alert storage instead

export type AlertType = 'approval' | 'deployment' | 'performance' | 'error' | 'info';
export type AlertSeverity = 'low' | 'medium' | 'high' | 'critical';

export interface AdminAlert {
  id: string;
  type: AlertType;
  severity: AlertSeverity;
  title: string;
  message: string;
  timestamp: Date;
  read: boolean;
  metadata?: Record<string, any>;
  actionUrl?: string;
}

/**
 * Emit alert to all connected admin clients
 */
export function emitAdminAlert(
  type: AlertType,
  title: string,
  message: string,
  options?: {
    severity?: AlertSeverity;
    metadata?: Record<string, any>;
    actionUrl?: string;
  }
): AdminAlert {
  const alert: AdminAlert = {
    id: `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
    type,
    severity: options?.severity || 'medium',
    title,
    message,
    timestamp: new Date(),
    read: false,
    metadata: options?.metadata,
    actionUrl: options?.actionUrl
  };

  // Alert stored in memory for retrieval via tRPC
  // In production, this would broadcast to WebSocket clients
  // console.log(`[AlertEmitter] Broadcasting to admins: ${title}`);

  console.log(`[AlertEmitter] Emitted ${type} alert: ${title}`);
  return alert;
}

/**
 * Alert templates for common admin scenarios
 */
export const AlertTemplates = {
  /**
   * Game approval alerts
   */
  gameApproved: (gameName: string, approverName: string) =>
    emitAdminAlert('approval', 'Game Approved ✓', `${gameName} has been approved by ${approverName}`, {
      severity: 'low',
      metadata: { gameName, approverName },
      actionUrl: '/admin/games-manager'
    }),

  gameRejected: (gameName: string, reason: string) =>
    emitAdminAlert('approval', 'Game Rejected ✗', `${gameName} was rejected: ${reason}`, {
      severity: 'high',
      metadata: { gameName, reason },
      actionUrl: '/admin/games-manager'
    }),

  /**
   * Deployment alerts
   */
  deploymentStarted: (version: string) =>
    emitAdminAlert('deployment', 'Deployment Started 🚀', `Deploying version ${version}...`, {
      severity: 'low',
      metadata: { version },
      actionUrl: '/admin/deployments'
    }),

  deploymentCompleted: (version: string, duration: number) =>
    emitAdminAlert('deployment', 'Deployment Completed ✓', `Version ${version} deployed successfully in ${duration}s`, {
      severity: 'low',
      metadata: { version, duration },
      actionUrl: '/admin/deployments'
    }),

  deploymentFailed: (version: string, error: string) =>
    emitAdminAlert('deployment', 'Deployment Failed ✗', `Version ${version} deployment failed: ${error}`, {
      severity: 'critical',
      metadata: { version, error },
      actionUrl: '/admin/deployments'
    }),

  /**
   * Payment alerts
   */
  paymentProcessed: (amount: number, currency: string, userId: number) =>
    emitAdminAlert('info', 'Payment Processed 💳', `$${amount} ${currency} payment processed for user #${userId}`, {
      severity: 'low',
      metadata: { amount, currency, userId },
      actionUrl: '/admin/payments-banking'
    }),

  paymentFailed: (amount: number, currency: string, reason: string) =>
    emitAdminAlert('error', 'Payment Failed ✗', `Payment of $${amount} ${currency} failed: ${reason}`, {
      severity: 'high',
      metadata: { amount, currency, reason },
      actionUrl: '/admin/payments-banking'
    }),

  /**
   * KYC alerts
   */
  kycSubmitted: (userName: string, userId: number) =>
    emitAdminAlert('approval', 'KYC Submitted', `${userName} (ID: ${userId}) submitted KYC documents`, {
      severity: 'medium',
      metadata: { userName, userId },
      actionUrl: '/admin/kyc-review'
    }),

  kycApproved: (userName: string, userId: number) =>
    emitAdminAlert('approval', 'KYC Approved ✓', `${userName} (ID: ${userId}) KYC verification approved`, {
      severity: 'low',
      metadata: { userName, userId },
      actionUrl: '/admin/kyc-review'
    }),

  kycRejected: (userName: string, userId: number, reason: string) =>
    emitAdminAlert('approval', 'KYC Rejected ✗', `${userName} (ID: ${userId}) KYC rejected: ${reason}`, {
      severity: 'high',
      metadata: { userName, userId, reason },
      actionUrl: '/admin/kyc-review'
    }),

  /**
   * Fraud alerts
   */
  fraudDetected: (type: string, userId: number, details: string) =>
    emitAdminAlert('error', 'Fraud Detected 🚨', `Potential ${type} fraud detected for user #${userId}: ${details}`, {
      severity: 'critical',
      metadata: { type, userId, details },
      actionUrl: '/admin/fraud-detection'
    }),

  /**
   * Performance alerts
   */
  highErrorRate: (errorRate: number, threshold: number) =>
    emitAdminAlert('performance', 'High Error Rate ⚠️', `Error rate is ${errorRate}% (threshold: ${threshold}%)`, {
      severity: 'high',
      metadata: { errorRate, threshold },
      actionUrl: '/admin/performance-monitoring'
    }),

  highLatency: (latency: number, threshold: number) =>
    emitAdminAlert('performance', 'High Latency ⚠️', `API latency is ${latency}ms (threshold: ${threshold}ms)`, {
      severity: 'medium',
      metadata: { latency, threshold },
      actionUrl: '/admin/performance-monitoring'
    }),

  /**
   * System alerts
   */
  maintenanceStarted: (duration: number) =>
    emitAdminAlert('info', 'Maintenance Started 🔧', `System maintenance started. Expected duration: ${duration} minutes`, {
      severity: 'medium',
      metadata: { duration },
      actionUrl: '/admin/settings'
    }),

  maintenanceCompleted: () =>
    emitAdminAlert('info', 'Maintenance Completed ✓', 'System maintenance completed successfully', {
      severity: 'low',
      actionUrl: '/admin/settings'
    }),

  /**
   * User alerts
   */
  userBanned: (userName: string, userId: number, reason: string) =>
    emitAdminAlert('approval', 'User Banned', `${userName} (ID: ${userId}) has been banned: ${reason}`, {
      severity: 'high',
      metadata: { userName, userId, reason },
      actionUrl: '/admin/users'
    }),

  userUnbanned: (userName: string, userId: number) =>
    emitAdminAlert('approval', 'User Unbanned ✓', `${userName} (ID: ${userId}) has been unbanned`, {
      severity: 'low',
      metadata: { userName, userId },
      actionUrl: '/admin/users'
    }),

  /**
   * Campaign alerts
   */
  campaignLaunched: (campaignName: string, targetUsers: number) =>
    emitAdminAlert('info', 'Campaign Launched 🚀', `${campaignName} launched to ${targetUsers} users`, {
      severity: 'low',
      metadata: { campaignName, targetUsers },
      actionUrl: '/admin/email-campaigns'
    }),

  campaignCompleted: (campaignName: string, successRate: number) =>
    emitAdminAlert('info', 'Campaign Completed ✓', `${campaignName} completed with ${successRate}% success rate`, {
      severity: 'low',
      metadata: { campaignName, successRate },
      actionUrl: '/admin/email-campaigns'
    })
};

/**
 * Emit alert (alias for emitAdminAlert for backward compatibility)
 */
export function emitAlert(
  options: {
    type: AlertType;
    title: string;
    message: string;
    severity?: AlertSeverity;
    metadata?: Record<string, any>;
    actionUrl?: string;
  }
): AdminAlert {
  return emitAdminAlert(options.type, options.title, options.message, {
    severity: options.severity,
    metadata: options.metadata,
    actionUrl: options.actionUrl
  });
}

/**
 * Custom alert for specific scenarios
 */
export function emitCustomAlert(
  type: AlertType,
  title: string,
  message: string,
  severity: AlertSeverity = 'medium',
  metadata?: Record<string, any>,
  actionUrl?: string
): AdminAlert {
  return emitAdminAlert(type, title, message, {
    severity,
    metadata,
    actionUrl
  });
}