import { getDb } from '../db.ts';
import { adminNotifications } from '../../drizzle/schema.ts';
import { adminNotificationBroadcaster } from './websocket.ts';
import { webhookManager } from './webhooks.ts';

class NotificationTriggerManager {
  /**
   * Trigger fraud alert notification
   */
  async triggerFraudAlert(data: {
    userId: number;
    fraudType: string;
    riskScore: number;
    details: string;
    evidence?: any;
  }) {
    const db = await getDb();
    if (!db) return;

    const severity = data.riskScore > 80 ? 'critical' : data.riskScore > 60 ? 'high' : 'medium';

    // Create notification record
    await db.insert(adminNotifications).values({
      type: 'fraud_alert',
      title: `Fraud Alert: ${data.fraudType}`,
      message: `User ${data.userId} flagged for ${data.fraudType}. Risk Score: ${data.riskScore}%`,
      severity,
      relatedUserId: data.userId,
      relatedEntityType: 'user',
      data: {
        fraudType: data.fraudType,
        riskScore: data.riskScore,
        details: data.details,
        evidence: data.evidence,
      },
      actionUrl: `/admin/users/${data.userId}`,
    });

    // Broadcast via WebSocket
    adminNotificationBroadcaster.broadcast({
      type: 'fraud_alert',
      title: `Fraud Alert: ${data.fraudType}`,
      message: `User ${data.userId} flagged for ${data.fraudType}. Risk Score: ${data.riskScore}%`,
      severity,
      data,
    });

    // Send webhook
    await webhookManager.broadcastEvent('fraud_alert', {
      userId: data.userId,
      fraudType: data.fraudType,
      riskScore: data.riskScore,
      details: data.details,
      timestamp: new Date().toISOString(),
    });

    console.log(`[Notifications] Fraud alert triggered for user ${data.userId}`);
  }

  /**
   * Trigger large win notification
   */
  async triggerLargeWin(data: {
    userId: number;
    gameId: string;
    gameName: string;
    winAmount: number;
    multiplier: number;
    timestamp: Date;
  }) {
    const db = await getDb();
    if (!db) return;

    const severity = data.winAmount > 10000 ? 'critical' : data.winAmount > 5000 ? 'high' : 'medium';

    // Create notification record
    await db.insert(adminNotifications).values({
      type: 'large_win',
      title: `Large Win: $${data.winAmount.toFixed(2)}`,
      message: `User ${data.userId} won $${data.winAmount.toFixed(2)} on ${data.gameName} with ${data.multiplier}x multiplier`,
      severity,
      relatedUserId: data.userId,
      relatedEntityId: data.gameId,
      relatedEntityType: 'game',
      data,
      actionUrl: `/admin/users/${data.userId}`,
    });

    // Broadcast via WebSocket
    adminNotificationBroadcaster.broadcast({
      type: 'large_win',
      title: `Large Win: $${data.winAmount.toFixed(2)}`,
      message: `User ${data.userId} won $${data.winAmount.toFixed(2)} on ${data.gameName}`,
      severity,
      data,
    });

    // Send webhook
    await webhookManager.broadcastEvent('large_win', {
      userId: data.userId,
      gameId: data.gameId,
      gameName: data.gameName,
      winAmount: data.winAmount,
      multiplier: data.multiplier,
      timestamp: data.timestamp.toISOString(),
    });

    console.log(`[Notifications] Large win triggered for user ${data.userId}: $${data.winAmount}`);
  }

  /**
   * Trigger KYC pending notification
   */
  async triggerKYCPending(data: {
    userId: number;
    documentType: string;
    submittedAt: Date;
  }) {
    const db = await getDb();
    if (!db) return;

    await db.insert(adminNotifications).values({
      type: 'kyc_pending',
      title: 'KYC Document Pending Review',
      message: `User ${data.userId} submitted ${data.documentType} for KYC verification`,
      severity: 'medium',
      relatedUserId: data.userId,
      relatedEntityType: 'kyc',
      data,
      actionUrl: `/admin/kyc/${data.userId}`,
    });

    // Broadcast via WebSocket
    adminNotificationBroadcaster.broadcast({
      type: 'kyc_pending',
      title: 'KYC Document Pending Review',
      message: `User ${data.userId} submitted ${data.documentType} for KYC verification`,
      severity: 'medium',
      data,
    });

    // Send webhook
    await webhookManager.broadcastEvent('kyc_pending', {
      userId: data.userId,
      documentType: data.documentType,
      submittedAt: data.submittedAt.toISOString(),
    });

    console.log(`[Notifications] KYC pending triggered for user ${data.userId}`);
  }

