import SubscriptionModel from '../models/Subscription';
import UserModel from '../models/User';
import mongoose from 'mongoose';
import { humanizeClientError } from './humanReadableError';

/**
 * Cleanup script to consolidate multiple subscriptions per user into a single subscription
 * Run this once to fix existing data
 */
export class SubscriptionCleanup {
  /**
   * Clean up duplicate subscriptions for all users
   */
  public static async cleanupAllUsers() {
    try {
      console.log('=== Starting Subscription Cleanup ===');

      // Find all users with multiple active subscriptions
      const duplicates = await SubscriptionModel.aggregate([
        {
          $match: { is_active: true },
        },
        {
          $group: {
            _id: '$user_id',
            count: { $sum: 1 },
            subscriptions: { $push: '$$ROOT' },
          },
        },
        {
          $match: { count: { $gt: 1 } },
        },
      ]);

      console.log(`Found ${duplicates.length} users with duplicate subscriptions`);

      let cleanedCount = 0;

      for (const duplicate of duplicates) {
        const userId = duplicate._id;
        const subscriptions = duplicate.subscriptions;

        console.log(
          `\n--- Processing user ${userId} with ${subscriptions.length} subscriptions ---`
        );

        // Sort subscriptions by priority:
        // 1. Active paid subscriptions (not free)
        // 2. Most recent subscription
        const sortedSubs = subscriptions.sort((a: any, b: any) => {
          // Prioritize non-free tiers
          if (a.tier !== 'free' && b.tier === 'free') return -1;
          if (a.tier === 'free' && b.tier !== 'free') return 1;

          // Prioritize active status
          const activeStatuses = ['active', 'trialing'];
          const aIsActive = activeStatuses.includes(a.status);
          const bIsActive = activeStatuses.includes(b.status);
          if (aIsActive && !bIsActive) return -1;
          if (!aIsActive && bIsActive) return 1;

          // Most recent created_at
          return new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
        });

        // Keep the first (highest priority) subscription
        const keepSubscription = sortedSubs[0];
        const removeSubscriptions = sortedSubs.slice(1);

        console.log(
          `Keeping subscription: ${keepSubscription._id} (tier: ${keepSubscription.tier}, status: ${keepSubscription.status})`
        );

        // Deactivate all other subscriptions
        for (const sub of removeSubscriptions) {
          await SubscriptionModel.findByIdAndUpdate(sub._id, {
            is_active: false,
            metadata: {
              ...sub.metadata,
              deactivated_by: 'cleanup_script',
              deactivated_at: new Date().toISOString(),
            },
          });
          console.log(`Deactivated subscription: ${sub._id} (tier: ${sub.tier})`);
        }

        // Sync user tier with the kept subscription
        await UserModel.findByIdAndUpdate(userId, {
          subscription_tier: keepSubscription.tier,
        });

        console.log(`✓ User ${userId} tier synced to: ${keepSubscription.tier}`);
        cleanedCount++;
      }

      console.log(`\n=== Cleanup Complete ===`);
      console.log(`Cleaned up ${cleanedCount} users`);

      return {
        success: true,
        cleanedCount,
        message: `Successfully cleaned up ${cleanedCount} users with duplicate subscriptions`,
      };
    } catch (error: any) {
      console.error('Error during cleanup:', error);
      return {
        success: false,
        cleanedCount: 0,
        message: humanizeClientError(
          error,
          'Subscription cleanup could not be completed. Please try again.'
        ),
      };
    }
  }

  /**
   * Clean up duplicate subscriptions for a specific user
   */
  public static async cleanupUser(userId: string | mongoose.Types.ObjectId) {
    try {
      console.log(`=== Cleaning up subscriptions for user ${userId} ===`);

      const subscriptions = await SubscriptionModel.find({
        user_id: userId,
        is_active: true,
      }).sort({ created_at: -1 });

      if (subscriptions.length <= 1) {
        console.log('No duplicate subscriptions found');
        return {
          success: true,
          message: 'No cleanup needed',
        };
      }

      console.log(`Found ${subscriptions.length} active subscriptions`);

      // Sort by priority (same logic as above)
      const sortedSubs = subscriptions.sort((a, b) => {
        if (a.tier !== 'free' && b.tier === 'free') return -1;
        if (a.tier === 'free' && b.tier !== 'free') return 1;

        const activeStatuses = ['active', 'trialing'];
        const aIsActive = activeStatuses.includes(a.status);
        const bIsActive = activeStatuses.includes(b.status);
        if (aIsActive && !bIsActive) return -1;
        if (!aIsActive && bIsActive) return 1;

        return b.created_at.getTime() - a.created_at.getTime();
      });

      const keepSubscription = sortedSubs[0];
      const removeSubscriptions = sortedSubs.slice(1);

      console.log(`Keeping: ${keepSubscription._id} (${keepSubscription.tier})`);

      // Deactivate others
      for (const sub of removeSubscriptions) {
        await SubscriptionModel.findByIdAndUpdate(sub._id, {
          is_active: false,
          metadata: {
            ...sub.metadata,
            deactivated_by: 'cleanup_script',
            deactivated_at: new Date().toISOString(),
          },
        });
        console.log(`Deactivated: ${sub._id} (${sub.tier})`);
      }

      // Sync user tier
      await UserModel.findByIdAndUpdate(userId, {
        subscription_tier: keepSubscription.tier,
      });

      console.log(`✓ Cleanup complete for user ${userId}`);

      return {
        success: true,
        message: `Cleaned up ${removeSubscriptions.length} duplicate subscriptions`,
        keptSubscription: keepSubscription,
      };
    } catch (error: any) {
      console.error('Error during user cleanup:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'Subscription cleanup could not be completed. Please try again.'
        ),
      };
    }
  }

  /**
   * Get statistics about subscription duplicates
   */
  public static async getStats() {
    try {
      const totalUsers = await UserModel.countDocuments();
      const totalSubscriptions = await SubscriptionModel.countDocuments({
        is_active: true,
      });

      const duplicates = await SubscriptionModel.aggregate([
        {
          $match: { is_active: true },
        },
        {
          $group: {
            _id: '$user_id',
            count: { $sum: 1 },
          },
        },
        {
          $match: { count: { $gt: 1 } },
        },
      ]);

      const usersWithDuplicates = duplicates.length;
      const totalDuplicates = duplicates.reduce((sum, d) => sum + (d.count - 1), 0);

      return {
        totalUsers,
        totalSubscriptions,
        usersWithDuplicates,
        totalDuplicates,
        message: `${usersWithDuplicates} users have duplicate subscriptions (${totalDuplicates} extra subscriptions)`,
      };
    } catch (error: any) {
      console.error('Error getting stats:', error);
      return {
        totalUsers: 0,
        totalSubscriptions: 0,
        usersWithDuplicates: 0,
        totalDuplicates: 0,
        message: humanizeClientError(
          error,
          'We could not load subscription statistics. Please try again.'
        ),
      };
    }
  }
}
