/**
 * Admin Control Panel System
 * Comprehensive admin dashboard for game management, player moderation, and financial reporting
 */

export type AdminRole = 'super_admin' | 'admin' | 'moderator' | 'analyst' | 'support';
export type AuditAction = 'create' | 'update' | 'delete' | 'suspend' | 'ban' | 'payment' | 'refund';

export interface AdminUser {
  id: number;
  username: string;
  email: string;
  role: AdminRole;
  permissions: string[];
  lastLogin: Date;
  createdAt: Date;
  isActive: boolean;
  twoFactorEnabled: boolean;
}

export interface AdminPermission {
  id: string;
  name: string;
  description: string;
  category: 'games' | 'players' | 'finance' | 'moderation' | 'analytics' | 'system';
}

export interface AuditLog {
  id: string;
  adminId: number;
  adminUsername: string;
  action: AuditAction;
  targetType: string; // 'player', 'game', 'transaction', etc.
  targetId: string;
  details: Record<string, any>;
  timestamp: Date;
  ipAddress: string;
  userAgent: string;
}

export interface GameManagement {
  gameId: string;
  gameName: string;
  status: 'active' | 'inactive' | 'maintenance' | 'testing';
  rtp: number; // Return to Player percentage
  volatility: 'low' | 'medium' | 'high';
  maxBet: number;
  minBet: number;
  dailyRevenue: number;
  totalPlays: number;
  uniquePlayers: number;
  lastUpdated: Date;
}

export interface PlayerModeration {
  playerId: number;
  username: string;
  status: 'active' | 'suspended' | 'banned' | 'restricted';
  reason?: string;
  suspendedUntil?: Date;
  restrictions: PlayerRestriction[];
  warnings: number;
  lastModeration: Date;
}

export interface PlayerRestriction {
  id: string;
  type: 'bet_limit' | 'game_restriction' | 'withdrawal_hold' | 'deposit_limit';
  value: number;
  expiresAt: Date;
}

export interface FinancialReport {
  id: string;
  period: 'daily' | 'weekly' | 'monthly';
  startDate: Date;
  endDate: Date;
  totalRevenue: number;
  totalDeposits: number;
  totalWithdrawals: number;
  totalPayouts: number;
  playerCount: number;
  newPlayers: number;
  activeGames: number;
  profitMargin: number;
}

export interface FraudDetection {
  id: string;
  playerId: number;
  username: string;
  riskScore: number; // 0-100
  riskFactors: string[];
  detectedAt: Date;
  status: 'investigating' | 'flagged' | 'cleared' | 'confirmed';
  action?: 'none' | 'review' | 'restrict' | 'ban';
}

export interface SystemHealth {
  uptime: number; // percentage
  responseTime: number; // ms
  errorRate: number; // percentage
  activeConnections: number;
  databaseStatus: 'healthy' | 'degraded' | 'offline';
  cacheStatus: 'healthy' | 'degraded' | 'offline';
  lastChecked: Date;
}

/**
 * Create admin user
 */
export function createAdminUser(
  username: string,
  email: string,
  role: AdminRole
): AdminUser {
  const permissions = getPermissionsForRole(role);

  return {
    id: Math.floor(Math.random() * 1000000),
    username,
    email,
    role,
    permissions,
    lastLogin: new Date(),
    createdAt: new Date(),
    isActive: true,
    twoFactorEnabled: false,
  };
}

/**
 * Get permissions for admin role
 */
export function getPermissionsForRole(role: AdminRole): string[] {
  const permissionMap: Record<AdminRole, string[]> = {
    super_admin: [
      'manage_admins',
      'manage_games',
      'manage_players',
      'manage_finance',
      'view_analytics',
      'system_settings',
      'audit_logs',
    ],
    admin: [
      'manage_games',
      'manage_players',
      'manage_finance',
      'view_analytics',
      'audit_logs',
    ],
    moderator: [
      'manage_players',
      'view_analytics',
      'audit_logs',
    ],
    analyst: [
      'view_analytics',
      'audit_logs',
    ],
    support: [
      'manage_players',
      'audit_logs',
    ],
  };

  return permissionMap[role] || [];
}

/**
 * Check if admin has permission
 */
export function hasPermission(admin: AdminUser, permission: string): boolean {
  return admin.permissions.includes(permission);
}

/**
 * Create audit log entry
 */
