import { MembershipTier } from '../types/membership';

export const TIER_LEVELS = {
  ODDECH: 0,
  CZUŁOŚĆ: 1,
  WOLNOŚĆ: 2
} as const;

export interface AccessControlConfig {
  requiredTier: MembershipTier;
  gracePeriod?: number; // in days
  allowTrial?: boolean;
}

export class AccessControl {
  /**
   * Check if user has access to content based on their tier
   */
  static hasAccess(userTier: MembershipTier, requiredTier: MembershipTier): boolean {
    const userLevel = TIER_LEVELS[userTier];
    const requiredLevel = TIER_LEVELS[requiredTier];
    return userLevel >= requiredLevel;
  }

  /**
   * Check if user can upgrade to a specific tier
   */
  static canUpgrade(currentTier: MembershipTier, targetTier: MembershipTier): boolean {
    const currentLevel = TIER_LEVELS[currentTier];
    const targetLevel = TIER_LEVELS[targetTier];
    return targetLevel > currentLevel;
  }

  /**
   * Check if subscription is active and not in grace period
   */
  static isSubscriptionActive(
    subscription: any,
    gracePeriodDays: number = 7
  ): boolean {
    if (!subscription) return false;
    
    if (subscription.status === 'active') return true;
    if (subscription.status === 'canceled' && subscription.cancelAtPeriodEnd) {
      const gracePeriodEnd = new Date(subscription.currentPeriodEnd);
      gracePeriodEnd.setDate(gracePeriodEnd.getDate() + gracePeriodDays);
      return new Date() <= gracePeriodEnd;
    }
    
    return false;
  }

  /**
   * Get available features for a specific tier
   */
  static getAvailableFeatures(tier: MembershipTier): string[] {
    const features = {
      ODDECH: [
        'newsletter',
        'basic_downloads',
        'community_access',
        'episode_notifications'
      ],
      CZUŁOŚĆ: [
        'newsletter',
        'basic_downloads',
        'community_access',
        'episode_notifications',
        'premium_episodes',
        'exclusive_articles',
        'group_sessions',
        'content_archive',
        'premium_downloads',
        'priority_support'
      ],
      WOLNOŚĆ: [
        'newsletter',
        'basic_downloads',
        'community_access',
        'episode_notifications',
        'premium_episodes',
        'exclusive_articles',
        'group_sessions',
        'content_archive',
        'premium_downloads',
        'priority_support',
        'personal_consultations',
        'early_access',
        'exclusive_workshops',
        'qa_sessions',
        'personalized_plans',
        'direct_contact'
      ]
    };

    return features[tier] || [];
  }

  /**
   * Check if user has access to a specific feature
   */
  static hasFeatureAccess(userTier: MembershipTier, feature: string): boolean {
    const availableFeatures = this.getAvailableFeatures(userTier);
    return availableFeatures.includes(feature);
  }

  /**
   * Get content access level for a user
   */
  static getContentAccessLevel(userTier: MembershipTier): {
    canAccessEpisodes: boolean;
    canAccessArticles: boolean;
    canAccessVideos: boolean;
    canAccessCourses: boolean;
    canAccessDownloads: boolean;
    canAccessConsultations: boolean;
  } {
    return {
      canAccessEpisodes: this.hasFeatureAccess(userTier, 'premium_episodes'),
      canAccessArticles: this.hasFeatureAccess(userTier, 'exclusive_articles'),
      canAccessVideos: this.hasFeatureAccess(userTier, 'exclusive_workshops'),
      canAccessCourses: this.hasFeatureAccess(userTier, 'personalized_plans'),
      canAccessDownloads: this.hasFeatureAccess(userTier, 'premium_downloads'),
      canAccessConsultations: this.hasFeatureAccess(userTier, 'personal_consultations')
    };
  }

