import { AbilityBuilder, PureAbility, AbilityClass } from '@casl/ability';
import {
  SubscriptionTier,
  getTierConfig,
  getStorageAuthorization,
  validateStorageUsage,
  isStorageExceeded,
  StorageAuthorizationResult,
  StorageValidationResult,
} from './subscriptionTiers';
import { AnalyticsLevel, StorageCapacity } from '../types/abilities';

// Define actions
type Actions = 'create' | 'read' | 'update' | 'delete' | 'manage' | 'access' | 'upload';

// Define subjects
type Subjects =
  | 'QRCode'
  | 'Scan'
  | 'MemoryTagScan'
  | 'ScanNotification'
  | 'Analytics'
  | 'Document'
  | 'CustomBranding'
  | 'HIPAACompliance'
  | 'API'
  | 'PrioritySupport'
  | 'all';

// Define ability type
export type AppAbility = PureAbility<[Actions, Subjects]>;
export const AppAbility = PureAbility as AbilityClass<AppAbility>;

/**
 * Define CASL abilities for a user based on their subscription tier
 * @param user - User object with subscription_tier property
 * @returns Built ability instance
 */
export function defineAbilitiesFor(user: any) {
  const { can, cannot, build } = new AbilityBuilder(AppAbility);
  const tierConfig = getTierConfig(user.subscription_tier || 'free');

  // QR Code permissions (all tiers can manage their own QR codes)
  // Note: 'create' doesn't need conditions since we're not checking ownership on creation
  can('create', 'QRCode');
  // Read, update, delete need conditions to check ownership
  if (user.userId) {
    can('read', 'QRCode', { created_by: user.userId });
    can('update', 'QRCode', { created_by: user.userId });
    can('delete', 'QRCode', { created_by: user.userId });
  }

  // Scan permissions (all tiers can create scans)
  can('create', 'Scan');
  // Read scans need conditions to check ownership
  if (user.userId) {
    can('read', 'Scan', { scanned_by: user.userId });
  }

  // Memory tag scan permissions based on tier
  // Free tier: limited memory tag scans
  // Paid tiers: unlimited memory tag scans
  if (user.subscription_tier === 'free') {
    // For free tier, user can create limited memory tag scans
    // We'll handle the actual limit check in the service layer
    can('create', 'MemoryTagScan');
  } else {
    // For paid tiers, unlimited memory tag scans
    can('create', 'MemoryTagScan');
  }

  // Analytics permissions based on tier
  if (tierConfig.features.analytics === 'basic') {
    can('access', 'Analytics', { level: 'basic' });
    cannot('access', 'Analytics', { level: 'advanced' });
    cannot('access', 'Analytics', { level: 'premium' });
  } else if (tierConfig.features.analytics === 'advanced') {
    can('access', 'Analytics', { level: 'basic' });
    can('access', 'Analytics', { level: 'advanced' });
    cannot('access', 'Analytics', { level: 'premium' });
  } else if (tierConfig.features.analytics === 'premium') {
    can('manage', 'Analytics');
  }

  // Document sharing and upload permissions
  if (tierConfig.features.document_sharing) {
    can('upload', 'Document');
    can('manage', 'Document');
  } else {
    cannot('upload', 'Document').because(
      'Document sharing requires a paid subscription'
    );
  }

  // Custom branding permissions
  if (tierConfig.features.custom_branding) {
    can('manage', 'CustomBranding');
  } else {
    cannot('manage', 'CustomBranding').because(
      'Custom branding requires Personal or Professional plan'
    );
  }

  // Scan notification permissions (only available for Professional tier)
  if (tierConfig.features.priority_support) {
    can('access', 'ScanNotification');
  } else {
    cannot('access', 'ScanNotification').because(
      'Scan notifications require Professional plan'
    );
  }

  // HIPAA compliance permissions
  if (tierConfig.features.hipaa_compliance) {
    can('access', 'HIPAACompliance');
  } else {
    cannot('access', 'HIPAACompliance').because(
      'HIPAA compliance requires Professional plan'
    );
  }

  // API access permissions
  if (tierConfig.features.api_access) {
    can('access', 'API');
  } else {
    cannot('access', 'API').because('API access requires Professional plan');
  }

  // Priority support permissions
  if (tierConfig.features.priority_support) {
    can('access', 'PrioritySupport');
  } else {
    cannot('access', 'PrioritySupport').because(
      'Priority support requires Professional plan'
    );
  }

  // CRITICAL: Add conditionsMatcher when using conditions in rules
  // This is required by CASL when any rule has conditions
  // CRITICAL: Add conditionsMatcher when using conditions in rules
  // This is required by CASL when any rule has conditions
  // Simple equality matcher for conditions like { created_by: user.userId }
  const conditionsMatcher = (conditions: any) => {
    return (object: any) => {
      if (!conditions || typeof conditions !== 'object') {
        return true; // No conditions means allow
      }

      if (!object || typeof object !== 'object') {
        return false; // No object means conditions can't match
      }

      // Check each condition field matches the object
      for (const [key, value] of Object.entries(conditions)) {
        // Handle ObjectId comparison (convert to string if needed)
        const objectValue = object[key];
        const conditionValue = value;

        // Compare values (handle ObjectId by converting to string)
        const objectStr = objectValue?.toString ? objectValue.toString() : objectValue;
        const conditionStr = conditionValue?.toString ? conditionValue.toString() : conditionValue;

        if (objectStr !== conditionStr) {
          return false;
        }
      }

      return true;
    };
  };

  return build({
    conditionsMatcher,
  });
}