  /**
   * Trigger KYC approved notification
   */
  async triggerKYCApproved(data: {
    userId: number;
    approvedBy: number;
    approvedAt: Date;
  }) {
    const db = await getDb();
    if (!db) return;

    await db.insert(adminNotifications).values({
      type: 'kyc_approved',
      title: 'KYC Approved',
      message: `User ${data.userId} KYC verification approved by admin ${data.approvedBy}`,
      severity: 'low',
      relatedUserId: data.userId,
      relatedEntityType: 'kyc',
      data,
      actionUrl: `/admin/users/${data.userId}`,
    });

    // Broadcast via WebSocket
    adminNotificationBroadcaster.broadcast({
      type: 'kyc_approved',
      title: 'KYC Approved',
      message: `User ${data.userId} KYC verification approved`,
      severity: 'low',
      data,
    });

    // Send webhook
    await webhookManager.broadcastEvent('kyc_approved', {
      userId: data.userId,
      approvedBy: data.approvedBy,
      approvedAt: data.approvedAt.toISOString(),
    });

    console.log(`[Notifications] KYC approved for user ${data.userId}`);
  }

  /**
   * Trigger KYC rejected notification
   */
  async triggerKYCRejected(data: {
    userId: number;
    rejectedBy: number;
    reason: string;
    rejectedAt: Date;
  }) {
    const db = await getDb();
    if (!db) return;

    await db.insert(adminNotifications).values({
      type: 'kyc_rejected',
      title: 'KYC Rejected',
      message: `User ${data.userId} KYC verification rejected: ${data.reason}`,
      severity: 'high',
      relatedUserId: data.userId,
      relatedEntityType: 'kyc',
      data,
      actionUrl: `/admin/users/${data.userId}`,
    });

    // Broadcast via WebSocket
    adminNotificationBroadcaster.broadcast({
      type: 'kyc_rejected',
      title: 'KYC Rejected',
      message: `User ${data.userId} KYC verification rejected`,
      severity: 'high',
      data,
    });

    // Send webhook
    await webhookManager.broadcastEvent('kyc_rejected', {
      userId: data.userId,
      rejectedBy: data.rejectedBy,
      reason: data.reason,
      rejectedAt: data.rejectedAt.toISOString(),
    });

    console.log(`[Notifications] KYC rejected for user ${data.userId}`);
  }

  /**
   * Trigger system alert notification
   */
  async triggerSystemAlert(data: {
    title: string;
    message: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    details?: any;
  }) {
    const db = await getDb();
    if (!db) return;

    await db.insert(adminNotifications).values({
      type: 'system_alert',
      title: data.title,
      message: data.message,
      severity: data.severity,
      relatedEntityType: 'system',
      data: data.details,
    });

    // Broadcast to all admins
    adminNotificationBroadcaster.broadcastToAll({
      type: 'system_alert',
      title: data.title,
      message: data.message,
      severity: data.severity,
      data: data.details,
    });

    // Send webhook
    await webhookManager.broadcastEvent('system_alert', {
      title: data.title,
      message: data.message,
      severity: data.severity,
      timestamp: new Date().toISOString(),
    });

    console.log(`[Notifications] System alert triggered: ${data.title}`);
  }

  /**
   * Trigger payment issue notification
   */
  async triggerPaymentIssue(data: {
    userId: number;
    transactionId: string;
    issueType: string;
    amount: number;
    details: string;
  }) {
    const db = await getDb();
    if (!db) return;

    await db.insert(adminNotifications).values({
      type: 'payment_issue',
      title: `Payment Issue: ${data.issueType}`,
      message: `Payment issue for user ${data.userId}: ${data.details}`,
      severity: 'high',
      relatedUserId: data.userId,
      relatedEntityId: data.transactionId,
      relatedEntityType: 'payment',
      data,
      actionUrl: `/admin/payments/${data.transactionId}`,
    });

    // Broadcast via WebSocket
    adminNotificationBroadcaster.broadcast({
      type: 'payment_issue',
      title: `Payment Issue: ${data.issueType}`,
      message: `Payment issue for user ${data.userId}: ${data.details}`,
      severity: 'high',
      data,
    });

    // Send webhook
    await webhookManager.broadcastEvent('payment_issue', {
      userId: data.userId,
      transactionId: data.transactionId,
      issueType: data.issueType,
      amount: data.amount,
      details: data.details,
      timestamp: new Date().toISOString(),
    });

    console.log(`[Notifications] Payment issue triggered for user ${data.userId}`);
  }
}

export const notificationTriggerManager = new NotificationTriggerManager();