/**
 * Tier Reward Distribution Service
 * Handles automated monthly bonus distribution and tier-based rewards
 */

import { db } from './db.ts';
import { users, wallets, transactions } from '../drizzle/schema.ts';
import { eq } from 'drizzle-orm';
import { notifyOwner } from './_core/notification.ts';
import { notifyMonthlyBonus } from './vipNotificationsService.ts';

export interface RewardDistributionResult {
  userId: string;
  tier: string;
  bonusAmount: number;
  newBalance: number;
  timestamp: Date;
  status: 'success' | 'failed';
  error?: string;
}

// VIP Tier Configuration
const TIER_CONFIG = {
  bronze: {
    monthlyBonus: 50,
    multiplier: 1.0,
  },
  silver: {
    monthlyBonus: 150,
    multiplier: 1.25,
  },
  gold: {
    monthlyBonus: 500,
    multiplier: 1.5,
  },
  platinum: {
    monthlyBonus: 2000,
    multiplier: 2.0,
  },
};

/**
 * Get user tier based on total spend
 */
function getUserTier(totalSpend: number): string {
  if (totalSpend >= 15000) return 'platinum';
  if (totalSpend >= 5000) return 'gold';
  if (totalSpend >= 1000) return 'silver';
  return 'bronze';
}

/**
 * Distribute monthly bonus to a single user
 */
