import { Request, Response, NextFunction } from 'express';
import UserModel from '../models/User';
import { UniResponse } from '../lib/UniResponse';
import { SubscriptionTier, getTierConfig } from '../config/subscriptionTiers';

/**
 * Extended Request interface to include user information
 */
interface AuthenticatedRequest extends Request {
  user?: {
    userId: string;
    email: string;
    role: string;
  };
}

/**
 * Middleware to check if user has a Family subscription tier
 * 
 * @returns Express middleware function that validates family subscription
 * 
 * @example
 * // Check if user has family plan before accessing family features
 * router.post('/family/create', authenticateToken, checkFamilySubscription, createFamily);
 * 
 * @example
 * // Check if user has family plan before accessing family member management
 * router.put('/family/:id/members', authenticateToken, checkFamilySubscription, addFamilyMember);
 */
export const checkFamilySubscription = async (
  req: AuthenticatedRequest,
  res: Response,
  next: NextFunction
): Promise<void> => {
  try {
    const userId = req.user?.userId;

    // Step 1: Verify user authentication
    if (!userId) {
      res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
      return;
    }

    // Step 2: Get user's subscription tier
    const user = await UserModel.findById(userId).select('subscription_tier');
    if (!user) {
      res.status(404).json(UniResponse.Error('User not found', null, 404));
      return;
    }

    const subscriptionTier = user.subscription_tier as SubscriptionTier || 'free';

    // Step 3: Check if user has family subscription tier
    if (subscriptionTier !== 'family' && subscriptionTier !== 'professional') {
      const currentTierConfig = getTierConfig(subscriptionTier);
      
      res.status(403).json(
        UniResponse.Error(
          `Family features are not available on your current plan. Please upgrade to Family or Professional plan to access these features.`,
          {
            subscription_tier: subscriptionTier,
            required_tier: 'family',
            upgrade_required: true,
            current_plan: currentTierConfig.name,
            available_plans: [
              getTierConfig('family').name,
              getTierConfig('professional').name
            ]
          },
          403
        )
      );
      return;
    }

    // Step 4: User has required subscription tier, proceed to next middleware
    next();
  } catch (error) {
    console.error('Error in checkFamilySubscription middleware:', error);
    res
      .status(500)
      .json(UniResponse.Error('Failed to check family subscription access', null, 500));
  }
};

/**
 * Middleware to check if user has a Family or higher subscription tier
 * 
 * @param requiredTier - The minimum required tier (default: 'family')
 * @returns Express middleware function that validates subscription tier
 * 
 * @example
 * // Check if user has at least family plan
 * router.get('/family/features', authenticateToken, checkMinimumSubscriptionTier('family'), getFamilyFeatures);
 * 
 * @example
 * // Check if user has at least professional plan
 * router.get('/advanced/features', authenticateToken, checkMinimumSubscriptionTier('professional'), getAdvancedFeatures);
 */
export function checkMinimumSubscriptionTier(
  requiredTier: SubscriptionTier = 'family'
) {
  return async (
    req: AuthenticatedRequest,
    res: Response,
    next: NextFunction
  ): Promise<void> => {
    try {
      const userId = req.user?.userId;

      // Step 1: Verify user authentication
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Step 2: Get user's subscription tier
      const user = await UserModel.findById(userId).select('subscription_tier');
      if (!user) {
        res.status(404).json(UniResponse.Error('User not found', null, 404));
        return;
      }

      const userTier = user.subscription_tier as SubscriptionTier || 'free';

      // Step 3: Define tier hierarchy for comparison
      const tierPriority: Record<SubscriptionTier, number> = {
        free: 0,
        personal: 1,
        family: 2,
        professional: 3
      };

      // Step 4: Check if user has sufficient subscription tier
      if (tierPriority[userTier] < tierPriority[requiredTier]) {
        const currentTierConfig = getTierConfig(userTier);
        const requiredTierConfig = getTierConfig(requiredTier);
        
        res.status(403).json(
          UniResponse.Error(
            `This feature requires at least ${requiredTierConfig.name}. Your current plan is ${currentTierConfig.name}.`,
            {
              subscription_tier: userTier,
              required_tier: requiredTier,
              upgrade_required: true,
              current_plan: currentTierConfig.name,
              required_plan: requiredTierConfig.name
            },
            403
          )
        );
        return;
      }

      // Step 5: User has required subscription tier or higher, proceed to next middleware
      next();
    } catch (error) {
      console.error(`Error in checkMinimumSubscriptionTier middleware (required: ${requiredTier}):`, error);
      res
        .status(500)
        .json(UniResponse.Error('Failed to check subscription access', null, 500));
    }
  };
}

