import { getDb } from "../db.ts";

export type ActivityAction = 
  | 'game_approved' | 'game_rejected' | 'game_created' | 'game_updated' | 'game_deleted'
  | 'user_banned' | 'user_unbanned' | 'user_created' | 'user_updated'
  | 'payment_processed' | 'payment_refunded' | 'payment_failed'
  | 'kyc_approved' | 'kyc_rejected' | 'kyc_submitted'
  | 'campaign_launched' | 'campaign_paused' | 'campaign_completed'
  | 'deployment_started' | 'deployment_completed' | 'deployment_failed'
  | 'fraud_detected' | 'fraud_resolved'
  | 'settings_updated' | 'role_assigned' | 'role_removed'
  | 'bulk_action_executed';

export interface AdminActivity {
  id: string;
  adminId: number;
  adminName: string;
  action: ActivityAction;
  resourceType: string; // e.g., 'game', 'user', 'payment'
  resourceId: string | number;
  resourceName: string;
  details: Record<string, any>;
  timestamp: Date;
  ipAddress?: string;
  userAgent?: string;
}

/**
 * Log admin activity for audit trail
 */
export async function logAdminActivity(
  adminId: number,
  adminName: string,
  action: ActivityAction,
  resourceType: string,
  resourceId: string | number,
  resourceName: string,
  details?: Record<string, any>,
  ipAddress?: string,
  userAgent?: string
): Promise<AdminActivity> {
  const activity: AdminActivity = {
    id: `activity_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
    adminId,
    adminName,
    action,
    resourceType,
    resourceId,
    resourceName,
    details: details || {},
    timestamp: new Date(),
    ipAddress,
    userAgent
  };

  try {
    // Store in database (if table exists)
    // await db.insert(adminActivityTable).values(activity);
    console.log(`[ActivityLogger] Logged: ${adminName} ${action} on ${resourceType} #${resourceId}`);
  } catch (err) {
    console.error('[ActivityLogger] Failed to log activity:', err);
  }

  return activity;
}

/**
 * Activity templates for common admin actions
 */