export function createAuditLog(
  adminId: number,
  adminUsername: string,
  action: AuditAction,
  targetType: string,
  targetId: string,
  details: Record<string, any>,
  ipAddress: string,
  userAgent: string
): AuditLog {
  return {
    id: `audit_${Date.now()}`,
    adminId,
    adminUsername,
    action,
    targetType,
    targetId,
    details,
    timestamp: new Date(),
    ipAddress,
    userAgent,
  };
}

/**
 * Update game management status
 */
export function updateGameStatus(
  game: GameManagement,
  status: 'active' | 'inactive' | 'maintenance' | 'testing'
): void {
  game.status = status;
  game.lastUpdated = new Date();
}

/**
 * Update game RTP
 */
export function updateGameRTP(game: GameManagement, rtp: number): void {
  if (rtp < 80 || rtp > 98) {
    throw new Error('RTP must be between 80 and 98');
  }
  game.rtp = rtp;
  game.lastUpdated = new Date();
}

/**
 * Suspend player
 */
export function suspendPlayer(
  moderation: PlayerModeration,
  reason: string,
  durationDays: number
): void {
  moderation.status = 'suspended';
  moderation.reason = reason;
  moderation.suspendedUntil = new Date(Date.now() + durationDays * 24 * 60 * 60 * 1000);
  moderation.warnings++;
  moderation.lastModeration = new Date();
}

/**
 * Ban player
 */
export function banPlayer(moderation: PlayerModeration, reason: string): void {
  moderation.status = 'banned';
  moderation.reason = reason;
  moderation.warnings++;
  moderation.lastModeration = new Date();
}

/**
 * Add player restriction
 */
export function addPlayerRestriction(
  moderation: PlayerModeration,
  type: 'bet_limit' | 'game_restriction' | 'withdrawal_hold' | 'deposit_limit',
  value: number,
  durationDays: number
): PlayerRestriction {
  const restriction: PlayerRestriction = {
    id: `restrict_${Date.now()}`,
    type,
    value,
    expiresAt: new Date(Date.now() + durationDays * 24 * 60 * 60 * 1000),
  };

  moderation.restrictions.push(restriction);
  return restriction;
}

/**
 * Remove expired restrictions
 */
export function removeExpiredRestrictions(moderation: PlayerModeration): void {
  const now = new Date();
  moderation.restrictions = moderation.restrictions.filter((r) => r.expiresAt > now);
}

/**
 * Calculate financial metrics
 */
export function calculateFinancialMetrics(
  totalRevenue: number,
  totalDeposits: number,
  totalWithdrawals: number,
  totalPayouts: number
): { profitMargin: number; playerRetention: number; roi: number } {
  const netRevenue = totalRevenue - totalPayouts;
  const profitMargin = totalRevenue > 0 ? (netRevenue / totalRevenue) * 100 : 0;
  const playerRetention = totalWithdrawals > 0 ? ((totalDeposits - totalWithdrawals) / totalDeposits) * 100 : 0;
  const roi = totalDeposits > 0 ? ((netRevenue / totalDeposits) * 100) : 0;

  return { profitMargin, playerRetention, roi };
}

/**
 * Detect fraud risk
 */
export function detectFraudRisk(
  playerId: number,
  username: string,
  factors: {
    unusualBettingPattern: boolean;
    multipleAccounts: boolean;
    rapidWithdrawals: boolean;
    chargebackHistory: boolean;
    veryNewAccount: boolean;
    largeWinnings: boolean;
    locationMismatch: boolean;
    deviceMismatch: boolean;
  }
): FraudDetection {
  const riskFactors: string[] = [];
  let riskScore = 0;

  if (factors.unusualBettingPattern) {
    riskFactors.push('Unusual betting pattern');
    riskScore += 15;
  }
  if (factors.multipleAccounts) {
    riskFactors.push('Multiple accounts detected');
    riskScore += 25;
  }
  if (factors.rapidWithdrawals) {
    riskFactors.push('Rapid withdrawal requests');
    riskScore += 20;
  }
  if (factors.chargebackHistory) {
    riskFactors.push('Chargeback history');
    riskScore += 30;
  }
  if (factors.veryNewAccount) {
    riskFactors.push('Very new account');
    riskScore += 10;
  }
  if (factors.largeWinnings) {
    riskFactors.push('Unusually large winnings');
    riskScore += 15;
  }
  if (factors.locationMismatch) {
    riskFactors.push('Location mismatch');
    riskScore += 10;
  }
  if (factors.deviceMismatch) {
    riskFactors.push('Device mismatch');
    riskScore += 10;
  }

  return {
    id: `fraud_${playerId}_${Date.now()}`,
    playerId,
    username,
    riskScore: Math.min(100, riskScore),
    riskFactors,
    detectedAt: new Date(),
    status: riskScore > 60 ? 'flagged' : 'investigating',
  };
}