/**
 * Get QR code limit for a subscription tier
 * @param subscriptionTier - The subscription tier to check
 * @returns Number of QR codes allowed (Infinity for unlimited)
 */
export function getQRCodeLimit(subscriptionTier: SubscriptionTier): number {
  const tierConfig = getTierConfig(subscriptionTier);
  const limit = tierConfig.features.qr_codes;

  if (limit === 'unlimited') {
    return Infinity;
  }

  return limit;
}

/**
 * Check if user can create more QR codes based on their subscription
 * @param subscriptionTier - User's subscription tier
 * @param currentQRCodeCount - Number of active QR codes user currently has
 * @returns Object with canCreate boolean and limit information
 */
export function canCreateQRCode(
  subscriptionTier: SubscriptionTier,
  currentQRCodeCount: number
): { canCreate: boolean; limit: number; current: number; remaining: number } {
  const limit = getQRCodeLimit(subscriptionTier);
  const canCreate = currentQRCodeCount < limit;
  const remaining =
    limit === Infinity ? Infinity : Math.max(0, limit - currentQRCodeCount);

  return {
    canCreate,
    limit,
    current: currentQRCodeCount,
    remaining,
  };
}

/**
 * Get scan limit for a subscription tier
 * @param subscriptionTier - The subscription tier to check
 * @returns Number of scans allowed per month (Infinity for unlimited)
 */
export function getScanLimit(subscriptionTier: SubscriptionTier): number {
  const tierConfig = getTierConfig(subscriptionTier);
  const limit = tierConfig.features.scans_per_month;

  if (limit === 'unlimited') {
    return Infinity;
  }

  return limit;
}

/**
 * Check if user can create more scans based on their subscription
 * @param subscriptionTier - User's subscription tier
 * @param currentMonthScans - Number of scans in current month
 * @returns Object with canScan boolean and limit information
 */
export function canCreateScan(
  subscriptionTier: SubscriptionTier,
  currentMonthScans: number
): { canScan: boolean; limit: number; current: number; remaining: number } {
  const limit = getScanLimit(subscriptionTier);
  const canScan = currentMonthScans < limit;
  const remaining =
    limit === Infinity ? Infinity : Math.max(0, limit - currentMonthScans);

  return {
    canScan,
    limit,
    current: currentMonthScans,
    remaining,
  };
}

/**
 * Get storage limit for a subscription tier in bytes
 * @param subscriptionTier - The subscription tier to check
 * @returns Storage limit in bytes
 */
export function getStorageLimit(subscriptionTier: SubscriptionTier): number {
  const tierConfig = getTierConfig(subscriptionTier);
  const limitGB = tierConfig.features.storage_gb || 0;

  // Convert GB to bytes
  return limitGB * 1024 * 1024 * 1024;
}

// ========== UPLOAD DOCUMENT ABILITIES ===========
export function canUploadDocument(
  subscriptionTier: SubscriptionTier,
  currentStorageBytes: number,
  uploadSizeBytes: number
): StorageCapacity {
  const tierConfig = getTierConfig(subscriptionTier);

  // Check if document sharing is enabled for this tier
  if (!tierConfig.features.document_sharing) {
    return {
      canUpload: false,
      limit: 0,
      current: currentStorageBytes,
      remaining: 0,
      uploadSize: uploadSizeBytes,
    };
  }

  const limit = getStorageLimit(subscriptionTier);
  const remaining = Math.max(0, limit - currentStorageBytes);
  const canUpload = currentStorageBytes + uploadSizeBytes <= limit;

  return {
    canUpload,
    limit,
    current: currentStorageBytes,
    remaining,
    uploadSize: uploadSizeBytes,
  };
}

// ========== STORAGE AUTHORIZATION WITH CASL INTEGRATION ===========

/**
 * Get storage authorization with CASL integration
 * This function checks storage limits and returns authorization results that can be used
 * to block uploads when storage is exceeded, with explicit 'storage_exceeded' error status
 * @param subscriptionTier - User's subscription tier
 * @param currentStorageBytes - Current storage usage in bytes
 * @param uploadSizeBytes - Size of file to be uploaded in bytes
 * @returns StorageAuthorizationResult with CASL-compatible authorization status
 */
