import { Request, Response, NextFunction } from 'express';
import {
  defineAbilitiesFor,
  canUploadDocument,
  getStorageLimit,
} from '../config/abilities';
import { UniResponse } from '../lib/UniResponse';
import { ForbiddenError } from '@casl/ability';
import UserModel from '../models/User';
import MediaModel from '../models/MediaSchema';

/**
 * Extended Request interface to include user and ability information
 */
interface AuthenticatedRequest extends Request {
  user?: {
    userId: string;
    email: string;
    role: string;
  };
  ability?: ReturnType<typeof defineAbilitiesFor>;
  file?: Express.Multer.File;
  files?: Express.Multer.File[] | { [fieldname: string]: Express.Multer.File[] };
}

/**
 * Middleware to check if user can upload documents based on their subscription tier
 *
 * This middleware:
 * 1. Verifies user authentication
 * 2. Checks CASL abilities for document upload
 * 3. Validates storage limits based on subscription tier
 * 4. Provides detailed error messages with upgrade suggestions
 *
 * @example
 * router.post('/upload', authenticateToken, uploadMiddleware, checkStorageLimit, uploadDocument);
 */
export const checkStorageLimit = 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 || 'free';

    // Step 3: Define CASL abilities for the user
    const ability = defineAbilitiesFor({ subscription_tier: subscriptionTier, userId });
    req.ability = ability;

    // Step 4: Check CASL permissions for document upload
    try {
      ForbiddenError.from(ability).throwUnlessCan('upload', 'Document');
    } catch (error) {
      res.status(403).json(
        UniResponse.Error(
          'Document sharing is not available on your current plan. Please upgrade to Personal or Professional plan.',
          {
            subscription_tier: subscriptionTier,
            upgrade_required: true,
          },
          403
        )
      );
      return;
    }

    // Step 5: Calculate upload size
    let uploadSize = 0;
    if (req.file) {
      uploadSize = req.file.size;
    } else if (req.files) {
      if (Array.isArray(req.files)) {
        uploadSize = req.files.reduce((total, file) => total + file.size, 0);
      } else {
        // Handle { [fieldname: string]: Express.Multer.File[] }
        uploadSize = Object.values(req.files)
          .flat()
          .reduce((total, file) => total + file.size, 0);
      }
    }

    if (uploadSize === 0) {
      // No files to upload, proceed
      next();
      return;
    }

    // Step 6: Calculate current storage usage
    const userMedia = await MediaModel.find({ userId }).select('size');
    const currentStorage = userMedia.reduce(
      (total, media) => total + (media.size || 0),
      0
    );

    // Step 7: Check if user has enough storage
    const storageCheck = canUploadDocument(
      subscriptionTier,
      currentStorage,
      uploadSize
    );

    if (!storageCheck.canUpload) {
      const tierNames = {
        free: 'Free',
        personal: 'Personal',
        family: 'Family',
        professional: 'Professional',
      };

      const limitGB = (storageCheck.limit / (1024 * 1024 * 1024)).toFixed(2);
      const currentGB = (storageCheck.current / (1024 * 1024 * 1024)).toFixed(2);
      const uploadGB = (storageCheck.uploadSize / (1024 * 1024 * 1024)).toFixed(2);

      res.status(403).json(
        UniResponse.Error(
          `Storage limit exceeded. Your GB. Please upgrade your subscription or delete some files.`,
          {
            current_storage_bytes: storageCheck.current,
            limit_bytes: storageCheck.limit,
            upload_size_bytes: storageCheck.uploadSize,
            current_storage_gb: currentGB,
            limit_gb: limitGB,
            upload_size_gb: uploadGB,
            subscription_tier: subscriptionTier,
            upgrade_required: true,
          },
          403
        )
      );
      return;
    }

    // Step 8: User can upload, proceed to next middleware
    next();
  } catch (error) {
    console.error('Error in checkStorageLimit middleware:', error);
    res
      .status(500)
      .json(UniResponse.Error('Failed to check storage limits', null, 500));
  }
};

/**
 * Helper function to format bytes to human-readable format
 */
export function formatBytes(bytes: number, decimals: number = 2): string {
  if (bytes === 0) return '0 Bytes';

  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];

  const i = Math.floor(Math.log(bytes) / Math.log(k));

  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}
