import { Parser } from "json2csv";
import { Document, Page, Text, View, StyleSheet, PDFDownloadLink } from "@react-pdf/renderer";

export interface ExportOptions {
  format: "csv" | "pdf" | "json";
  dateRange: { start: Date; end: Date };
  includeFields: string[];
  filename: string;
}

export interface FraudReport {
  alertId: string;
  userId: number;
  playerName: string;
  alertType: string;
  severity: "low" | "medium" | "high" | "critical";
  description: string;
  detectedAt: Date;
  status: "pending" | "reviewed" | "resolved";
  actionTaken?: string;
}

export interface GamePerformanceReport {
  gameId: string;
  gameName: string;
  totalSpins: number;
  totalWagered: number;
  totalWon: number;
  rtp: number;
  volatility: "low" | "medium" | "high";
  activeUsers: number;
  revenue: number;
  period: string;
}

export interface PlayerBehaviorReport {
  userId: number;
  playerName: string;
  totalSpent: number;
  totalWon: number;
  roi: number;
  favoriteGame: string;
  avgSessionDuration: number;
  loginFrequency: string;
  lastLogin: Date;
  vipTier: string;
  fraudRiskScore: number;
}

export async function exportFraudReports(reports: FraudReport[], options: ExportOptions): Promise<string | Buffer> {
  if (options.format === "csv") {
    return exportToCSV(reports, options);
  } else if (options.format === "pdf") {
    return exportToPDF(reports, "Fraud Alerts Report", options);
  } else {
    return JSON.stringify(reports, null, 2);
  }
}

export async function exportGamePerformance(reports: GamePerformanceReport[], options: ExportOptions): Promise<string | Buffer> {
  if (options.format === "csv") {
    return exportToCSV(reports, options);
  } else if (options.format === "pdf") {
    return exportToPDF(reports, "Game Performance Report", options);
  } else {
    return JSON.stringify(reports, null, 2);
  }
}

export async function exportPlayerBehavior(reports: PlayerBehaviorReport[], options: ExportOptions): Promise<string | Buffer> {
  if (options.format === "csv") {
    return exportToCSV(reports, options);
  } else if (options.format === "pdf") {
    return exportToPDF(reports, "Player Behavior Report", options);
  } else {
    return JSON.stringify(reports, null, 2);
  }
}

function exportToCSV(data: any[], options: ExportOptions): string {
  try {
    const parser = new Parser({
      fields: options.includeFields,
      header: true,
    });

    return parser.parse(data);
  } catch (error) {
    console.error("[Analytics Export] CSV export error:", error);
    throw error;
  }
}

function exportToPDF(data: any[], title: string, options: ExportOptions): Buffer {
  // Mock PDF generation - in production would use a PDF library
  const csvContent = exportToCSV(data, options);

  // Create simple PDF-like structure
  const pdfContent = `
%PDF-1.4
1 0 obj
<< /Type /Catalog /Pages 2 0 R >>
endobj
2 0 obj
<< /Type /Pages /Kids [3 0 R] /Count 1 >>
endobj
3 0 obj
<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>
endobj
4 0 obj
<< /Length ${csvContent.length} >>
stream
${title}
${csvContent}
endstream
endobj
xref
0 5
0000000000 65535 f 
0000000009 00000 n 
0000000058 00000 n 
0000000115 00000 n 
0000000214 00000 n 
trailer
<< /Size 5 /Root 1 0 R >>
startxref
${csvContent.length + 300}
%%EOF
`;

  return Buffer.from(pdfContent);
}

export async function generateFraudReport(startDate: Date, endDate: Date): Promise<FraudReport[]> {
  // Mock implementation - would query database for real data
  const mockReports: FraudReport[] = [
    {
      alertId: "alert_1",
      userId: 101,
      playerName: "Player101",
      alertType: "rapid_betting",
      severity: "high",
      description: "10 consecutive bets in 30 seconds",
      detectedAt: new Date(),
      status: "reviewed",
      actionTaken: "Account flagged for monitoring",
    },
    {
      alertId: "alert_2",
      userId: 102,
      playerName: "Player102",
      alertType: "multi_account",
      severity: "critical",
      description: "Same device fingerprint as Player101",
      detectedAt: new Date(),
      status: "resolved",
      actionTaken: "Both accounts suspended",
    },
  ];

  return mockReports;
}

export async function generateGamePerformanceReport(startDate: Date, endDate: Date): Promise<GamePerformanceReport[]> {
  // Mock implementation
  const mockReports: GamePerformanceReport[] = [
    {
      gameId: "golden-pharaoh",
      gameName: "Golden Pharaoh",
      totalSpins: 50000,
      totalWagered: 250000,
      totalWon: 200000,
      rtp: 96.5,
      volatility: "high",
      activeUsers: 2500,
      revenue: 50000,
      period: "2026-04-01 to 2026-04-06",
    },
    {
      gameId: "lucky-dragon",
      gameName: "Lucky Dragon",
      totalSpins: 45000,
      totalWagered: 225000,
      totalWon: 180000,
      rtp: 95.2,
      volatility: "medium",
      activeUsers: 2200,
      revenue: 45000,
      period: "2026-04-01 to 2026-04-06",
    },
  ];

  return mockReports;
}

export async function generatePlayerBehaviorReport(startDate: Date, endDate: Date): Promise<PlayerBehaviorReport[]> {
  // Mock implementation
  const mockReports: PlayerBehaviorReport[] = [
    {
      userId: 1001,
      playerName: "HighRoller",
      totalSpent: 5000,
      totalWon: 12000,
      roi: 140,
      favoriteGame: "Golden Pharaoh",
      avgSessionDuration: 45,
      loginFrequency: "daily",
      lastLogin: new Date(),
      vipTier: "Platinum",
      fraudRiskScore: 2,
    },
    {
      userId: 1002,
      playerName: "CasualPlayer",
      totalSpent: 500,
      totalWon: 450,
      roi: -10,
      favoriteGame: "Lucky Dragon",
      avgSessionDuration: 15,
      loginFrequency: "weekly",
      lastLogin: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
      vipTier: "Bronze",
      fraudRiskScore: 1,
    },
  ];

  return mockReports;
}

export async function scheduleReportGeneration(reportType: string, schedule: "daily" | "weekly" | "monthly", recipients: string[]): Promise<void> {
  console.log(`[Analytics Export] Report ${reportType} scheduled for ${schedule} delivery to ${recipients.join(", ")}`);
}

export async function getExportHistory(limit: number = 20): Promise<Array<{ id: string; type: string; format: string; createdAt: Date; createdBy: string }>> {
  // Mock implementation
  return [
    {
      id: "export_1",
      type: "fraud_report",
      format: "pdf",
      createdAt: new Date(),
      createdBy: "admin@playcoinkrazy.com",
    },
    {
      id: "export_2",
      type: "game_performance",
      format: "csv",
      createdAt: new Date(Date.now() - 24 * 60 * 60 * 1000),
      createdBy: "admin@playcoinkrazy.com",
    },
  ];
}