import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
import UserModel from '../models/User';
import { UniResponse } from '../lib/UniResponse';
import { humanizeClientError } from '../utils/humanReadableError';

interface AuthRequest extends Request {
  user?: any;
}

// ========== AUTHENTICATION TOKEN ================
export const authenticateToken = async (
  req: AuthRequest,
  res: Response,
  next: NextFunction
) => {
  try {
    const authHeader = req.headers.authorization;
    const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

    if (!token) {
      const response = UniResponse.Error('Access token is required', null, 401);
      return res.status(response.code).json(response);
    }

    // Verify token
    const jwtSecret = process.env.JWT_SECRET;
    if (!jwtSecret) {
      const response = UniResponse.Error('JWT secret is not configured', null, 500);
      return res.status(response.code).json(response);
    }

    const decoded = jwt.verify(token, jwtSecret) as any;

    // Check if user still exists
    const user = await UserModel.findById(decoded.userId).select('-password');
    if (!user) {
      const response = UniResponse.Error('User not found', null, 401);
      return res.status(response.code).json(response);
    }

    // Add user info to request
    req.user = {
      userId: decoded.userId,
      email: decoded.email,
      role: decoded.role,
    };

    next();
  } catch (error: any) {
    let response;
    if (error.name === 'TokenExpiredError') {
      response = UniResponse.Error('Token has expired', null, 401);
    } else if (error.name === 'JsonWebTokenError') {
      response = UniResponse.Error('Invalid token', null, 401);
    } else {
      response = UniResponse.Error(
        'Token verification failed',
        humanizeClientError(
          error,
          'We could not verify your session. Please sign in again.'
        ),
        500
      );
    }
    return res.status(response.code).json(response);
  }
};

/** Sets req.user when Authorization Bearer is valid; otherwise continues without error. */
export const optionalAuthenticateToken = async (
  req: AuthRequest,
  _res: Response,
  next: NextFunction
) => {
  try {
    const authHeader = req.headers.authorization;
    const token = authHeader && authHeader.split(' ')[1];
    if (!token) return next();

    const jwtSecret = process.env.JWT_SECRET;
    if (!jwtSecret) return next();

    const decoded = jwt.verify(token, jwtSecret) as any;
    const user = await UserModel.findById(decoded.userId).select('-password');
    if (!user) return next();

    req.user = {
      userId: decoded.userId,
      email: decoded.email,
      role: decoded.role,
    };
    next();
  } catch {
    next();
  }
};

// =========== ADMIN MIDDLEWARE ===================
export const AdminMiddleware = async (
  req: AuthRequest,
  res: Response,
  next: NextFunction
) => {
  try {
    const authHeader = req.headers.authorization;
    const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

    if (!token) {
      const response = UniResponse.Error('Access token is required', null, 401);
      return res.status(response.code).json(response);
    }

    // Verify token
    const jwtSecret = process.env.JWT_SECRET;
    if (!jwtSecret) {
      const response = UniResponse.Error('JWT secret is not configured', null, 500);
      return res.status(response.code).json(response);
    }

    const decoded = jwt.verify(token, jwtSecret) as any;

    // Check if user still exists
    const user = await UserModel.findById(decoded.userId).select('-password');
    if (!user) {
      const response = UniResponse.Error('User not found', null, 401);
      return res.status(response.code).json(response);
    }

    // Check if user has admin role
    if (user.role !== 'ADMIN') {
      const response = UniResponse.Error(
        'Access denied. Admin privileges required',
        null,
        403
      );
      return res.status(response.code).json(response);
    }

    // Add user info to request
    req.user = {
      userId: decoded.userId,
      email: decoded.email,
      role: decoded.role,
    };

    next();
  } catch (error: any) {
    let response;
    if (error.name === 'TokenExpiredError') {
      response = UniResponse.Error('Token has expired', null, 401);
    } else if (error.name === 'JsonWebTokenError') {
      response = UniResponse.Error('Invalid token', null, 401);
    } else {
      response = UniResponse.Error(
        'Token verification failed',
        humanizeClientError(
          error,
          'We could not verify your session. Please sign in again.'
        ),
        500
      );
    }
    return res.status(response.code).json(response);
  }
};

// Password reset token authentication middleware
export const authenticateResetToken = async (
  req: AuthRequest,
  res: Response,
  next: NextFunction
) => {
  try {
    const authHeader = req.headers.authorization;
    const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

    if (!token) {
      const response = UniResponse.Error('Reset token is required', null, 401);
      return res.status(response.code).json(response);
    }

    // Verify token
    const jwtSecret = process.env.JWT_SECRET;
    if (!jwtSecret) {
      const response = UniResponse.Error('JWT secret is not configured', null, 500);
      return res.status(response.code).json(response);
    }

    const decoded = jwt.verify(token, jwtSecret) as any;

    // Check if this is a password reset token
    if (decoded.type !== 'password-reset') {
      const response = UniResponse.Error('Invalid reset token', null, 401);
      return res.status(response.code).json(response);
    }

    // Check if user still exists
    const user = await UserModel.findById(decoded.userId).select('-password');
    if (!user) {
      const response = UniResponse.Error('User not found', null, 401);
      return res.status(response.code).json(response);
    }

    // Add user info to request with reset flag
    req.user = {
      userId: decoded.userId,
      email: decoded.email,
      isPasswordReset: true,
    };

    next();
  } catch (error: any) {
    let response;
    if (error.name === 'TokenExpiredError') {
      response = UniResponse.Error('Reset token has expired', null, 401);
    } else if (error.name === 'JsonWebTokenError') {
      response = UniResponse.Error('Invalid reset token', null, 401);
    } else {
      response = UniResponse.Error(
        'Reset token verification failed',
        humanizeClientError(
          error,
          'We could not verify your reset link. Please request a new one.'
        ),
        500
      );
    }
    return res.status(response.code).json(response);
  }
};

// Role-based authorization middleware
export const authorizeRoles = (...roles: string[]) => {
  return (req: AuthRequest, res: Response, next: NextFunction) => {
    if (!req.user) {
      const response = UniResponse.Error('Authentication required', null, 401);
      return res.status(response.code).json(response);
    }

    if (!roles.includes(req.user.role)) {
      const response = UniResponse.Error(
        'Access denied. Insufficient permissions',
        null,
        403
      );
      return res.status(response.code).json(response);
    }

    next();
  };
};