/**
 * Middleware to check if user has access to family-specific features
 * This is a more specific version that can check for particular family features
 * 
 * @param feature - Optional specific family feature to check
 * @returns Express middleware function
 * 
 * @example
 * // Check access to general family features
 * router.get('/family', authenticateToken, checkFamilyFeatureAccess(), getFamilyInfo);
 * 
 * @example
 * // Check access to specific family feature
 * router.post('/family/share', authenticateToken, checkFamilyFeatureAccess('sharing'), shareWithFamily);
 */
export function checkFamilyFeatureAccess(
  feature?: 'sharing' | 'management' | 'collaboration' | 'storage' | 'analytics'
) {
  return async (
    req: AuthenticatedRequest,
    res: Response,
    next: NextFunction
  ): Promise<void> => {
    try {
      const userId = req.user?.userId;

      // Step 1: Verify user authentication
      if (!userId) {
        res.status(401).json(UniResponse.Error('User not authenticated', null, 401));
        return;
      }

      // Step 2: Get user's subscription tier
      const user = await UserModel.findById(userId).select('subscription_tier');
      if (!user) {
        res.status(404).json(UniResponse.Error('User not found', null, 404));
        return;
      }

      const subscriptionTier = user.subscription_tier as SubscriptionTier || 'free';

      // Step 3: Define which tiers have access to which family features
      const hasAccess = (): boolean => {
        switch (feature) {
          case 'storage':
            // Family and Professional tiers have higher storage limits
            return ['family', 'professional'].includes(subscriptionTier);
          case 'analytics':
            // Family and Professional tiers have advanced analytics
            return ['family', 'professional'].includes(subscriptionTier);
          case 'management':
          case 'sharing':
          case 'collaboration':
            // Family and Professional tiers have family sharing features
            return ['family', 'professional'].includes(subscriptionTier);
          default:
            // For general family features, Family and Professional tiers have access
            return ['family', 'professional'].includes(subscriptionTier);
        }
      };

      if (!hasAccess()) {
        const currentTierConfig = getTierConfig(subscriptionTier);
        const requiredTier = feature === 'storage' || feature === 'analytics' ? 'family' : 'family';
        const requiredTierConfig = getTierConfig(requiredTier);
        
        const featureMessages: Record<string, string> = {
          sharing: 'Family sharing features are not available on your current plan.',
          management: 'Family management features are not available on your current plan.',
          collaboration: 'Family collaboration features are not available on your current plan.',
          storage: 'Higher storage limits for family features are not available on your current plan.',
          analytics: 'Advanced family analytics are not available on your current plan.',
        };

        const message = feature 
          ? featureMessages[feature] || `Access to ${feature} features is not available on your current plan.`
          : 'Family features are not available on your current plan.';
        
        res.status(403).json(
          UniResponse.Error(
            `${message} Please upgrade to Family or Professional plan.`,
            {
              subscription_tier: subscriptionTier,
              required_tier: requiredTier,
              feature: feature || 'family_features',
              upgrade_required: true,
              current_plan: currentTierConfig.name,
              required_plan: requiredTierConfig.name
            },
            403
          )
        );
        return;
      }

      // Step 4: User has access to the requested family feature, proceed to next middleware
      next();
    } catch (error) {
      console.error(`Error in checkFamilyFeatureAccess middleware (feature: ${feature}):`, error);
      res
        .status(500)
        .json(UniResponse.Error('Failed to check family feature access', null, 500));
    }
  };
}