export function getStorageAuthorizationForCASL(
  subscriptionTier: SubscriptionTier,
  currentStorageBytes: number,
  uploadSizeBytes: number = 0
): StorageAuthorizationResult {
  return getStorageAuthorization(subscriptionTier, currentStorageBytes, uploadSizeBytes);
}

/**
 * Check storage permission for CASL ability rules
 * Returns permission check result indicating storage availability status
 * This can be used in CASL rules to conditionally allow/deny upload actions
 * @param subscriptionTier - User's subscription tier
 * @param currentStorageBytes - Current storage usage in bytes
 * @param uploadSizeBytes - Size of file to be uploaded in bytes
 * @returns Object with permission status and storage information
 */
export function checkStoragePermission(
  subscriptionTier: SubscriptionTier,
  currentStorageBytes: number,
  uploadSizeBytes: number = 0
): {
  hasPermission: boolean;
  storageStatus: 'available' | 'storage_exceeded' | 'invalid_tier';
  validation: StorageValidationResult;
  errorCode?: 'storage_exceeded' | 'invalid_tier';
  errorMessage?: string;
} {
  const authorization = getStorageAuthorization(subscriptionTier, currentStorageBytes, uploadSizeBytes);

  return {
    hasPermission: authorization.canUpload,
    storageStatus: authorization.storageStatus,
    validation: authorization.validation,
    errorCode: authorization.storageStatus === 'storage_exceeded' ? 'storage_exceeded' :
      authorization.storageStatus === 'invalid_tier' ? 'invalid_tier' : undefined,
    errorMessage: authorization.errorMessage,
  };
}

/**
 * Define CASL ability rules for storage operations with storage limit enforcement
 * This function extends the existing defineAbilitiesFor to include storage-based permissions
 * @param user - User object with subscription_tier and optional currentStorageBytes
 * @param currentStorageBytes - Current storage usage in bytes (optional, defaults to 0)
 * @returns Object with ability rules and storage authorization status
 */
export function defineStorageAbilities(
  user: { subscription_tier: SubscriptionTier; userId?: string },
  currentStorageBytes: number = 0
): {
  canUpload: boolean;
  storageStatus: 'available' | 'storage_exceeded' | 'invalid_tier';
  validation: StorageValidationResult;
  errorCode?: 'storage_exceeded' | 'invalid_tier';
  errorMessage?: string;
} {
  const tier = user.subscription_tier || 'free';
  const authorization = getStorageAuthorization(tier, currentStorageBytes, 0);

  return {
    canUpload: authorization.canUpload,
    storageStatus: authorization.storageStatus,
    validation: authorization.validation,
    errorCode: authorization.storageStatus === 'storage_exceeded' ? 'storage_exceeded' :
      authorization.storageStatus === 'invalid_tier' ? 'invalid_tier' : undefined,
    errorMessage: authorization.errorMessage,
  };
}

// ============ ANALYTICAL LEVEL =============
export function getAnalyticsLevel(
  subscriptionTier: SubscriptionTier
): 'basic' | 'advanced' | 'premium' {
  const tierConfig = getTierConfig(subscriptionTier);
  return tierConfig.features.analytics;
}

/**
 * Check if user has access to a specific feature
 * @param subscriptionTier - User's subscription tier
 * @param feature - Feature to check
 * @returns Boolean indicating if user has access
 */
export function hasFeatureAccess(
  subscriptionTier: SubscriptionTier,
  feature: keyof typeof getTierConfig extends (tier: SubscriptionTier) => infer R
    ? R extends { features: infer F }
    ? keyof F
    : never
    : never
): boolean {
  const tierConfig = getTierConfig(subscriptionTier);
  const featureValue = tierConfig.features[feature as keyof typeof tierConfig.features];

  if (typeof featureValue === 'boolean') {
    return featureValue;
  }

  if (typeof featureValue === 'number') {
    return featureValue > 0;
  }

  return featureValue !== undefined && featureValue !== 'basic';
}

/**
 * Check if user has permission to create memory tag scans
 * @param subscriptionTier - User's subscription tier
 * @param currentMemoryTagScanCount - Number of memory tag scans in current month
 * @returns Object with permission status and limit information
 */
export function canCreateMemoryTagScan(
  subscriptionTier: SubscriptionTier,
  currentMemoryTagScanCount: number
): { canScan: boolean; limit: number; current: number; remaining: number } {
  // Free tier: limited to 10 memory tag scans per month
  // Paid tiers: unlimited memory tag scans
  const tier = String(subscriptionTier ?? 'free')
    .trim()
    .toLowerCase() || 'free';
  const limit = tier === 'free' ? 10 : Infinity;
  const canScan = currentMemoryTagScanCount < limit;
  const remaining = limit === Infinity ? Infinity : Math.max(0, limit - currentMemoryTagScanCount);

  return {
    canScan,
    limit,
    current: currentMemoryTagScanCount,
    remaining,
  };
}