  /**
   * Validate subscription status and return access status
   */
  static validateAccess(
    userTier: MembershipTier,
    subscription: any,
    requiredTier: MembershipTier
  ): {
    hasAccess: boolean;
    reason: string;
    gracePeriod?: Date;
  } {
    // Check if user tier meets requirements
    if (!this.hasAccess(userTier, requiredTier)) {
      return {
        hasAccess: false,
        reason: `Wymagany plan: ${requiredTier}. Twój plan: ${userTier}`
      };
    }

    // Check subscription status
    if (!subscription) {
      return {
        hasAccess: false,
        reason: 'Brak aktywnej subskrypcji'
      };
    }

    if (subscription.status === 'active') {
      return {
        hasAccess: true,
        reason: 'Aktywna subskrypcja'
      };
    }

    if (subscription.status === 'canceled' && subscription.cancelAtPeriodEnd) {
      const gracePeriodEnd = new Date(subscription.currentPeriodEnd);
      gracePeriodEnd.setDate(gracePeriodEnd.getDate() + 7); // 7 days grace period
      
      if (new Date() <= gracePeriodEnd) {
        return {
          hasAccess: true,
          reason: 'Okres łaski - subskrypcja zostanie anulowana',
          gracePeriod: gracePeriodEnd
        };
      } else {
        return {
          hasAccess: false,
          reason: 'Okres łaski wygasł'
        };
      }
    }

    return {
      hasAccess: false,
      reason: `Status subskrypcji: ${subscription.status}`
    };
  }

  /**
   * Get upgrade recommendations based on user activity
   */
  static getUpgradeRecommendations(
    userTier: MembershipTier,
    userActivity: {
      episodesWatched: number;
      articlesRead: number;
      timeSpent: number;
      consultationRequests: number;
    }
  ): {
    recommended: boolean;
    reason: string;
    suggestedTier: MembershipTier;
  } {
    if (userTier === 'WOLNOŚĆ') {
      return {
        recommended: false,
        reason: 'Masz już najwyższy plan',
        suggestedTier: 'WOLNOŚĆ'
      };
    }

    const { episodesWatched, articlesRead, timeSpent, consultationRequests } = userActivity;
    
    // High engagement - recommend WOLNOŚĆ
    if (episodesWatched > 20 && articlesRead > 15 && timeSpent > 10000 && consultationRequests > 2) {
      return {
        recommended: true,
        reason: 'Wysokie zaangażowanie - rozważ plan WOLNOŚĆ dla osobistych konsultacji',
        suggestedTier: 'WOLNOŚĆ'
      };
    }

    // Medium engagement - recommend CZUŁOŚĆ
    if (episodesWatched > 10 && articlesRead > 8 && timeSpent > 5000) {
      return {
        recommended: true,
        reason: 'Średnie zaangażowanie - rozważ plan CZUŁOŚĆ dla ekskluzywnych treści',
        suggestedTier: 'CZUŁOŚĆ'
      };
    }

    return {
      recommended: false,
      reason: 'Kontynuuj z obecnym planem',
      suggestedTier: userTier
    };
  }

  /**
   * Calculate proration for subscription changes
   */
  static calculateProration(
    currentPlan: { price: number; interval: string },
    newPlan: { price: number; interval: string },
    daysRemaining: number
  ): {
    credit: number;
    charge: number;
    prorationDate: Date;
  } {
    const currentDailyRate = currentPlan.price / 30; // Assuming monthly
    const newDailyRate = newPlan.price / 30;
    
    const unusedCredit = currentDailyRate * daysRemaining;
    const newCharge = newDailyRate * daysRemaining;
    
    const credit = Math.max(0, unusedCredit - newCharge);
    const charge = Math.max(0, newCharge - unusedCredit);
    
    return {
      credit,
      charge,
      prorationDate: new Date()
    };
  }
}

/**
 * Middleware function for protecting routes based on membership
 */
export function withMembershipAccess(
  requiredTier: MembershipTier,
  options: {
    redirectTo?: string;
    gracePeriod?: number;
  } = {}
) {
  return function(Component: any) {
    return function ProtectedComponent(props: any) {
      // This would be implemented with actual auth context
      // For now, return the component as-is
      return Component(props);
    };
  };
}

/**
 * Hook for checking access permissions
 */
export function useAccessControl() {
  return {
    hasAccess: AccessControl.hasAccess,
    canUpgrade: AccessControl.canUpgrade,
    isSubscriptionActive: AccessControl.isSubscriptionActive,
    hasFeatureAccess: AccessControl.hasFeatureAccess,
    getContentAccessLevel: AccessControl.getContentAccessLevel,
    validateAccess: AccessControl.validateAccess,
    getUpgradeRecommendations: AccessControl.getUpgradeRecommendations
  };
}