/**
 * Generate financial report
 */
export function generateFinancialReport(
  period: 'daily' | 'weekly' | 'monthly',
  startDate: Date,
  endDate: Date,
  totalRevenue: number,
  totalDeposits: number,
  totalWithdrawals: number,
  totalPayouts: number,
  playerCount: number,
  newPlayers: number,
  activeGames: number
): FinancialReport {
  const { profitMargin } = calculateFinancialMetrics(totalRevenue, totalDeposits, totalWithdrawals, totalPayouts);

  return {
    id: `report_${Date.now()}`,
    period,
    startDate,
    endDate,
    totalRevenue,
    totalDeposits,
    totalWithdrawals,
    totalPayouts,
    playerCount,
    newPlayers,
    activeGames,
    profitMargin,
  };
}

/**
 * System health check
 */
export function checkSystemHealth(
  uptime: number,
  responseTime: number,
  errorRate: number,
  activeConnections: number
): SystemHealth {
  return {
    uptime,
    responseTime,
    errorRate,
    activeConnections,
    databaseStatus: errorRate < 1 ? 'healthy' : 'degraded',
    cacheStatus: responseTime < 100 ? 'healthy' : 'degraded',
    lastChecked: new Date(),
  };
}

/**
 * Admin dashboard summary
 */
export interface AdminDashboardSummary {
  totalPlayers: number;
  activeToday: number;
  totalRevenue: number;
  pendingWithdrawals: number;
  flaggedAccounts: number;
  systemHealth: SystemHealth;
  topGames: GameManagement[];
  recentAuditLogs: AuditLog[];
}

export function generateAdminDashboardSummary(
  totalPlayers: number,
  activeToday: number,
  totalRevenue: number,
  pendingWithdrawals: number,
  flaggedAccounts: number,
  systemHealth: SystemHealth,
  topGames: GameManagement[],
  recentAuditLogs: AuditLog[]
): AdminDashboardSummary {
  return {
    totalPlayers,
    activeToday,
    totalRevenue,
    pendingWithdrawals,
    flaggedAccounts,
    systemHealth,
    topGames: topGames.slice(0, 5),
    recentAuditLogs: recentAuditLogs.slice(0, 10),
  };
}

/**
 * Admin notifications
 */
export interface AdminNotification {
  id: string;
  adminId: number;
  type: 'alert' | 'warning' | 'info' | 'error';
  title: string;
  message: string;
  actionUrl?: string;
  read: boolean;
  createdAt: Date;
}

export function createAdminNotification(
  adminId: number,
  type: 'alert' | 'warning' | 'info' | 'error',
  title: string,
  message: string,
  actionUrl?: string
): AdminNotification {
  return {
    id: `notif_${adminId}_${Date.now()}`,
    adminId,
    type,
    title,
    message,
    actionUrl,
    read: false,
    createdAt: new Date(),
  };
}

/**
 * Batch player actions
 */
export function batchSuspendPlayers(
  playerIds: number[],
  reason: string,
  durationDays: number
): Array<{ playerId: number; success: boolean }> {
  return playerIds.map((playerId) => ({
    playerId,
    success: true, // In production, would attempt actual suspension
  }));
}

/**
 * Export data for compliance
 */
export interface ComplianceExport {
  id: string;
  exportType: 'transactions' | 'players' | 'games' | 'full_audit';
  startDate: Date;
  endDate: Date;
  recordCount: number;
  fileUrl: string;
  createdAt: Date;
  expiresAt: Date;
}

export function createComplianceExport(
  exportType: 'transactions' | 'players' | 'games' | 'full_audit',
  startDate: Date,
  endDate: Date,
  recordCount: number
): ComplianceExport {
  return {
    id: `export_${Date.now()}`,
    exportType,
    startDate,
    endDate,
    recordCount,
    fileUrl: `https://storage.example.com/exports/export_${Date.now()}.csv`,
    createdAt: new Date(),
    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // 30 days
  };
}