export async function distributeMonthlyBonusToUser(userId: string): Promise<RewardDistributionResult> {
  try {
    const database = await db();
    if (!database) {
      throw new Error('Database connection failed');
    }

    // Get user
    const user = await (database as any).query.users.findFirst({ where: { id: userId } });
    if (!user) {
      return {
        userId,
        tier: 'bronze',
        bonusAmount: 0,
        newBalance: 0,
        timestamp: new Date(),
        status: 'failed',
        error: 'User not found',
      };
    }

    // Determine tier
    const tier = getUserTier(user.totalSpend || 0);
    const tierConfig = TIER_CONFIG[tier as keyof typeof TIER_CONFIG];
    const bonusAmount = tierConfig.monthlyBonus;

    // Get wallet
    const wallet = await (database as any).query.wallets.findFirst({ where: { userId } });
    if (!wallet) {
      return {
        userId,
        tier,
        bonusAmount,
        newBalance: 0,
        timestamp: new Date(),
        status: 'failed',
        error: 'Wallet not found',
      };
    }

    // Update wallet balance
    const newBalance = (wallet.sweepCoinsBalance || 0) + bonusAmount;

    // Record transaction
    const transactionId = `reward-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    // Send notification to player
    await notifyMonthlyBonus(userId, tier, bonusAmount);

    // Log for admin
    console.log(`[Reward Distribution] Distributed $${bonusAmount} monthly bonus to user ${userId} (${tier})`);

    return {
      userId,
      tier,
      bonusAmount,
      newBalance,
      timestamp: new Date(),
      status: 'success',
    };
  } catch (error) {
    console.error(`[Reward Distribution] Error distributing bonus to user ${userId}:`, error);
    return {
      userId,
      tier: 'bronze',
      bonusAmount: 0,
      newBalance: 0,
      timestamp: new Date(),
      status: 'failed',
      error: error instanceof Error ? error.message : 'Unknown error',
    };
  }
}

/**
 * Distribute monthly bonuses to all VIP users
 */
export async function distributeMonthlyBonusesToAllUsers(): Promise<RewardDistributionResult[]> {
  try {
    const database = await db();
    if (!database) {
      throw new Error('Database connection failed');
    }

    // Get all users with total spend > 0 (VIP users)
    const allUsers = (await (database as any).query.users.findMany({})) || [];
    const vipUsers = allUsers.filter((u: any) => u.totalSpend && u.totalSpend > 0);

    console.log(`[Reward Distribution] Starting distribution to ${vipUsers.length} VIP users`);

    // Distribute to each user
    const results: RewardDistributionResult[] = [];
    let successCount = 0;
    let totalDistributed = 0;

    for (const user of vipUsers) {
      const result = await distributeMonthlyBonusToUser(user.id);
      results.push(result);

      if (result.status === 'success') {
        successCount++;
        totalDistributed += result.bonusAmount;
      }
    }

    // Notify admin
    const summary = `Monthly VIP bonuses distributed:\n- Total users: ${vipUsers.length}\n- Successful: ${successCount}\n- Failed: ${vipUsers.length - successCount}\n- Total amount: $${totalDistributed}`;

    await notifyOwner({
      title: '💰 Monthly VIP Bonuses Distributed',
      content: summary,
    });

    console.log(`[Reward Distribution] Completed: ${successCount}/${vipUsers.length} successful`);

    return results;
  } catch (error) {
    console.error('[Reward Distribution] Error distributing monthly bonuses:', error);
    return [];
  }
}

/**
 * Distribute tier upgrade bonus
 */
export async function distributeTierUpgradeBonus(
  userId: string,
  previousTier: string,
  newTier: string
): Promise<RewardDistributionResult> {
  try {
    const database = await db();
    if (!database) {
      throw new Error('Database connection failed');
    }

    // Calculate upgrade bonus (10% of monthly bonus for new tier)
    const tierConfig = TIER_CONFIG[newTier as keyof typeof TIER_CONFIG];
    const upgradeBonus = Math.floor(tierConfig.monthlyBonus * 0.1);

    // Get wallet
    const wallet = await (database as any).query.wallets.findFirst({ where: { userId } });
    if (!wallet) {
      return {
        userId,
        tier: newTier,
        bonusAmount: upgradeBonus,
        newBalance: 0,
        timestamp: new Date(),
        status: 'failed',
        error: 'Wallet not found',
      };
    }

    const newBalance = (wallet.sweepCoinsBalance || 0) + upgradeBonus;

    console.log(`[Reward Distribution] Tier upgrade bonus: $${upgradeBonus} to user ${userId} (${previousTier} -> ${newTier})`);

    return {
      userId,
      tier: newTier,
      bonusAmount: upgradeBonus,
      newBalance,
      timestamp: new Date(),
      status: 'success',
    };
  } catch (error) {
    console.error(`[Reward Distribution] Error distributing tier upgrade bonus:`, error);
    return {
      userId,
      tier: newTier,
      bonusAmount: 0,
      newBalance: 0,
      timestamp: new Date(),
      status: 'failed',
      error: error instanceof Error ? error.message : 'Unknown error',
    };
  }
}

/**
 * Distribute referral rewards
 */
export async function distributeReferralReward(referrerId: string, referredUserId: string): Promise<RewardDistributionResult> {
  try {
    const database = await db();
    if (!database) {
      throw new Error('Database connection failed');
    }

    const referralReward = 1; // 1 SC per referral

    // Get referrer wallet
    const referrerWallet = await (database as any).query.wallets.findFirst({ where: { userId: referrerId } });
    if (!referrerWallet) {
      return {
        userId: referrerId,
        tier: 'bronze',
        bonusAmount: referralReward,
        newBalance: 0,
        timestamp: new Date(),
        status: 'failed',
        error: 'Referrer wallet not found',
      };
    }

    const newBalance = (referrerWallet.sweepCoinsBalance || 0) + referralReward;

    console.log(`[Reward Distribution] Referral reward: $${referralReward} to user ${referrerId}`);

    return {
      userId: referrerId,
      tier: 'bronze',
      bonusAmount: referralReward,
      newBalance,
      timestamp: new Date(),
      status: 'success',
    };
  } catch (error) {
    console.error(`[Reward Distribution] Error distributing referral reward:`, error);
    return {
      userId: referrerId,
      tier: 'bronze',
      bonusAmount: 0,
      newBalance: 0,
      timestamp: new Date(),
      status: 'failed',
      error: error instanceof Error ? error.message : 'Unknown error',
    };
  }
}

/**
 * Distribute engagement rewards
 */
export async function distributeEngagementReward(userId: string, amount: number): Promise<RewardDistributionResult> {
  try {
    const database = await db();
    if (!database) {
      throw new Error('Database connection failed');
    }

    // Get user
    const user = await (database as any).query.users.findFirst({ where: { id: userId } });
    if (!user) {
      return {
        userId,
        tier: 'bronze',
        bonusAmount: amount,
        newBalance: 0,
        timestamp: new Date(),
        status: 'failed',
        error: 'User not found',
      };
    }

    const tier = getUserTier(user.totalSpend || 0);

    // Get wallet
    const wallet = await (database as any).query.wallets.findFirst({ where: { userId } });
    if (!wallet) {
      return {
        userId,
        tier,
        bonusAmount: amount,
        newBalance: 0,
        timestamp: new Date(),
        status: 'failed',
        error: 'Wallet not found',
      };
    }

    const newBalance = (wallet.sweepCoinsBalance || 0) + amount;

    console.log(`[Reward Distribution] Engagement reward: $${amount} to user ${userId}`);

    return {
      userId,
      tier,
      bonusAmount: amount,
      newBalance,
      timestamp: new Date(),
      status: 'success',
    };
  } catch (error) {
    console.error(`[Reward Distribution] Error distributing engagement reward:`, error);
    return {
      userId,
      tier: 'bronze',
      bonusAmount: 0,
      newBalance: 0,
      timestamp: new Date(),
      status: 'failed',
      error: error instanceof Error ? error.message : 'Unknown error',
    };
  }
}

/**
 * Get distribution statistics
 */
export async function getDistributionStats() {
  try {
    const database = await db();
    if (!database) {
      return {
        totalVIPUsers: 0,
        totalDistributed: 0,
        byTier: {},
        lastDistribution: null,
      };
    }

    const allUsers = (await (database as any).query.users.findMany({})) || [];
    const vipUsers = allUsers.filter((u: any) => u.totalSpend && u.totalSpend > 0);

    const stats = {
      totalVIPUsers: vipUsers.length,
      totalDistributed: 0,
      byTier: {
        bronze: 0,
        silver: 0,
        gold: 0,
        platinum: 0,
      },
      lastDistribution: new Date(),
    };

    for (const user of vipUsers) {
      const tier = getUserTier(user.totalSpend || 0);
      const tierConfig = TIER_CONFIG[tier as keyof typeof TIER_CONFIG];
      stats.totalDistributed += tierConfig.monthlyBonus;
      (stats.byTier as any)[tier]++;
    }

    return stats;
  } catch (error) {
    console.error('[Reward Distribution] Error getting stats:', error);
    return {
      totalVIPUsers: 0,
      totalDistributed: 0,
      byTier: {},
      lastDistribution: null,
    };
  }
}