import { adminNotificationService } from './adminNotifications.ts';

export interface FraudSignal {
  type: 'velocity_limit' | 'failed_kyc' | 'suspicious_pattern' | 'high_risk_country' | 'duplicate_account';
  severity: 'critical' | 'high' | 'medium' | 'low';
  userId: string;
  details: Record<string, any>;
}

class FraudDetectionService {
  /**
   * Analyze player for fraud signals
   */
  async analyzePlayer(
    userId: string,
    playerData: {
      totalDeposits: number;
      depositCount: number;
      lastDepositTime: Date;
      kycStatus: string;
      country: string;
      ipAddresses: string[];
      failedKycAttempts: number;
      accountAgeMinutes: number;
    }
  ): Promise<FraudSignal[]> {
    const signals: FraudSignal[] = [];

    // Check velocity limits (deposits in short time)
    if (playerData.depositCount > 5 && playerData.accountAgeMinutes < 60) {
      signals.push({
        type: 'velocity_limit',
        severity: 'high',
        userId,
        details: {
          depositCount: playerData.depositCount,
          accountAgeMinutes: playerData.accountAgeMinutes,
          message: 'Multiple deposits in short time period',
        },
      });
    }

    // Check failed KYC attempts
    if (playerData.failedKycAttempts > 3) {
      signals.push({
        type: 'failed_kyc',
        severity: 'critical',
        userId,
        details: {
          failedAttempts: playerData.failedKycAttempts,
          kycStatus: playerData.kycStatus,
          message: 'Multiple failed KYC verification attempts',
        },
      });
    }

    // Check for high-risk countries
    const highRiskCountries = ['KP', 'IR', 'SY', 'CU']; // North Korea, Iran, Syria, Cuba
    if (highRiskCountries.includes(playerData.country)) {
      signals.push({
        type: 'high_risk_country',
        severity: 'critical',
        userId,
        details: {
          country: playerData.country,
          message: 'Player from high-risk country',
        },
      });
    }

    // Check for large deposits
    if (playerData.totalDeposits > 10000) {
      signals.push({
        type: 'suspicious_pattern',
        severity: 'high',
        userId,
        details: {
          totalDeposits: playerData.totalDeposits,
          message: 'Large deposit amount detected',
        },
      });
    }

    return signals;
  }

  /**
   * Check for duplicate accounts
   */
  async checkDuplicateAccounts(
    userId: string,
    playerData: {
      email: string;
      phone?: string;
      ipAddress: string;
      deviceId?: string;
    }
  ): Promise<FraudSignal | null> {
    // TODO: Implement actual duplicate detection by querying database
    // This is a placeholder that would check for:
    // - Multiple accounts with same email
    // - Multiple accounts from same IP
    // - Multiple accounts with same device ID

    return null;
  }

  /**
   * Trigger fraud alert and notify admins
   */
  async triggerFraudAlert(signal: FraudSignal, adminId: string): Promise<void> {
    const severityMap = {
      critical: 'critical' as const,
      high: 'high' as const,
      medium: 'medium' as const,
      low: 'low' as const,
    };

    const typeMap: Record<string, string> = {
      velocity_limit: 'Velocity Limit Exceeded',
      failed_kyc: 'Failed KYC Verification',
      suspicious_pattern: 'Suspicious Pattern Detected',
      high_risk_country: 'High-Risk Country',
      duplicate_account: 'Duplicate Account Detected',
    };

    await adminNotificationService.createAlert(
      'fraud',
      severityMap[signal.severity],
      typeMap[signal.type],
      `Player ${signal.userId}: ${JSON.stringify(signal.details)}`,
      adminId,
      `/admin/risk-management?userId=${signal.userId}`
    );
  }

  /**
   * Analyze transaction for fraud
   */
  async analyzeTransaction(
    userId: string,
    transactionData: {
      amount: number;
      currency: string;
      timestamp: Date;
      paymentMethod: string;
      merchantCategory: string;
    }
  ): Promise<FraudSignal[]> {
    const signals: FraudSignal[] = [];

    // Check for unusually large transactions
    if (transactionData.amount > 5000) {
      signals.push({
        type: 'suspicious_pattern',
        severity: 'high',
        userId,
        details: {
          amount: transactionData.amount,
          currency: transactionData.currency,
          message: 'Large transaction amount',
        },
      });
    }

    return signals;
  }

  /**
   * Get fraud score for player (0-100)
   */
  async calculateFraudScore(signals: FraudSignal[]): Promise<number> {
    let score = 0;

    for (const signal of signals) {
      switch (signal.severity) {
        case 'critical':
          score += 30;
          break;
        case 'high':
          score += 20;
          break;
        case 'medium':
          score += 10;
          break;
        case 'low':
          score += 5;
          break;
      }
    }

    return Math.min(score, 100);
  }

  /**
   * Get fraud risk level
   */
  getRiskLevel(score: number): 'low' | 'medium' | 'high' | 'critical' {
    if (score >= 80) return 'critical';
    if (score >= 60) return 'high';
    if (score >= 40) return 'medium';
    return 'low';
  }
}

export const fraudDetectionService = new FraudDetectionService();