import 'dotenv/config';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import UserModel from '../../models/User';
import { AuthValidation, ValidationUtils } from '../../validations';
import { MediaUtils } from '../../utils/MediaUtils';
import { OtpUtils } from '../../utils/OtpUtils';
import OtpModel from '../../models/Otp';
import { EmailService } from '../../utils/EmailService';
import { DeviceTokenUtils } from '../../utils/DeviceTokenUtils';
import {
  VerifyOtpRequest,
  ForgotPasswordRequest,
  CreateProfileRequest,
} from '../../types';
import { AuditLogger } from '../../utils/AuditLogger';
import mongoose from 'mongoose';
import { SubscriptionHelper } from '../../utils/subscriptionHelper';
import SubscriptionService from '../../services/subscription.service';
import { QRCodeService } from '../qr-code/qrcodeService';
import { getStorageLimit } from '../../config/abilities';
import { SubscriptionTier } from '../../config/subscriptionTiers';
import { bytesToMB } from '../../config/subscriptionTiers';
import MediaModel from '../../models/MediaSchema';
import { humanizeClientError } from '../../utils/humanReadableError';

// Type definition removed - using inline type inference to avoid complex union types

export class AuthService {
  // =========== REGISTER SERVICE ==============
  public static async RegisterService(userData: any) {
    try {
      // Validate input data
      const validationResult = AuthValidation.validateRegister(userData);
      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Check if user already exists and is not deleted
      const existingUser = await UserModel.findOne({
        email: value.email,
        is_delete: false,
      });
      if (existingUser) {
        return {
          success: false,
          message: 'User with this email already exists',
          data: null,
        };
      }

      // Hash password
      const saltRounds = 12;
      const hashedPassword = await bcrypt.hash(value.password, saltRounds);

      // Create user with minimal data
      const newUser = new UserModel({
        email: value.email,
        password: hashedPassword,
      });

      const savedUser = await newUser.save();

      // Log user registration
      await AuditLogger.logUserAction({
        action: 'USER_REGISTER',
        user_id: savedUser._id,
        email: savedUser.email!,
        description: `New user registered: ${savedUser.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          registration_time: new Date(),
          has_device_token: !!value.deviceToken,
        },
      });

      // ========== Create Free Subscription for New User ==========
      try {
        const subscriptionService = new SubscriptionService();
        await subscriptionService.createFreeSubscription(savedUser._id.toString());
        console.log(`Free subscription created for new user: ${savedUser.email}`);
      } catch (subscriptionError) {
        console.error(
          'Error creating free subscription during registration:',
          subscriptionError
        );
        // Don't fail registration if subscription creation fails
      }

      // ========== Update Device Token on Registration ==========
      if (value.deviceToken) {
        try {
          await DeviceTokenUtils.upsertDeviceToken(
            savedUser._id,
            value.deviceToken,
            value.deviceType,
            userData.user_agent
          );
          console.log(`Device token saved for new user: ${savedUser.email}`);
        } catch (deviceTokenError) {
          console.error(
            'Error saving device token during registration:',
            deviceTokenError
          );
        }
      }

      // Generate and send OTP via email
      const otpResult = await OtpUtils.createAndSendOtp(
        savedUser._id.toString(),
        savedUser?.email!,
        savedUser.first_name || 'User',
        'signup'
      );
      if (!otpResult.success) {
        return {
          success: false,
          message: 'User registered but failed to send OTP: ' + otpResult.message,
          data: null,
        };
      }

      // Remove password from response
      const userResponse = savedUser.toObject();
      delete (userResponse as any).password;

      return {
        success: true,
        message:
          'User registered successfully. Please verify your account with the OTP sent to your email.',
        data: {
          user: userResponse,
          requiresVerification: true,
        },
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'Registration could not be completed. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== LOGIN SERVICE ==============
  public static async LoginService(loginData: any) {
    try {
      // Validate input data
      const validationResult = AuthValidation.validateLogin(loginData);
      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Find user by email (exclude deleted users)
      const user = await UserModel.findOne({
        email: value.email,
      }).populate('media_id');

      if (!user) {
        // Log failed login attempt - user not found
        await AuditLogger.logSecurityEvent({
          action: 'SECURITY_LOGIN_ATTEMPT_FAILED',
          email: value.email,
          description: `Failed login attempt for ${value.email}: User not found`,
          status: 'FAILURE',
          severity: 'MEDIUM',
          metadata: {
            ip_address: loginData?.ip_address,
            user_agent: loginData?.user_agent,
            device_token: value?.deviceToken,
          },
        });

        return {
          success: false,
          message: 'Invalid email or password',
          data: null,
        };
      }

      if (user?.status?.toUpperCase()?.trim() !== 'ACTIVE') {
        return {
          success: false,
          message: 'Account disabled by administrator',
          data: null,
        };
      }

      // Check password
      const isPasswordValid = await bcrypt.compare(value.password, user?.password!);
      if (!isPasswordValid) {
        // Log failed login attempt - invalid password
        await AuditLogger.logSecurityEvent({
          action: 'SECURITY_LOGIN_ATTEMPT_FAILED',
          user_id: user._id,
          email: value.email,
          description: `Failed login attempt for ${value.email}: Invalid password`,
          status: 'FAILURE',
          severity: 'HIGH',
          metadata: {
            ip_address: loginData.ip_address,
            user_agent: loginData.user_agent,
            device_token: value.deviceToken,
          },
        });

        return {
          success: false,
          message: 'Invalid email or password',
          data: null,
        };
      }

      // Generate JWT token
      const jwtSecret = process.env.JWT_SECRET;
      if (!jwtSecret) {
        return {
          success: false,
          message: 'JWT secret is not configured',
          data: null,
        };
      }

      // ========== Update Device Token ==========
      if (value.deviceToken) {
        try {
          await DeviceTokenUtils.upsertDeviceToken(
            user._id,
            value.deviceToken,
            value.deviceType,
            loginData.user_agent
          );
          console.log(`Device token updated for user: ${user.email}`);
        } catch (deviceTokenError) {
          console.error('Error updating device token:', deviceTokenError);
        }
      }

      const payload = {
        userId: user._id.toString(),
        email: user.email,
        role: user.role,
      };

      // ========== ACTIVE USER LOGIN ==============
      const updatedUser = (await UserModel.findByIdAndUpdate(
        user._id,
        { isLogin: true },
        { new: true }
      )
        .select('-password')
        .populate('media_id')
        .lean()) as any;

      // =========== TOKEN GENERATION ==============
      const token = jwt.sign(payload, jwtSecret, {
        expiresIn: process.env.JWT_EXPIRES_IN || '7d',
      });

      // Log successful login
      await AuditLogger.logUserAction({
        action: 'USER_LOGIN',
        user_id: user._id,
        email: user.email!,
        description: `User logged in: ${user.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          ip_address: loginData.ip_address,
          user_agent: loginData.user_agent,
          device_token: value.deviceToken,
          login_time: new Date(),
        },
      });

      // Remove password from response
      const userResponse = user.toObject();
      delete (userResponse as any).password;

      // Get user's active subscription
      const subscriptionInfo = await SubscriptionHelper.getUserActiveSubscription(
        user._id
      );

      // Calculate subscription remaining time
      let daysRemaining: number | null = null;
      let isUnlimited = false;

      if (
        subscriptionInfo.subscription &&
        typeof subscriptionInfo.subscription === 'object' &&
        !Array.isArray(subscriptionInfo.subscription) &&
        'current_period_end' in subscriptionInfo.subscription
      ) {
        const periodEnd = new Date(
          (subscriptionInfo.subscription as { current_period_end?: string })
            .current_period_end!
        );
        const now = new Date();

        // Check if it's a free/lifetime subscription (set to far future date)
        if (periodEnd.getFullYear() >= 2099) {
          isUnlimited = true;
          daysRemaining = null;
        } else {
          const diffTime = periodEnd.getTime() - now.getTime();
          daysRemaining = Math.max(0, Math.ceil(diffTime / (1000 * 60 * 60 * 24)));
        }
      }

      // Get QR code limit information (excluding MEMORY_TAG type)
      let qrcodeLimitInfo = {
        limit: 0,
        current: 0,
        remaining: 0,
        canCreate: false,
      };

      try {
        const qrcodeLimit = await QRCodeService.checkQRCodeCreationLimit(
          user._id.toString()
        );
        qrcodeLimitInfo = {
          limit: qrcodeLimit.limit === Infinity ? -1 : qrcodeLimit.limit, // Use -1 for unlimited
          current: qrcodeLimit.current,
          remaining: qrcodeLimit.remaining === Infinity ? -1 : qrcodeLimit.remaining, // Use -1 for unlimited
          canCreate: qrcodeLimit.canCreate,
        };
      } catch (error) {
        console.error('Error getting QR code limit info:', error);
        // Continue with default values if there's an error
      }

      // Get storage limit information
      let storageInfo = {
        limit_bytes: 0,
        limit_mb: 0,
        limit_gb: 0,
        current_bytes: 0,
        current_mb: 0,
        current_gb: 0,
        remaining_bytes: 0,
        remaining_mb: 0,
        remaining_gb: 0,
        canUpload: false,
        isExceeded: false,
      };

      try {
        const subscriptionTier = subscriptionInfo.tier as SubscriptionTier;
        const storageLimitBytes = getStorageLimit(subscriptionTier);
        const currentStorageBytes = await QRCodeService.calculateUserStorageUsage(
          user._id.toString()
        );
        const remainingStorageBytes = Math.max(
          0,
          storageLimitBytes - currentStorageBytes
        );

        // Convert to MB and GB
        const limitMB = bytesToMB(storageLimitBytes);
        const currentMB = bytesToMB(currentStorageBytes);
        const remainingMB = bytesToMB(remainingStorageBytes);
        const limitGB = limitMB / 1024;
        const currentGB = currentMB / 1024;
        const remainingGB = remainingMB / 1024;

        storageInfo = {
          limit_bytes: storageLimitBytes,
          limit_mb: Math.round(limitMB * 100) / 100, // Round to 2 decimal places
          limit_gb: Math.round(limitGB * 100) / 100, // Round to 2 decimal places
          current_bytes: currentStorageBytes,
          current_mb: Math.round(currentMB * 100) / 100, // Round to 2 decimal places
          current_gb: Math.round(currentGB * 100) / 100, // Round to 2 decimal places
          remaining_bytes: remainingStorageBytes,
          remaining_mb: Math.round(remainingMB * 100) / 100, // Round to 2 decimal places
          remaining_gb: Math.round(remainingGB * 100) / 100, // Round to 2 decimal places
          canUpload: currentStorageBytes < storageLimitBytes,
          isExceeded: currentStorageBytes >= storageLimitBytes,
        };
      } catch (error) {
        console.error('Error getting storage info:', error);
        // Continue with default values if there's an error
      }

      // Build subscription details response
      const subscriptionDetails = {
        current: {
          tier: subscriptionInfo.tier,
          status:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { status?: string }).status ||
                'active'
              : 'active',
          period_start:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_start?: string })
                  .current_period_start || null
              : null,
          period_end:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
          interval:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { interval?: string }).interval ||
                null
              : null,
          amount:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { amount?: number }).amount || 0
              : 0,
          currency:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { currency?: string }).currency ||
                'usd'
              : 'usd',
        },
        remaining: {
          days: daysRemaining,
          is_unlimited: isUnlimited,
          expires_at:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
        },
        qrcode_limit: qrcodeLimitInfo,
        storage: storageInfo,
        full_subscription: subscriptionInfo.subscription,
      };

      const userWithSubscription = {
        ...updatedUser,
        ...(updatedUser?.role !== 'ADMIN' && {
          subscription: subscriptionInfo.subscription,
        }),
      };

      // Remove password from user object
      if (userWithSubscription.password) {
        delete (userWithSubscription as any).password;
      }

      // Check if user has verified OTP (type == 'signup' and isUsed == true)
      let isVerified = false;
      try {
        const verifiedOtp = await OtpModel.findOne({
          userId: user._id,
          type: 'signup',
          isUsed: true,
        });

        isVerified = !!verifiedOtp;
      } catch (error) {
        console.error('Error checking OTP verification status:', error);
      }

      return {
        success: true,
        message: 'Login successful',
        data: {
          user: userWithSubscription,
          token,
          isVerified,
          ...(userWithSubscription?.role !== 'ADMIN' && {
            subscription: subscriptionInfo.subscription,
          }),
          ...(userWithSubscription?.role !== 'ADMIN' && {
            subscription_tier: subscriptionInfo.tier,
          }),
          ...(userWithSubscription?.role !== 'ADMIN' && {
            subscription_info: subscriptionDetails,
          }),
        },
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'Sign-in could not be completed. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== GOOGLE LOGIN SERVICE ==============
  public static async GoogleLoginService(user: any, loginData: any = {}) {
    try {
      const jwtSecret = process.env.JWT_SECRET;
      if (!jwtSecret) {
        return {
          success: false,
          message: 'JWT secret is not configured',
          data: null,
        };
      }

      const payload = {
        userId: user._id.toString(),
        email: user.email,
        role: user.role,
      };

      // Set user as logged in
      const updatedUser = (await UserModel.findByIdAndUpdate(
        user._id,
        { isLogin: true },
        { new: true }
      )
        .select('-password')
        .populate('media_id')
        .lean()) as any;

      // Generate token
      const token = jwt.sign(payload, jwtSecret, {
        expiresIn: process.env.JWT_EXPIRES_IN || '7d',
      });

      // Log successful login
      await AuditLogger.logUserAction({
        action: 'USER_LOGIN_GOOGLE',
        user_id: user._id,
        email: user.email!,
        description: `User logged in via Google: ${user.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          ip_address: loginData.ip_address,
          user_agent: loginData.user_agent,
          login_time: new Date(),
        },
      });

      // Get user's active subscription
      const subscriptionInfo = await SubscriptionHelper.getUserActiveSubscription(
        user._id
      );

      // Calculate subscription remaining time
      let daysRemaining: number | null = null;
      let isUnlimited = false;

      if (
        subscriptionInfo.subscription &&
        typeof subscriptionInfo.subscription === 'object' &&
        !Array.isArray(subscriptionInfo.subscription) &&
        'current_period_end' in subscriptionInfo.subscription
      ) {
        const periodEnd = new Date(
          (subscriptionInfo.subscription as { current_period_end?: string })
            .current_period_end!
        );
        const now = new Date();

        if (periodEnd.getFullYear() >= 2099) {
          isUnlimited = true;
          daysRemaining = null;
        } else {
          const diffTime = periodEnd.getTime() - now.getTime();
          daysRemaining = Math.max(0, Math.ceil(diffTime / (1000 * 60 * 60 * 24)));
        }
      }

      // Get QR code limit information
      let qrcodeLimitInfo = {
        limit: 0,
        current: 0,
        remaining: 0,
        canCreate: false,
      };

      try {
        const qrcodeLimit = await QRCodeService.checkQRCodeCreationLimit(
          user._id.toString()
        );
        qrcodeLimitInfo = {
          limit: qrcodeLimit.limit === Infinity ? -1 : qrcodeLimit.limit,
          current: qrcodeLimit.current,
          remaining: qrcodeLimit.remaining === Infinity ? -1 : qrcodeLimit.remaining,
          canCreate: qrcodeLimit.canCreate,
        };
      } catch (error) {
        console.error('Error getting QR code limit info:', error);
      }

      // Get storage limit information
      let storageInfo = {
        limit_bytes: 0,
        limit_mb: 0,
        limit_gb: 0,
        current_bytes: 0,
        current_mb: 0,
        current_gb: 0,
        remaining_bytes: 0,
        remaining_mb: 0,
        remaining_gb: 0,
        canUpload: false,
        isExceeded: false,
      };

      try {
        const subscriptionTier = subscriptionInfo.tier as SubscriptionTier;
        const storageLimitBytes = getStorageLimit(subscriptionTier);
        const currentStorageBytes = await QRCodeService.calculateUserStorageUsage(
          user._id.toString()
        );
        const remainingStorageBytes = Math.max(
          0,
          storageLimitBytes - currentStorageBytes
        );

        const limitMB = bytesToMB(storageLimitBytes);
        const currentMB = bytesToMB(currentStorageBytes);
        const remainingMB = bytesToMB(remainingStorageBytes);
        const limitGB = limitMB / 1024;
        const currentGB = currentMB / 1024;
        const remainingGB = remainingMB / 1024;

        storageInfo = {
          limit_bytes: storageLimitBytes,
          limit_mb: Math.round(limitMB * 100) / 100,
          limit_gb: Math.round(limitGB * 100) / 100,
          current_bytes: currentStorageBytes,
          current_mb: Math.round(currentMB * 100) / 100,
          current_gb: Math.round(currentGB * 100) / 100,
          remaining_bytes: remainingStorageBytes,
          remaining_mb: Math.round(remainingMB * 100) / 100,
          remaining_gb: Math.round(remainingGB * 100) / 100,
          canUpload: currentStorageBytes < storageLimitBytes,
          isExceeded: currentStorageBytes >= storageLimitBytes,
        };
      } catch (error) {
        console.error('Error getting storage info:', error);
      }

      const subscriptionDetails = {
        current: {
          tier: subscriptionInfo.tier,
          status:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { status?: string }).status ||
                'active'
              : 'active',
          period_start:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_start?: string })
                  .current_period_start || null
              : null,
          period_end:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
          interval:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { interval?: string }).interval ||
                null
              : null,
          amount:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { amount?: number }).amount || 0
              : 0,
          currency:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { currency?: string }).currency ||
                'usd'
              : 'usd',
        },
        remaining: {
          days: daysRemaining,
          is_unlimited: isUnlimited,
          expires_at:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
        },
        qrcode_limit: qrcodeLimitInfo,
        storage: storageInfo,
        full_subscription: subscriptionInfo.subscription,
      };

      const userWithSubscription = {
        ...updatedUser,
        ...(updatedUser?.role !== 'ADMIN' && {
          subscription: subscriptionInfo.subscription,
        }),
      };

      // Remove password from user object
      if ((userWithSubscription as any).password) {
        delete (userWithSubscription as any).password;
      }

      return {
        success: true,
        message: 'Google login successful',
        data: {
          user: userWithSubscription,
          token,
          isVerified: true, // Google users are verified
          ...(userWithSubscription?.role !== 'ADMIN' && {
            subscription: subscriptionInfo.subscription,
          }),
          ...(userWithSubscription?.role !== 'ADMIN' && {
            subscription_tier: subscriptionInfo.tier,
          }),
          ...(userWithSubscription?.role !== 'ADMIN' && {
            subscription_info: subscriptionDetails,
          }),
        },
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'Google sign-in could not be completed. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== GET USER PROFILE SERVICE ==============
  public static async GetUserProfileService(userId: string) {
    try {
      const user = await UserModel.findOne({
        _id: userId,
        is_delete: false,
      })
        .select('-password')
        .populate('media_id');

      if (!user) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Get user's active subscription
      const subscriptionInfo =
        await SubscriptionHelper.getUserActiveSubscription(userId);

      // Combine user data with subscription info
      const userWithSubscription = {
        ...user.toObject(),
        subscription: subscriptionInfo.subscription,
        subscription_tier: subscriptionInfo.tier,
      };

      return {
        success: true,
        message: 'User profile retrieved successfully',
        data: userWithSubscription,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not load your profile. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== GET USER PROFILE BY ID SERVICE ==============
  public static async GetUserProfileByIdService(userId: string) {
    try {
      console.log(`================= USER ID ========================`);
      console.log(userId);

      const user = await UserModel.findOne({
        _id: userId,
      })
        .select('-password')
        .populate('media_id');

      console.log(`===============================`);
      console.log(user);
      console.log(`===============================`);

      if (!user) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Get user's active subscription
      const subscriptionInfo =
        await SubscriptionHelper.getUserActiveSubscription(userId);

      // Combine user data with subscription info
      const userWithSubscription = {
        ...user.toObject(),
        subscription: subscriptionInfo.subscription,
        subscription_tier: subscriptionInfo.tier,
      };

      return {
        success: true,
        message: 'User profile retrieved successfully',
        data: userWithSubscription,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not load your profile. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== UPDATE USER PROFILE SERVICE ==============
  public static async UpdateUserProfileService(
    userId: string,
    updateData: any,
    profilePicturePath?: string,
    fileData?: any,
    mediaId?: string,
    hostUrl?: string
  ) {
    try {
      console.log('=== UpdateUserProfileService START ===');
      console.log('userId:', userId);
      console.log('updateData:', JSON.stringify(updateData, null, 2));
      console.log('profilePicturePath:', profilePicturePath);
      console.log('mediaId:', mediaId);
      console.log('hostUrl:', hostUrl);
      console.log(
        'fileData:',
        fileData
          ? {
              originalname: fileData.originalname,
              mimetype: fileData.mimetype,
              size: fileData.size,
            }
          : null
      );

      // Get current user to check for existing media
      const currentUser = await UserModel.findOne({
        _id: userId,
        // is_delete: false,
      });
      console.log('currentUser found:', currentUser ? 'Yes' : 'No');
      if (currentUser) {
        console.log('currentUser.media_id:', currentUser.media_id);
      }

      if (!currentUser) {
        console.log('ERROR: User not found');
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Prepare update data - if media was uploaded, use the mediaId and filePath from insertMedia
      const updatedValue: any = { ...updateData };
      if (mediaId && profilePicturePath) {
        // Media record was already created in controller via insertMedia
        updatedValue.profile_picture = profilePicturePath;
        updatedValue.media_id = mediaId;
      }
      console.log('Updated value:', JSON.stringify(updatedValue, null, 2));

      // Update user profile - only update fields that were provided
      console.log('Updating user with data:', JSON.stringify(updatedValue, null, 2));
      const updatedUser = await UserModel.findByIdAndUpdate(userId, updatedValue, {
        new: true,
        runValidators: true,
      })
        .select('-password')
        .populate('media_id');

      console.log('User update result:', updatedUser ? 'Success' : 'Failed');
      if (updatedUser) {
        console.log('Updated user email:', updatedUser.email);
        console.log('Updated user media_id:', updatedUser.media_id);
      }

      if (!updatedUser) {
        console.log('ERROR: User update failed - user not found after update');
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Log profile update
      console.log('Logging profile update to AuditLogger...');
      await AuditLogger.logUserAction({
        action: 'USER_PROFILE_UPDATE',
        user_id: userId,
        email: updatedUser.email!,
        description: `User profile updated: ${updatedUser.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          updated_fields: Object.keys(updateData),
          has_new_profile_picture: !!fileData,
        },
      });
      console.log('AuditLogger log completed');

      // Clean up old media if a new profile picture was uploaded
      if (fileData && currentUser.media_id) {
        console.log('Cleaning up old media record:', currentUser.media_id.toString());
        try {
          await MediaUtils.deleteMediaRecord(currentUser.media_id.toString());
          console.log('Old media record deleted successfully');
        } catch (error) {
          // Log error but don't fail the operation
          console.warn('Failed to delete old media record:', error);
        }
      }

      // Get user's active subscription
      const subscriptionInfo =
        await SubscriptionHelper.getUserActiveSubscription(userId);

      // Calculate subscription remaining time
      let daysRemaining: number | null = null;
      let isUnlimited = false;

      if (
        subscriptionInfo.subscription &&
        typeof subscriptionInfo.subscription === 'object' &&
        !Array.isArray(subscriptionInfo.subscription) &&
        'current_period_end' in subscriptionInfo.subscription
      ) {
        const periodEnd = new Date(
          (subscriptionInfo.subscription as { current_period_end?: string })
            .current_period_end!
        );
        const now = new Date();

        // Check if it's a free/lifetime subscription (set to far future date)
        if (periodEnd.getFullYear() >= 2099) {
          isUnlimited = true;
          daysRemaining = null;
        } else {
          const diffTime = periodEnd.getTime() - now.getTime();
          daysRemaining = Math.max(0, Math.ceil(diffTime / (1000 * 60 * 60 * 24)));
        }
      }

      // Get QR code limit information
      let qrcodeLimitInfo = {
        limit: 0,
        current: 0,
        remaining: 0,
        canCreate: false,
      };

      try {
        const qrcodeLimit = await QRCodeService.checkQRCodeCreationLimit(userId);
        qrcodeLimitInfo = {
          limit: qrcodeLimit.limit === Infinity ? -1 : qrcodeLimit.limit,
          current: qrcodeLimit.current,
          remaining: qrcodeLimit.remaining === Infinity ? -1 : qrcodeLimit.remaining,
          canCreate: qrcodeLimit.canCreate,
        };
      } catch (error) {
        console.error('Error getting QR code limit info:', error);
      }

      // Get storage limit information
      let storageInfo = {
        limit_bytes: 0,
        limit_mb: 0,
        limit_gb: 0,
        current_bytes: 0,
        current_mb: 0,
        current_gb: 0,
        remaining_bytes: 0,
        remaining_mb: 0,
        remaining_gb: 0,
        canUpload: false,
        isExceeded: false,
      };

      try {
        const subscriptionTier = subscriptionInfo.tier as SubscriptionTier;
        const storageLimitBytes = getStorageLimit(subscriptionTier);
        const currentStorageBytes =
          await QRCodeService.calculateUserStorageUsage(userId);
        const remainingStorageBytes = Math.max(
          0,
          storageLimitBytes - currentStorageBytes
        );

        const limitMB = bytesToMB(storageLimitBytes);
        const currentMB = bytesToMB(currentStorageBytes);
        const remainingMB = bytesToMB(remainingStorageBytes);
        const limitGB = limitMB / 1024;
        const currentGB = currentMB / 1024;
        const remainingGB = remainingMB / 1024;

        storageInfo = {
          limit_bytes: storageLimitBytes,
          limit_mb: Math.round(limitMB * 100) / 100,
          limit_gb: Math.round(limitGB * 100) / 100,
          current_bytes: currentStorageBytes,
          current_mb: Math.round(currentMB * 100) / 100,
          current_gb: Math.round(currentGB * 100) / 100,
          remaining_bytes: remainingStorageBytes,
          remaining_mb: Math.round(remainingMB * 100) / 100,
          remaining_gb: Math.round(remainingGB * 100) / 100,
          canUpload: currentStorageBytes < storageLimitBytes,
          isExceeded: currentStorageBytes >= storageLimitBytes,
        };
      } catch (error) {
        console.error('Error getting storage info:', error);
      }

      // Build subscription details response
      const subscriptionDetails = {
        current: {
          tier: subscriptionInfo.tier,
          status:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { status?: string }).status ||
                'active'
              : 'active',
          period_start:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_start?: string })
                  .current_period_start || null
              : null,
          period_end:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
          interval:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { interval?: string }).interval ||
                null
              : null,
          amount:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { amount?: number }).amount || 0
              : 0,
          currency:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { currency?: string }).currency ||
                'usd'
              : 'usd',
        },
        remaining: {
          days: daysRemaining,
          is_unlimited: isUnlimited,
          expires_at:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
        },
        qrcode_limit: qrcodeLimitInfo,
        storage: storageInfo,
        full_subscription: subscriptionInfo.subscription,
      };

      const userWithSubscription = {
        ...(updatedUser as any).toObject(),
        ...((updatedUser as any)?.role !== 'ADMIN' && {
          subscription: subscriptionInfo.subscription,
        }),
      };

      console.log('=== UpdateUserProfileService SUCCESS ===');
      return {
        success: true,
        message: 'Profile updated successfully',
        data: {
          ...userWithSubscription,
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription: subscriptionInfo.subscription,
          }),
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription_tier: subscriptionInfo.tier,
          }),
          ...((userWithSubscription?.role as any) !== 'ADMIN' && {
            subscription_info: subscriptionDetails,
          }),
        },
      };
    } catch (error: any) {
      console.error('=== UpdateUserProfileService ERROR ===');
      console.error('Error message:', error.message);
      console.error('Error stack:', error.stack);
      console.error('Error details:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not update your profile. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== CHANGE PASSWORD SERVICE ==============
  public static async ChangePasswordService(
    userId: string,
    passwordData: any,
    isPasswordReset: boolean = false
  ) {
    try {
      let validationResult;

      if (isPasswordReset) {
        // For password reset, only validate new password
        validationResult = AuthValidation.validateResetPassword(passwordData);
      } else {
        // For regular password change, validate current and new password
        validationResult = AuthValidation.validateChangePassword(passwordData);
      }

      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Find user (exclude deleted users)
      const user = await UserModel.findOne({
        _id: userId,
        is_delete: false,
      });
      if (!user) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // For regular password change, check current password
      if (!isPasswordReset) {
        const isCurrentPasswordValid = await bcrypt.compare(
          value?.currentPassword,
          user?.password!
        );
        if (!isCurrentPasswordValid) {
          return {
            success: false,
            message: 'Current password is incorrect',
            data: null,
          };
        }
      }

      // Hash new password
      const saltRounds = 12;
      const hashedNewPassword = await bcrypt.hash(value.newPassword, saltRounds);

      // Update password
      await UserModel.findByIdAndUpdate(userId, { password: hashedNewPassword });

      // Log password change
      await AuditLogger.logUserAction({
        action: isPasswordReset ? 'USER_PASSWORD_RESET' : 'USER_PASSWORD_CHANGE',
        user_id: userId,
        email: user.email!,
        description: `Password ${isPasswordReset ? 'reset' : 'changed'} for user: ${user.email}`,
        status: 'SUCCESS',
        severity: 'MEDIUM',
        metadata: {
          is_password_reset: isPasswordReset,
        },
      });

      const message = isPasswordReset
        ? 'Password reset successfully'
        : 'Password changed successfully';

      return {
        success: true,
        message: message,
        data: null,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not change your password. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== UPDATE PROFILE PICTURE SERVICE ==============
  public static async UpdateProfilePictureService(
    userId: string,
    profilePicturePath: string,
    fileData: any
  ) {
    try {
      // Find user to get current media_id for cleanup
      const currentUser = await UserModel.findOne({
        _id: userId,
        is_delete: false,
      });
      if (!currentUser) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Create new media record
      const mediaResult = await MediaUtils.createMediaRecord(
        fileData,
        profilePicturePath
      );

      if (!mediaResult) {
        return {
          success: false,
          message: 'Failed to process media file',
          data: null,
        };
      }

      // Update user with new media information
      const updatedUser = await UserModel.findByIdAndUpdate(
        userId,
        {
          profile_picture: mediaResult.filePath,
          media_id: mediaResult.mediaId,
        },
        { new: true, runValidators: true }
      )
        .select('-password')
        .populate('media_id');

      // Clean up old media record if it exists
      if (currentUser.media_id) {
        try {
          await MediaUtils.deleteMediaRecord(currentUser.media_id.toString());
        } catch (error) {
          // Log error but don't fail the operation
          console.warn('Failed to delete old media record:', error);
        }
      }

      return {
        success: true,
        message: 'Profile picture updated successfully',
        data: updatedUser,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not update your profile picture. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== VERIFY OTP SERVICE ==============
  public static async VerifyOtpService(otpData: VerifyOtpRequest) {
    try {
      // Validate input data with type support
      const validationResult = AuthValidation.validateVerifyOtpWithType(otpData);

      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Find user by email (exclude deleted users)
      const user = await UserModel.findOne({
        email: value.email,
        is_delete: false,
      });
      if (!user) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Verify OTP with type
      const verifyResult = await OtpUtils.verifyOtp(
        user._id.toString(),
        value.otp,
        value.type
      );
      if (!verifyResult.success) {
        return {
          success: false,
          message: verifyResult.message,
          data: null,
        };
      }

      // Handle different OTP types
      if (value?.type?.trim() === 'signup') {
        // Generate JWT token after successful signup verification
        const jwtSecret = process.env.JWT_SECRET;
        if (!jwtSecret) {
          return {
            success: false,
            message: 'JWT secret is not configured',
            data: null,
          };
        }

        const payload = {
          userId: user._id.toString(),
          email: user.email,
          role: user.role,
        };

        const token = jwt.sign(payload, jwtSecret, {
          expiresIn: process.env.JWT_EXPIRES_IN || '7d',
        });

        // Log OTP verification
        await AuditLogger.logUserAction({
          action: 'USER_OTP_VERIFY',
          user_id: user._id,
          email: user.email!,
          description: `OTP verified successfully for signup: ${user.email}`,
          status: 'SUCCESS',
          severity: 'LOW',
          metadata: {
            otp_type: 'signup',
          },
        });

        // ========== Get Subscription Information ==========
        let subscriptionInfo = { tier: 'free' as any, subscription: null as any };
        let subscriptionDetails = null;

        try {
          const subscriptionService = new SubscriptionService();
          subscriptionInfo = await subscriptionService.getUserSubscription(
            user._id.toString()
          );

          // Build simplified subscription details for frontend
          const isUnlimited =
            subscriptionInfo.tier === 'pro' || subscriptionInfo.tier === 'enterprise';
          let daysRemaining = null;

          if (!isUnlimited && subscriptionInfo.subscription?.current_period_end) {
            const end = new Date(subscriptionInfo.subscription.current_period_end);
            const now = new Date();
            daysRemaining = Math.max(
              0,
              Math.ceil((end.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
            );
          }

          // Get QR code limit information
          let qrcodeLimitInfo = { limit: 2, current: 0, remaining: 2, canCreate: true };
          try {
            const qrcodeLimit = await QRCodeService.checkQRCodeCreationLimit(
              user._id.toString()
            );
            qrcodeLimitInfo = {
              limit: qrcodeLimit.limit === Infinity ? -1 : qrcodeLimit.limit,
              current: qrcodeLimit.current,
              remaining:
                qrcodeLimit.remaining === Infinity ? -1 : qrcodeLimit.remaining,
              canCreate: qrcodeLimit.canCreate,
            };
          } catch (error) {
            console.error('Error getting QR code limit info:', error);
          }

          // Get storage limit information
          let storageInfo = {
            limit_bytes: 0,
            limit_mb: 0,
            limit_gb: 0,
            current_bytes: 0,
            current_mb: 0,
            current_gb: 0,
            remaining_bytes: 0,
            remaining_mb: 0,
            remaining_gb: 0,
            canUpload: false,
            isExceeded: false,
          };

          try {
            const subscriptionTier = subscriptionInfo.tier as SubscriptionTier;
            const storageLimitBytes = getStorageLimit(subscriptionTier);
            const currentStorageBytes = await QRCodeService.calculateUserStorageUsage(
              user._id.toString()
            );
            const remainingStorageBytes = Math.max(
              0,
              storageLimitBytes - currentStorageBytes
            );

            const limitMB = bytesToMB(storageLimitBytes);
            const currentMB = bytesToMB(currentStorageBytes);
            const remainingMB = bytesToMB(remainingStorageBytes);
            const limitGB = limitMB / 1024;
            const currentGB = currentMB / 1024;
            const remainingGB = remainingMB / 1024;

            storageInfo = {
              limit_bytes: storageLimitBytes,
              limit_mb: Math.round(limitMB * 100) / 100,
              limit_gb: Math.round(limitGB * 100) / 100,
              current_bytes: currentStorageBytes,
              current_mb: Math.round(currentMB * 100) / 100,
              current_gb: Math.round(currentGB * 100) / 100,
              remaining_bytes: remainingStorageBytes,
              remaining_mb: Math.round(remainingMB * 100) / 100,
              remaining_gb: Math.round(remainingGB * 100) / 100,
              canUpload: currentStorageBytes < storageLimitBytes,
              isExceeded: currentStorageBytes >= storageLimitBytes,
            };
          } catch (error) {
            console.error('Error getting storage info:', error);
          }

          subscriptionDetails = {
            current: {
              tier: subscriptionInfo.tier,
              status:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { status?: string }).status ||
                    'active'
                  : 'active',
              period_start:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { current_period_start?: string })
                      .current_period_start || null
                  : null,
              period_end:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { current_period_end?: string })
                      .current_period_end || null
                  : null,
              interval:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { interval?: string }).interval ||
                    null
                  : null,
              amount:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { amount?: number }).amount || 0
                  : 0,
              currency:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { currency?: string }).currency ||
                    'usd'
                  : 'usd',
            },
            remaining: {
              days: daysRemaining,
              is_unlimited: isUnlimited,
              expires_at:
                subscriptionInfo.subscription &&
                typeof subscriptionInfo.subscription === 'object' &&
                !Array.isArray(subscriptionInfo.subscription)
                  ? (subscriptionInfo.subscription as { current_period_end?: string })
                      .current_period_end || null
                  : null,
            },
            qrcode_limit: qrcodeLimitInfo,
            storage: storageInfo,
            full_subscription: subscriptionInfo.subscription,
          };
        } catch (subError) {
          console.error('Error getting subscription for verified user:', subError);
        }

        // Remove password from response
        const userWithSubscription = {
          ...user.toObject(),
          ...(user?.role !== 'ADMIN' && {
            subscription: subscriptionInfo.subscription,
          }),
        };

        if ((userWithSubscription as any).password) {
          delete (userWithSubscription as any).password;
        }

        return {
          success: true,
          message: 'OTP verified successfully',
          data: {
            user: userWithSubscription,
            token,
            isVerified: true,
            ...(userWithSubscription?.role !== 'ADMIN' && {
              subscription: subscriptionInfo.subscription,
            }),
            ...(userWithSubscription?.role !== 'ADMIN' && {
              subscription_tier: subscriptionInfo.tier,
            }),
            ...(userWithSubscription?.role !== 'ADMIN' && {
              subscription_info: subscriptionDetails,
            }),
          },
        };
      } else if (value.type.trim() === 'forgot-password') {
        // For forgot password, generate a temporary token for password reset
        const jwtSecret = process.env.JWT_SECRET;
        if (!jwtSecret) {
          return {
            success: false,
            message: 'JWT secret is not configured',
            data: null,
          };
        }

        const payload = {
          userId: user._id.toString(),
          email: user.email,
          role: user.role,
          type: 'password-reset',
          iat: Math.floor(Date.now() / 1000),
        };

        // Generate a short-lived token for password reset (15 minutes)
        const resetToken = jwt.sign(payload, jwtSecret, {
          expiresIn: '15m',
        });

        return {
          success: true,
          message: 'OTP verified successfully. You can now reset your password.',
          data: {
            verified: true,
            email: user.email,
            token: resetToken,
          },
        };
      } else if (value.type.trim() === 'resend-otp' || value.type == '') {
        const jwtSecret = process.env.JWT_SECRET;
        if (!jwtSecret) {
          return {
            success: false,
            message: 'JWT secret is not configured',
            data: null,
          };
        }

        const payload = {
          userId: user._id.toString(),
          email: user.email,
          role: user.role,
          type: 'password-reset',
          iat: Math.floor(Date.now() / 1000),
        };

        const token = jwt.sign(payload, jwtSecret, {
          expiresIn: process.env.JWT_EXPIRES_IN || '7d',
        });

        // Generate a short-lived token for password reset (15 minutes)
        const resetToken = jwt.sign(payload, jwtSecret, {
          expiresIn: '15m',
        });

        return {
          success: true,
          message: 'OTP verified successfully. You can now use new OTP code.',
          data: {
            verified: true,
            email: user?.email,
            token: resetToken,
          },
        };
      }

      return {
        success: false,
        message: 'Invalid OTP type',
        data: null,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not verify that code. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== RESEND OTP SERVICE ==============
  public static async ResendOtpService(resendData: any) {
    try {
      // Validate input data
      const validationResult = AuthValidation.validateResendOtp(resendData);
      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Find user by email (exclude deleted users)
      const user = await UserModel.findOne({
        email: value.email,
        is_delete: false,
      });
      if (!user) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Generate and send new OTP via email
      const otpResult = await OtpUtils.createAndSendOtp(
        user._id.toString(),
        user?.email!,
        user?.first_name!,
        'resend-otp'
      );
      if (!otpResult.success) {
        return {
          success: false,
          message: otpResult.message,
          data: null,
        };
      }

      return {
        success: true,
        message: 'OTP sent successfully',
        data: null,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not resend your verification code. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== FORGOT PASSWORD SERVICE ==============
  public static async ForgotPasswordService(forgotPasswordData: ForgotPasswordRequest) {
    try {
      // Validate input data
      const validationResult =
        AuthValidation.validateForgotPassword(forgotPasswordData);
      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Find user by email (exclude deleted users)
      const user = await UserModel.findOne({
        email: value.email,
        is_delete: false,
      });
      if (!user) {
        return {
          success: false,
          message: 'User not found with this email address',
          data: null,
        };
      }

      // Generate and send OTP for forgot password
      const otpResult = await OtpUtils.createAndSendOtp(
        user._id.toString(),
        user?.email!,
        user?.first_name!,
        'forgot-password'
      );

      if (!otpResult.success) {
        return {
          success: false,
          message: otpResult.message,
          data: null,
        };
      }

      return {
        success: true,
        message: 'Password reset OTP sent successfully to your email',
        data: null,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not process your password reset request. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== CREATE PROFILE SERVICE ==============
  public static async CreateProfileService(
    userId: string,
    profileData: CreateProfileRequest,
    profilePicturePath?: string,
    fileData?: any,
    hostUrl?: string
  ) {
    try {
      // Validate input data
      const validationResult = AuthValidation.validateCreateProfile(profileData);
      if (!ValidationUtils.isValidationSuccess(validationResult)) {
        return {
          success: false,
          message: ValidationUtils.formatValidationError(validationResult.error),
          data: null,
        };
      }
      const value = ValidationUtils.getValidatedData(validationResult);

      // Check if user exists and is not deleted
      const existingUser = await UserModel.findOne({
        _id: userId,
        is_delete: false,
      });
      if (!existingUser) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Check if email is already taken by another user
      if (value?.email !== existingUser?.email) {
        const emailExists = await UserModel.findOne({
          email: value.email,
          _id: { $ne: userId },
          is_delete: false,
        });
        if (emailExists) {
          return {
            success: false,
            message: 'Email is already taken by another user',
            data: null,
          };
        }
      }

      // Handle media upload if file is provided
      const updatedValue = await MediaUtils.handleUserMedia(
        value,
        fileData,
        profilePicturePath,
        hostUrl
      );

      // ========== Update Device Token on Profile Creation ==========
      if (value.deviceToken) {
        try {
          await DeviceTokenUtils.upsertDeviceToken(
            userId,
            value.deviceToken,
            value.deviceType,
            profileData.user_agent
          );
          console.log(
            `Device token updated during profile creation for user: ${userId}`
          );
        } catch (deviceTokenError) {
          console.error(
            'Error updating device token during profile creation:',
            deviceTokenError
          );
        }
      }

      // Update user profile with new data
      const updatedUser = await UserModel.findByIdAndUpdate(
        userId,
        { $set: { ...updatedValue, isProfileComplete: true } },
        { new: true, runValidators: true }
      )
        .select('-password')
        .populate('media_id')
        .lean();

      console.log(`===============================================================`);
      console.log('🚀 ~ AuthService.createProfile ~ updatedUser:', updatedUser);
      console.log(`===============================================================`);

      if (!updatedUser || Array.isArray(updatedUser)) {
        return {
          success: false,
          message: 'Failed to update profile',
          data: null,
        };
      }

      // Log profile creation
      await AuditLogger.logUserAction({
        action: 'USER_PROFILE_UPDATE',
        user_id: userId,
        email: updatedUser.email!,
        description: `User profile created: ${updatedUser.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          profile_fields: Object.keys(updatedValue),
          has_profile_picture: !!fileData,
        },
      });

      // Send welcome email after successful profile creation (only for the first time)
      if (!existingUser.isProfileComplete) {
        try {
          const emailServiceInstance = new EmailService();
          await emailServiceInstance.sendWelcomeEmail(
            updatedUser.email!,
            profileData?.first_name ?? (updatedUser as any).name ?? 'User'
          );
        } catch (error) {
          // Don't fail the operation if welcome email fails
          console.log('Welcome email failed to send:', error);
        }
      }

      // Clean up old media if a new profile picture was uploaded
      if (fileData && existingUser.media_id) {
        try {
          await MediaUtils.deleteMediaRecord(existingUser.media_id.toString());
        } catch (error) {
          // Log error but don't fail the operation
          console.warn('Failed to delete old media record:', error);
        }
      }

      // Get user's active subscription
      const subscriptionInfo =
        await SubscriptionHelper.getUserActiveSubscription(userId);

      // Calculate subscription remaining time
      let daysRemaining: number | null = null;
      let isUnlimited = false;

      if (
        subscriptionInfo.subscription &&
        typeof subscriptionInfo.subscription === 'object' &&
        !Array.isArray(subscriptionInfo.subscription) &&
        'current_period_end' in subscriptionInfo.subscription
      ) {
        const periodEnd = new Date(
          (subscriptionInfo.subscription as { current_period_end?: string })
            .current_period_end!
        );
        const now = new Date();

        // Check if it's a free/lifetime subscription (set to far future date)
        if (periodEnd.getFullYear() >= 2099) {
          isUnlimited = true;
          daysRemaining = null;
        } else {
          const diffTime = periodEnd.getTime() - now.getTime();
          daysRemaining = Math.max(0, Math.ceil(diffTime / (1000 * 60 * 60 * 24)));
        }
      }

      // Get QR code limit information (excluding MEMORY_TAG type)
      let qrcodeLimitInfo = {
        limit: 0,
        current: 0,
        remaining: 0,
        canCreate: false,
      };

      try {
        const qrcodeLimit = await QRCodeService.checkQRCodeCreationLimit(userId);
        qrcodeLimitInfo = {
          limit: qrcodeLimit.limit === Infinity ? -1 : qrcodeLimit.limit, // Use -1 for unlimited
          current: qrcodeLimit.current,
          remaining: qrcodeLimit.remaining === Infinity ? -1 : qrcodeLimit.remaining, // Use -1 for unlimited
          canCreate: qrcodeLimit.canCreate,
        };
      } catch (error) {
        console.error('Error getting QR code limit info:', error);
      }

      // Get storage limit information
      let storageInfo = {
        limit_bytes: 0,
        limit_mb: 0,
        limit_gb: 0,
        current_bytes: 0,
        current_mb: 0,
        current_gb: 0,
        remaining_bytes: 0,
        remaining_mb: 0,
        remaining_gb: 0,
        canUpload: false,
        isExceeded: false,
      };

      try {
        const subscriptionTier = subscriptionInfo.tier as SubscriptionTier;
        const storageLimitBytes = getStorageLimit(subscriptionTier);
        const currentStorageBytes =
          await QRCodeService.calculateUserStorageUsage(userId);
        const remainingStorageBytes = Math.max(
          0,
          storageLimitBytes - currentStorageBytes
        );

        // Convert to MB and GB
        const limitMB = bytesToMB(storageLimitBytes);
        const currentMB = bytesToMB(currentStorageBytes);
        const remainingMB = bytesToMB(remainingStorageBytes);
        const limitGB = limitMB / 1024;
        const currentGB = currentMB / 1024;
        const remainingGB = remainingMB / 1024;

        storageInfo = {
          limit_bytes: storageLimitBytes,
          limit_mb: Math.round(limitMB * 100) / 100,
          limit_gb: Math.round(limitGB * 100) / 100,
          current_bytes: currentStorageBytes,
          current_mb: Math.round(currentMB * 100) / 100,
          current_gb: Math.round(currentGB * 100) / 100,
          remaining_bytes: remainingStorageBytes,
          remaining_mb: Math.round(remainingMB * 100) / 100,
          remaining_gb: Math.round(remainingGB * 100) / 100,
          canUpload: currentStorageBytes < storageLimitBytes,
          isExceeded: currentStorageBytes >= storageLimitBytes,
        };
      } catch (error) {
        console.error('Error getting storage info:', error);
      }

      // Build subscription details response
      const subscriptionDetails = {
        current: {
          tier: subscriptionInfo.tier,
          status:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { status?: string }).status ||
                'active'
              : 'active',
          period_start:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_start?: string })
                  .current_period_start || null
              : null,
          period_end:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
          interval:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { interval?: string }).interval ||
                null
              : null,
          amount:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { amount?: number }).amount || 0
              : 0,
          currency:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { currency?: string }).currency ||
                'usd'
              : 'usd',
        },
        remaining: {
          days: daysRemaining,
          is_unlimited: isUnlimited,
          expires_at:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
        },
        qrcode_limit: qrcodeLimitInfo,
        storage: storageInfo,
        full_subscription: subscriptionInfo.subscription,
      };

      const userWithSubscription = {
        ...(updatedUser as any),
        ...((updatedUser as any)?.role !== 'ADMIN' && {
          subscription: subscriptionInfo.subscription,
        }),
      };

      console.log(userWithSubscription);

      return {
        success: true,
        message: 'Profile created successfully',
        data: {
          ...(userWithSubscription as any),
          isProfileCompleted: true,
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription: subscriptionInfo.subscription,
          }),
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription_tier: subscriptionInfo.tier,
          }),
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription_info: subscriptionDetails,
          }),
        },
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not create your profile. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== EDIT PROFILE SERVICE ==============
  public static async EditProfileService(
    userId: string,
    updateData: any,
    profilePicturePath?: string,
    fileData?: any
  ) {
    try {
      // Get current user to check for existing media and validate updates
      const currentUser = await UserModel.findOne({
        _id: userId,
        is_delete: false,
      });
      if (!currentUser) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Handle media upload if file is provided, otherwise use updateData directly
      let updatedValue = updateData;
      if (fileData && profilePicturePath) {
        updatedValue = await MediaUtils.handleUserMedia(
          updateData,
          fileData,
          profilePicturePath
        );
      }

      // Update user profile - only update fields that were provided
      console.log('Updating user with data:', JSON.stringify(updatedValue, null, 2));
      const updatedUser = await UserModel.findByIdAndUpdate(
        userId,
        { $set: updatedValue },
        {
          new: true,
          runValidators: true,
        }
      )
        .select('-password')
        .populate('media_id');

      console.log('User update result:', updatedUser ? 'Success' : 'Failed');
      if (updatedUser) {
        console.log('Updated user email:', updatedUser.email);
        console.log('Updated user first_name:', updatedUser.first_name);
        console.log('Updated user last_name:', updatedUser.last_name);
        console.log('Updated user media_id:', updatedUser.media_id);
      }

      if (!updatedUser) {
        console.log('ERROR: User update failed');
        return {
          success: false,
          message: 'Failed to update profile',
          data: null,
        };
      }

      // Log profile edit
      await AuditLogger.logUserAction({
        action: 'USER_PROFILE_UPDATE',
        user_id: userId,
        email: updatedUser.email!,
        description: `User profile edited: ${updatedUser.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          updated_fields: Object.keys(updateData),
          has_new_profile_picture: !!fileData,
        },
      });

      // Clean up old media if a new profile picture was uploaded
      if (fileData && currentUser.media_id) {
        try {
          await MediaUtils.deleteMediaRecord(currentUser.media_id.toString());
        } catch (error) {
          // Log error but don't fail the operation
          console.warn('Failed to delete old media record:', error);
        }
      }

      // Get user's active subscription
      const subscriptionInfo =
        await SubscriptionHelper.getUserActiveSubscription(userId);

      // Calculate subscription remaining time
      let daysRemaining: number | null = null;
      let isUnlimited = false;

      if (
        subscriptionInfo.subscription &&
        typeof subscriptionInfo.subscription === 'object' &&
        !Array.isArray(subscriptionInfo.subscription) &&
        'current_period_end' in subscriptionInfo.subscription
      ) {
        const periodEnd = new Date(
          (subscriptionInfo.subscription as { current_period_end?: string })
            .current_period_end!
        );
        const now = new Date();

        // Check if it's a free/lifetime subscription (set to far future date)
        if (periodEnd.getFullYear() >= 2099) {
          isUnlimited = true;
          daysRemaining = null;
        } else {
          const diffTime = periodEnd.getTime() - now.getTime();
          daysRemaining = Math.max(0, Math.ceil(diffTime / (1000 * 60 * 60 * 24)));
        }
      }

      // Get QR code limit information
      let qrcodeLimitInfo = {
        limit: 0,
        current: 0,
        remaining: 0,
        canCreate: false,
      };

      try {
        const qrcodeLimit = await QRCodeService.checkQRCodeCreationLimit(userId);
        qrcodeLimitInfo = {
          limit: qrcodeLimit.limit === Infinity ? -1 : qrcodeLimit.limit,
          current: qrcodeLimit.current,
          remaining: qrcodeLimit.remaining === Infinity ? -1 : qrcodeLimit.remaining,
          canCreate: qrcodeLimit.canCreate,
        };
      } catch (error) {
        console.error('Error getting QR code limit info:', error);
      }

      // Get storage limit information
      let storageInfo = {
        limit_bytes: 0,
        limit_mb: 0,
        limit_gb: 0,
        current_bytes: 0,
        current_mb: 0,
        current_gb: 0,
        remaining_bytes: 0,
        remaining_mb: 0,
        remaining_gb: 0,
        canUpload: false,
        isExceeded: false,
      };

      try {
        const subscriptionTier = subscriptionInfo.tier as SubscriptionTier;
        const storageLimitBytes = getStorageLimit(subscriptionTier);
        const currentStorageBytes =
          await QRCodeService.calculateUserStorageUsage(userId);
        const remainingStorageBytes = Math.max(
          0,
          storageLimitBytes - currentStorageBytes
        );

        const limitMB = bytesToMB(storageLimitBytes);
        const currentMB = bytesToMB(currentStorageBytes);
        const remainingMB = bytesToMB(remainingStorageBytes);
        const limitGB = limitMB / 1024;
        const currentGB = currentMB / 1024;
        const remainingGB = remainingMB / 1024;

        storageInfo = {
          limit_bytes: storageLimitBytes,
          limit_mb: Math.round(limitMB * 100) / 100,
          limit_gb: Math.round(limitGB * 100) / 100,
          current_bytes: currentStorageBytes,
          current_mb: Math.round(currentMB * 100) / 100,
          current_gb: Math.round(currentGB * 100) / 100,
          remaining_bytes: remainingStorageBytes,
          remaining_mb: Math.round(remainingMB * 100) / 100,
          remaining_gb: Math.round(remainingGB * 100) / 100,
          canUpload: currentStorageBytes < storageLimitBytes,
          isExceeded: currentStorageBytes >= storageLimitBytes,
        };
      } catch (error) {
        console.error('Error getting storage info:', error);
      }

      // Build subscription details response
      const subscriptionDetails = {
        current: {
          tier: subscriptionInfo.tier,
          status:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { status?: string }).status ||
                'active'
              : 'active',
          period_start:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_start?: string })
                  .current_period_start || null
              : null,
          period_end:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
          interval:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { interval?: string }).interval ||
                null
              : null,
          amount:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { amount?: number }).amount || 0
              : 0,
          currency:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { currency?: string }).currency ||
                'usd'
              : 'usd',
        },
        remaining: {
          days: daysRemaining,
          is_unlimited: isUnlimited,
          expires_at:
            subscriptionInfo.subscription &&
            typeof subscriptionInfo.subscription === 'object' &&
            !Array.isArray(subscriptionInfo.subscription)
              ? (subscriptionInfo.subscription as { current_period_end?: string })
                  .current_period_end || null
              : null,
        },
        qrcode_limit: qrcodeLimitInfo,
        storage: storageInfo,
        full_subscription: subscriptionInfo.subscription,
      };

      const userWithSubscription = {
        ...(updatedUser as any).toObject(),
        ...((updatedUser as any)?.role !== 'ADMIN' && {
          subscription: subscriptionInfo.subscription,
        }),
      };

      console.log('=== EditProfileService SUCCESS ===');
      return {
        success: true,
        message: 'Profile updated successfully',
        data: {
          ...userWithSubscription,
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription: subscriptionInfo.subscription,
          }),
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription_tier: subscriptionInfo.tier,
          }),
          ...((userWithSubscription as any)?.role !== 'ADMIN' && {
            subscription_info: subscriptionDetails,
          }),
        },
      };
    } catch (error: any) {
      console.error('=== EditProfileService ERROR ===');
      console.error('Error message:', error.message);
      console.error('Error stack:', error.stack);
      console.error('Error details:', error);
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not update your profile. Please try again.'
        ),
        data: null,
      };
    }
  }

  // =========== LOGOUT SERVICE ==============
  public static async LogoutService(logoutData: {
    userId: string;
    ip_address?: string;
    user_agent?: string;
  }) {
    try {
      // Find user to get email for logging
      const user = await UserModel.findById(logoutData.userId);

      if (user) {
        user.isLogin = false;
        await user.save();
      }
      await user?.save();

      if (!user) {
        return {
          success: false,
          message: 'User not found',
          data: null,
        };
      }

      // Log successful logout
      await AuditLogger.logUserAction({
        action: 'USER_LOGOUT',
        user_id: user._id,
        email: user.email!,
        description: `User logged out: ${user.email}`,
        status: 'SUCCESS',
        severity: 'LOW',
        metadata: {
          ip_address: logoutData.ip_address,
          user_agent: logoutData.user_agent,
          logout_time: new Date(),
        },
      });

      return {
        success: true,
        message: 'Logout successful',
        data: null,
      };
    } catch (error: any) {
      return {
        success: false,
        message: humanizeClientError(
          error,
          'We could not sign you out. Please try again.'
        ),
        data: null,
      };
    }
  }
}