export const ActivityTemplates = {
  /**
   * Game management
   */
  gameApproved: (adminId: number, adminName: string, gameId: number, gameName: string) =>
    logAdminActivity(adminId, adminName, 'game_approved', 'game', gameId, gameName, {
      status: 'approved'
    }),

  gameRejected: (adminId: number, adminName: string, gameId: number, gameName: string, reason: string) =>
    logAdminActivity(adminId, adminName, 'game_rejected', 'game', gameId, gameName, {
      status: 'rejected',
      reason
    }),

  gameCreated: (adminId: number, adminName: string, gameId: number, gameName: string, gameType: string) =>
    logAdminActivity(adminId, adminName, 'game_created', 'game', gameId, gameName, {
      gameType
    }),

  gameUpdated: (adminId: number, adminName: string, gameId: number, gameName: string, changes: Record<string, any>) =>
    logAdminActivity(adminId, adminName, 'game_updated', 'game', gameId, gameName, {
      changes
    }),

  /**
   * User management
   */
  userBanned: (adminId: number, adminName: string, userId: number, userName: string, reason: string) =>
    logAdminActivity(adminId, adminName, 'user_banned', 'user', userId, userName, {
      reason,
      action: 'banned'
    }),

  userUnbanned: (adminId: number, adminName: string, userId: number, userName: string) =>
    logAdminActivity(adminId, adminName, 'user_unbanned', 'user', userId, userName, {
      action: 'unbanned'
    }),

  /**
   * Payment management
   */
  paymentProcessed: (adminId: number, adminName: string, paymentId: string, userId: number, amount: number, currency: string) =>
    logAdminActivity(adminId, adminName, 'payment_processed', 'payment', paymentId, `Payment #${paymentId}`, {
      userId,
      amount,
      currency,
      status: 'processed'
    }),

  paymentRefunded: (adminId: number, adminName: string, paymentId: string, userId: number, amount: number, reason: string) =>
    logAdminActivity(adminId, adminName, 'payment_refunded', 'payment', paymentId, `Payment #${paymentId}`, {
      userId,
      amount,
      reason,
      status: 'refunded'
    }),

  /**
   * KYC management
   */
  kycApproved: (adminId: number, adminName: string, userId: number, userName: string) =>
    logAdminActivity(adminId, adminName, 'kyc_approved', 'kyc', userId, `KYC for ${userName}`, {
      status: 'approved'
    }),

  kycRejected: (adminId: number, adminName: string, userId: number, userName: string, reason: string) =>
    logAdminActivity(adminId, adminName, 'kyc_rejected', 'kyc', userId, `KYC for ${userName}`, {
      status: 'rejected',
      reason
    }),

  /**
   * Campaign management
   */
  campaignLaunched: (adminId: number, adminName: string, campaignId: string, campaignName: string, targetCount: number) =>
    logAdminActivity(adminId, adminName, 'campaign_launched', 'campaign', campaignId, campaignName, {
      status: 'launched',
      targetCount
    }),

  /**
   * Deployment
   */
  deploymentStarted: (adminId: number, adminName: string, version: string) =>
    logAdminActivity(adminId, adminName, 'deployment_started', 'deployment', version, `Deployment v${version}`, {
      status: 'started'
    }),

  deploymentCompleted: (adminId: number, adminName: string, version: string, duration: number) =>
    logAdminActivity(adminId, adminName, 'deployment_completed', 'deployment', version, `Deployment v${version}`, {
      status: 'completed',
      duration
    }),

  /**
   * Fraud management
   */
  fraudDetected: (adminId: number, adminName: string, userId: number, userName: string, fraudType: string, details: string) =>
    logAdminActivity(adminId, adminName, 'fraud_detected', 'fraud_case', userId, `Fraud: ${userName}`, {
      fraudType,
      details,
      status: 'detected'
    }),

  /**
   * Settings
   */
  settingsUpdated: (adminId: number, adminName: string, settingKey: string, oldValue: any, newValue: any) =>
    logAdminActivity(adminId, adminName, 'settings_updated', 'setting', settingKey, `Setting: ${settingKey}`, {
      oldValue,
      newValue
    }),

  /**
   * Bulk actions
   */
  bulkActionExecuted: (adminId: number, adminName: string, actionType: string, resourceCount: number, details: Record<string, any>) =>
    logAdminActivity(adminId, adminName, 'bulk_action_executed', 'bulk_action', `${actionType}_${Date.now()}`, `Bulk ${actionType}`, {
      actionType,
      resourceCount,
      ...details
    })
};

/**
 * Get activity log for a specific resource
 */
export async function getActivityLog(
  resourceType: string,
  resourceId: string | number,
  limit: number = 50
): Promise<AdminActivity[]> {
  // This would query the database
  // const activities = await db.query.adminActivityTable.findMany({
  //   where: and(
  //     eq(adminActivityTable.resourceType, resourceType),
  //     eq(adminActivityTable.resourceId, resourceId)
  //   ),
  //   orderBy: desc(adminActivityTable.timestamp),
  //   limit
  // });
  // return activities;
  return [];
}

/**
 * Get activity log for a specific admin
 */
export async function getAdminActivityLog(
  adminId: number,
  limit: number = 100
): Promise<AdminActivity[]> {
  // This would query the database
  // const activities = await db.query.adminActivityTable.findMany({
  //   where: eq(adminActivityTable.adminId, adminId),
  //   orderBy: desc(adminActivityTable.timestamp),
  //   limit
  // });
  // return activities;
  return [];
}

/**
 * Get all activities within a date range
 */
export async function getActivityLogByDateRange(
  startDate: Date,
  endDate: Date,
  limit: number = 500
): Promise<AdminActivity[]> {
  // This would query the database
  // const activities = await db.query.adminActivityTable.findMany({
  //   where: and(
  //     gte(adminActivityTable.timestamp, startDate),
  //     lte(adminActivityTable.timestamp, endDate)
  //   ),
  //   orderBy: desc(adminActivityTable.timestamp),
  //   limit
  // });
  // return activities;
  return [];
}

// Export alias for backward compatibility
export const logActivity = logAdminActivity;