import 'dotenv/config';
import { Request, Response } from 'express';
import { UniResponse } from '../../lib/UniResponse';
import { AuthValidation } from '../../validations/authValidation';
import { AuthService } from './AuthServices';
import UserModel from '../../models/User';
import { asyncHandler } from '../../utils/asyncHandler';
import { humanizeClientError } from '../../utils/humanReadableError';
import { MediaUtils } from '../../utils/MediaUtils';
import { deleteOldProfilePicture } from './AuthRepositry';
import { resolveGoogleOAuthCallbackUrl } from '../../utils/googleOAuthCallbackUrl';

interface AuthenticatedRequest extends Request {
  user?: {
    userId: string;
    email: string;
    role: string;
  };
}

export class AuthController {
  // ========== REGISTER CONTROLLER ================
  public static RegisterController = asyncHandler(
    async (req: Request, res: Response) => {
      const registerData = {
        ...req.body,
      };

      console.log('registerData :>> ', registerData);

      const result = await AuthService.RegisterService(registerData);

      if (result?.success) {
        const response = UniResponse.Success(result.message, result.data, 201);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result?.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== LOGIN CONTROLLER ================
  public static LoginController = asyncHandler(async (req: Request, res: Response) => {
    // Extract IP address and user agent for audit logging
    const ip_address =
      req.ip ||
      req.connection.remoteAddress ||
      (req.headers['x-forwarded-for'] as string);
    const user_agent = req.headers['user-agent'];

    // Add IP and user agent to request body for logging
    const loginData = {
      ...req.body,
      ip_address,
      user_agent,
    };

    const result = await AuthService.LoginService(loginData);

    if (result.success) {
      const response = UniResponse.Success(result.message, result.data, 200);
      return res.status(response.code).json(response);
    } else {
      const response = UniResponse.Error(result.message, null, 401);
      return res.status(response.code).json(response);
    }
  });

  // ========== LOGOUT CONTROLLER ================
  public static LogoutController = asyncHandler(
    async (req: AuthenticatedRequest, res: Response) => {
      // Extract IP address and user agent for audit logging
      const ip_address =
        req.ip ||
        req.connection.remoteAddress ||
        (req.headers['x-forwarded-for'] as string);
      const user_agent = req.headers['user-agent'];

      // Get userId from either session or JWT token (for backward compatibility)
      const userId = req.user?.userId!;

      const logoutData = {
        userId: userId!,
        ip_address,
        user_agent,
      };

      const result = await AuthService.LogoutService(logoutData);

      console.log('logoutData :>> ', logoutData);
      console.log('result :>> ', result);

      if (result.success) {
        console.log('result.message :>> ', result.message);
        console.log('result.data :>> ', result.data);

        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        console.log('result.message :>> ', result.message);
        console.log('result.data :>> ', result.data);

        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== GET USER PROFILE CONTROLLER ================
  public static GetUserProfileController = asyncHandler(
    async (req: Request, res: Response) => {
      const userId = (req as any).user.userId; // From auth middleware
      const result = await AuthService.GetUserProfileService(userId);

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 404);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== GET USER PROFILE BY ID CONTROLLER ================
  public static GetUserProfileByIdController = asyncHandler(
    async (req: Request, res: Response) => {
      const { id } = req.params;
      const result = await AuthService.GetUserProfileByIdService(id as any);

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 404);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== GET PROFILE RESOURCES CONTROLLER ================
  public static GetProfileResourcesController = asyncHandler(
    async (req: Request, res: Response) => {
      const userId = (req as any).user.userId; // From auth middleware

      try {
        // Return profile editing resources/options
        const profileResources = {
          availableFields: {
            personalInfo: ['firstName', 'lastName', 'email', 'phone', 'dateOfBirth'],
            address: ['street', 'city', 'state', 'zipCode', 'country'],
            preferences: [
              'notificationForQrdCode',
              'smsAlert',
              'emergencyScanNotification',
            ],
            media: ['profilePicture'],
          },
          validationRules: {
            email: 'Must be a valid email format',
            phone: 'Must be a valid phone number',
            profilePicture: 'Supported formats: JPG, PNG, GIF. Max size: 5MB',
          },
          endpoints: {
            updateProfile: '/api/auth/profile',
            changePassword: '/api/auth/change-password',
            updateNotifications: '/api/auth/notification-preference',
          },
        };

        const response = UniResponse.Success(
          'Profile resources retrieved successfully',
          profileResources,
          200
        );
        return res.status(response.code).json(response);
      } catch (error: any) {
        const response = UniResponse.Error(
          'Failed to retrieve profile resources',
          humanizeClientError(
            error,
            'We could not load profile resources. Please try again.'
          ),
          500
        );
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== UPDATE USER PROFILE CONTROLLER ================
  public static UpdateUserProfileController = asyncHandler(
    async (req: Request, res: Response) => {
      const userId = (req as any).user.userId; // From auth middleware

      try {
        // Get current user to check for existing profile picture
        const currentUser = await UserModel.findOne({
          _id: userId,
          // is_delete: false,
        });

        if (!currentUser) {
          const response = UniResponse.Error('User not found', null, 404);
          return res.status(response.code).json(response);
        }

        // If a new profile picture is being uploaded and user has an existing profile picture
        await deleteOldProfilePicture(currentUser, req);

        // Handle media upload if file is provided - use MediaUtils.insertMedia for proper path handling
        let profilePicturePath: string | undefined;
        let mediaId: string | undefined;
        let hostUrl: string | undefined;

        if (req.file) {
          // Use dynamic insertMedia component for proper path conversion
          // Use req.get('host') to include port number when needed
          const baseUrl =
            process.env.BASE_URL || `${req.protocol}://${req.get('host')}`;

          let mediaResult;
          try {
            mediaResult = await MediaUtils.insertMedia({
              file: req.file,
              uploadDir: 'uploads/profile-pictures',
              baseUrl: baseUrl,
            });
          } catch (error: any) {
            console.error('Error inserting media:', error);
            const response = UniResponse.Error(
              humanizeClientError(
                error,
                'We could not upload your profile picture. Please try again.'
              ),
              null,
              500
            );
            return res.status(response.code).json(response);
          }

          if (!mediaResult) {
            const response = UniResponse.Error(
              'Failed to process profile picture',
              null,
              500
            );
            return res.status(response.code).json(response);
          }

          profilePicturePath = mediaResult.filePath;
          mediaId = mediaResult.mediaId;
          hostUrl = mediaResult.mediaRecord?.hostUrl;
        }

        const result = await AuthService.UpdateUserProfileService(
          userId,
          req.body,
          profilePicturePath,
          req.file,
          mediaId,
          hostUrl
        );

        if (result.success) {
          const response = UniResponse.Success(result.message, result.data, 200);
          return res.status(response.code).json(response);
        } else {
          const response = UniResponse.Error(result.message, null, 400);
          return res.status(response.code).json(response);
        }
      } catch (error: any) {
        console.error('Error in UpdateUserProfileController:', error);
        const response = UniResponse.Error(
          'Internal server error during profile update',
          humanizeClientError(
            error,
            'We could not update your profile. Please try again.'
          ),
          500
        );
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== CHANGE PASSWORD CONTROLLER ================
  public static ChangePasswordController = asyncHandler(
    async (req: Request, res: Response) => {
      const userId = (req as any).user.userId;
      const isCurrent = !!req.body.currentPassword;
      const isPasswordReset = !isCurrent;

      const result = await AuthService.ChangePasswordService(
        userId,
        req.body,
        isPasswordReset
      );

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== UPDATE PROFILE PICTURE CONTROLLER ================
  public static UpdateProfilePictureController = asyncHandler(
    async (req: Request, res: Response) => {
      const userId = (req as any).user.userId; // From auth middleware

      if (!req.file) {
        const response = UniResponse.Error('No file uploaded', null, 400);
        return res.status(response.code).json(response);
      }

      const profilePicturePath =
        `uploads/profile-pictures/${req.file.filename}`.replace(/\/+/g, '/');
      const result = await AuthService.UpdateProfilePictureService(
        userId,
        profilePicturePath,
        req.file
      );

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== VERIFY OTP CONTROLLER ================
  public static VerifyOtpController = asyncHandler(
    async (req: Request, res: Response) => {
      if (!req.body) {
        const response = UniResponse.Error('Request body is missing', null, 400);
        return res.status(response.code).json(response);
      }

      if (!req.body.email) {
        const response = UniResponse.Error(
          'Email is required in request body',
          null,
          400
        );
        return res.status(response.code).json(response);
      }

      if (!req.body.otp) {
        const response = UniResponse.Error(
          'OTP is required in request body',
          null,
          400
        );
        return res.status(response.code).json(response);
      }

      const result = await AuthService.VerifyOtpService(req.body);

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== RESEND OTP CONTROLLER ================
  public static ResendOtpController = asyncHandler(
    async (req: Request, res: Response) => {
      const result = await AuthService.ResendOtpService(req.body);

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== CHECK PASSWORD STRENGTH CONTROLLER ================
  public static async CheckPasswordStrengthController(req: Request, res: Response) {
    try {
      const { password } = req.body;

      if (!password) {
        const response = UniResponse.Error('Password is required', null, 400);
        return res.status(response.code).json(response);
      }

      const strengthCheck = AuthValidation.checkPasswordStrength(password);
      const response = UniResponse.Success(
        'Password strength checked',
        strengthCheck,
        200
      );
      return res.status(response.code).json(response);
    } catch (error: any) {
      const response = UniResponse.Error(
        'Internal server error',
        humanizeClientError(error, 'Something went wrong. Please try again.'),
        500
      );
      return res.status(response.code).json(response);
    }
  }

  // ========== FORGOT PASSWORD CONTROLLER ================
  public static ForgotPasswordController = asyncHandler(
    async (req: Request, res: Response) => {
      const result = await AuthService.ForgotPasswordService(req.body);

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ================ NOTIFICATION PREFERENCE ================
  public static NotificationPreference = asyncHandler(
    async (req: AuthenticatedRequest, res: Response) => {
      const userId = req?.user?.userId;

      if (!userId) {
        const response = UniResponse.Error('User ID not found', null, 401);
        return res.status(response.code).json(response);
      }

      // Extract notification preferences from request body
      const { notificationForQrdCode, smsAlert, emergencyScanNotification } = req.body;

      // Validate that at least one field is provided
      if (
        notificationForQrdCode === undefined &&
        smsAlert === undefined &&
        emergencyScanNotification === undefined
      ) {
        const response = UniResponse.Error(
          'At least one notification preference must be provided',
          null,
          400
        );
        return res.status(response.code).json(response);
      }

      // Validate boolean values
      const updateData: any = {};

      if (notificationForQrdCode !== undefined) {
        if (typeof notificationForQrdCode !== 'boolean') {
          const response = UniResponse.Error(
            'notificationForQrdCode must be a boolean value',
            null,
            400
          );
          return res.status(response.code).json(response);
        }
        updateData.notificationForQrdCode = notificationForQrdCode;
      }

      if (smsAlert !== undefined) {
        if (typeof smsAlert !== 'boolean') {
          const response = UniResponse.Error(
            'smsAlert must be a boolean value',
            null,
            400
          );
          return res.status(response.code).json(response);
        }
        updateData.smsAlert = smsAlert;
      }

      if (emergencyScanNotification !== undefined) {
        if (typeof emergencyScanNotification !== 'boolean') {
          const response = UniResponse.Error(
            'emergencyScanNotification must be a boolean value',
            null,
            400
          );
          return res.status(response.code).json(response);
        }
        updateData.emergencyScanNotification = emergencyScanNotification;
      }

      // Update user notification preferences
      const updatedUser = await UserModel.findByIdAndUpdate(
        userId,
        { $set: updateData },
        {
          new: true,
          select: 'notificationForQrdCode smsAlert emergencyScanNotification',
        }
      );

      if (!updatedUser) {
        const response = UniResponse.Error('User not found', null, 404);
        return res.status(response.code).json(response);
      }

      const response = UniResponse.Success(
        'Notification preferences updated successfully',
        {
          notificationForQrdCode: updatedUser.notificationForQrdCode,
          smsAlert: updatedUser.smsAlert,
          emergencyScanNotification: updatedUser.emergencyScanNotification,
        },
        200
      );
      return res.status(response.code).json(response);
    }
  );

  // ========== CREATE PROFILE CONTROLLER ================
  public static CreateProfileController = asyncHandler(
    async (req: AuthenticatedRequest, res: Response) => {
      const userId = req?.user?.userId;

      if (!userId) {
        const response = UniResponse.Error('User ID not found', null, 401);
        return res.status(response.code).json(response);
      }

      // Profile picture is optional - only process media when file was uploaded
      let profilePicturePath: string | undefined;
      let hostUrl: string | undefined;
      let mediaId: string | undefined;

      if (req.file) {
        const baseUrl = process.env.BASE_URL || `${req.protocol}://${req.get('host')}`;
        let mediaResult;
        try {
          mediaResult = await MediaUtils.insertMedia({
            file: req.file,
            uploadDir: 'uploads/profile-pictures',
            baseUrl: baseUrl,
          });
        } catch (error: any) {
          console.error('Error inserting media:', error);
          const response = UniResponse.Error(
            humanizeClientError(
              error,
              'We could not upload your profile picture. Please try again.'
            ),
            null,
            500
          );
          return res.status(response.code).json(response);
        }

        if (!mediaResult) {
          const response = UniResponse.Error(
            'Failed to process profile picture',
            null,
            500
          );
          return res.status(response.code).json(response);
        }

        profilePicturePath = mediaResult?.filePath;
        hostUrl = mediaResult?.mediaRecord?.hostUrl;
        mediaId = mediaResult?.mediaId;
      }

      // Extract user agent for device type detection
      const user_agent = req.headers['user-agent'];

      const profileData = {
        ...req.body,
        user_agent,
        ...(mediaId !== undefined && { media_id: mediaId }),
      };

      const result = await AuthService.CreateProfileService(
        userId,
        profileData,
        profilePicturePath,
        req.file,
        hostUrl
      );

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 201);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ===== EDIT PROFILE ==============
  // Profile picture is optional - supports JSON-only updates and multipart with/without file
  public static EditProfileController = asyncHandler(
    async (req: AuthenticatedRequest, res: Response) => {
      const userId = req?.user?.userId;

      if (!userId) {
        const response = UniResponse.Error('User ID not found', null, 401);
        return res.status(response.code).json(response);
      }

      // Get profile picture path only when file was uploaded (optional)
      const profilePicturePath = req.file
        ? `uploads/profile-pictures/${req.file.filename}`.replace(/\/+/g, '/')
        : undefined;

      const result = await AuthService.EditProfileService(
        userId,
        req.body,
        profilePicturePath,
        req.file
      );

      if (result.success) {
        const response = UniResponse.Success(result.message, result.data, 200);
        return res.status(response.code).json(response);
      } else {
        const response = UniResponse.Error(result.message, null, 400);
        return res.status(response.code).json(response);
      }
    }
  );

  // ========== GET GOOGLE AUTH URL CONTROLLER ================
  public static GetGoogleAuthUrl = asyncHandler(async (req: Request, res: Response) => {
    const clientID = process.env.GOOGLE_CLIENT_ID;
    // Must match Passport's `callbackURL` exactly (passport resolves without `req` at init).
    const callbackURL = resolveGoogleOAuthCallbackUrl();
    const scope = encodeURIComponent('profile email');

    if (!clientID) {
      const response = UniResponse.Error(
        'Google OAuth is not configured on the server',
        null,
        500
      );
      return res.status(response.code).json(response);
    }

    const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?response_type=code&redirect_uri=${encodeURIComponent(callbackURL)}&scope=${scope}&client_id=${clientID}&access_type=offline&prompt=consent`;

    const response = UniResponse.Success(
      'Google Auth URL generated',
      { url: authUrl, redirectUri: callbackURL },
      200
    );
    return res.status(response.code).json(response);
  });

  // ========== GOOGLE AUTH CALLBACK CONTROLLER ================
  public static GoogleAuthCallback = asyncHandler(
    async (req: Request, res: Response) => {
      const user = req.user;
      if (!user) {
        const response = UniResponse.Error('Google authentication failed', null, 401);
        return res.status(response.code).json(response);
      }

      const ip_address =
        req.ip ||
        req.connection.remoteAddress ||
        (req.headers['x-forwarded-for'] as string);
      const user_agent = req.headers['user-agent'];

      const result = await AuthService.GoogleLoginService(user, {
        ip_address,
        user_agent,
      });

      if (result.success && result.data) {
        // Redirect to frontend with token and user data
        const frontendUrl = process.env.FRONTEND_URL || 'http://localhost:8080';
        const token = result.data.token;
        const user = encodeURIComponent(JSON.stringify(result.data.user));

        return res.redirect(`${frontendUrl}/auth-success?token=${token}&user=${user}`);
      } else {
        const frontendUrl = process.env.FRONTEND_URL || 'http://localhost:8080';
        const errorMessage = result.message || 'Google authentication failed';
        return res.redirect(
          `${frontendUrl}/login?error=${encodeURIComponent(errorMessage)}`
        );
      }
    }
  );
}
