/**
 * Subscription Sync Utility
 *
 * This utility helps sync subscription tiers between User and Subscription models
 * Run this if you suspect data inconsistencies
 */

import UserModel from '../models/User';
import SubscriptionModel from '../models/Subscription';
import { SubscriptionHelper } from './subscriptionHelper';
import { isValidTier, SubscriptionTier } from '../config/subscriptionTiers';
import { humanizeClientError } from './humanReadableError';

export class SubscriptionSync {
  /**
   * Sync all users' subscription tiers based on their active subscriptions
   * This ensures User.subscription_tier matches their active Subscription.tier
   */
  public static async syncAllUsers() {
    try {
      console.log('🔄 Starting subscription sync for all users...');

      const users = await UserModel.find({ is_delete: false });
      let syncedCount = 0;
      let errorCount = 0;

      for (const user of users) {
        try {
          // Find user's active subscription
          const activeSubscription = await SubscriptionModel.findOne({
            user_id: user._id,
            is_active: true,
            status: { $in: ['active', 'trialing'] },
          }).sort({ created_at: -1 });

          let correctTier: SubscriptionTier = 'free';

          if (activeSubscription) {
            // Use subscription tier if valid
            if (isValidTier(activeSubscription.tier)) {
              correctTier = activeSubscription.tier as SubscriptionTier;
            }
          }

          // Update user if tier doesn't match
          if (user.subscription_tier !== correctTier) {
            console.log(
              `Syncing user ${user._id}: ${user.subscription_tier} → ${correctTier}`
            );
            await SubscriptionHelper.syncUserTier(user._id, correctTier);
            syncedCount++;
          }
        } catch (error) {
          console.error(`Error syncing user ${user._id}:`, error);
          errorCount++;
        }
      }

      console.log(
        `✓ Sync complete: ${syncedCount} users updated, ${errorCount} errors`
      );

      return {
        success: true,
        totalUsers: users.length,
        syncedCount,
        errorCount,
      };
    } catch (error: any) {
      console.error('✗ Error syncing users:', error);
      return {
        success: false,
        error: humanizeClientError(
          error,
          'Subscription sync could not be completed. Please try again.'
        ),
      };
    }
  }

  /**
   * Sync a single user's subscription tier
   */
  public static async syncUser(userId: string) {
    try {
      const user = await UserModel.findById(userId);
      if (!user) {
        return { success: false, message: 'User not found' };
      }

      const activeSubscription = await SubscriptionModel.findOne({
        user_id: userId,
        is_active: true,
        status: { $in: ['active', 'trialing'] },
      }).sort({ created_at: -1 });

      let correctTier: SubscriptionTier = 'free';

      if (activeSubscription && isValidTier(activeSubscription.tier)) {
        correctTier = activeSubscription.tier as SubscriptionTier;
      }

      if (user.subscription_tier !== correctTier) {
        await SubscriptionHelper.syncUserTier(userId, correctTier);
        return {
          success: true,
          message: `User tier synced: ${user.subscription_tier} → ${correctTier}`,
          oldTier: user.subscription_tier,
          newTier: correctTier,
        };
      }

      return {
        success: true,
        message: 'User tier already in sync',
        tier: correctTier,
      };
    } catch (error: any) {
      console.error('Error syncing user:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          "We could not sync this user's subscription. Please try again."
        ),
      };
    }
  }

  /**
   * Find users with mismatched tiers
   */
  public static async findMismatchedUsers() {
    try {
      const users = await UserModel.find({ is_delete: false });
      const mismatches = [];

      for (const user of users) {
        const activeSubscription = await SubscriptionModel.findOne({
          user_id: user._id,
          is_active: true,
          status: { $in: ['active', 'trialing'] },
        }).sort({ created_at: -1 });

        const expectedTier = activeSubscription?.tier || 'free';

        if (user.subscription_tier !== expectedTier) {
          mismatches.push({
            userId: user._id,
            email: user.email,
            userTier: user.subscription_tier,
            subscriptionTier: expectedTier,
            hasActiveSubscription: !!activeSubscription,
          });
        }
      }

      console.log(`Found ${mismatches.length} users with mismatched tiers`);

      return {
        success: true,
        count: mismatches.length,
        mismatches,
      };
    } catch (error: any) {
      console.error('Error finding mismatched users:', error);
      return {
        success: false,
        error: humanizeClientError(
          error,
          'We could not check subscription tiers. Please try again.'
        ),
      };
    }
  }

  /**
   * Deactivate duplicate active subscriptions
   * Ensures each user has only one active subscription
   */
  public static async deactivateDuplicateSubscriptions() {
    try {
      console.log('🔄 Checking for duplicate active subscriptions...');

      const users = await UserModel.find({ is_delete: false });
      let deactivatedCount = 0;

      for (const user of users) {
        const activeSubscriptions = await SubscriptionModel.find({
          user_id: user._id,
          is_active: true,
        }).sort({ created_at: -1 });

        if (activeSubscriptions.length > 1) {
          console.log(
            `User ${user._id} has ${activeSubscriptions.length} active subscriptions`
          );

          // Keep the most recent one, deactivate others
          for (let i = 1; i < activeSubscriptions.length; i++) {
            await SubscriptionModel.findByIdAndUpdate(activeSubscriptions[i]._id, {
              is_active: false,
            });
            deactivatedCount++;
            console.log(`Deactivated subscription ${activeSubscriptions[i]._id}`);
          }
        }
      }

      console.log(`✓ Deactivated ${deactivatedCount} duplicate subscriptions`);

      return {
        success: true,
        deactivatedCount,
      };
    } catch (error: any) {
      console.error('✗ Error deactivating duplicates:', error);
      return {
        success: false,
        error: humanizeClientError(
          error,
          'We could not deactivate duplicate subscriptions. Please try again.'
        ),
      };
    }
  }
}
