const { 
  createUserDb,
  getUserByIdDb,
  getAllUsersDb,
  getUserByUsernameDb,
  updateUserDb,
  deleteUserDb,
  changeUserPasswordDb
} = require('../db/user.db');
const { hashPassword } = require('../helpers/hashPassword');
const { ErrorHandler } = require('../helpers/error');

const statusName = [
  { status: true, status_name: "Aktif" },
  { status: false, status_name: "NonAktif" }
];

class UserService {

  // Get all status users
  getAllStatusUsers = async () => {
    try {
      return statusName;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Get all users
  getAllUsers = async () => {
    try {
      const results = await getAllUsersDb();

      results.forEach(user => {
        user.is_active = user.is_active == 1;
        user.is_active_name = statusName.find(s => s.status === user.is_active)?.status_name;
        delete user.user_password; // remove password
      });

      return results;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Get user by ID
  getUserById = async (id) => {
    try {
      const user = await getUserByIdDb(id);
      if (!user) throw new ErrorHandler(404, "User not found");

      user.is_active = user.is_active == 1;
      user.is_active_name = statusName.find(s => s.status === user.is_active)?.status_name;
      delete user.user_password;
      return user;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Create users
  createUser = async ({ fullname, name, email, phone, password, role_id = null, is_sa = 0, is_active = 1, approved_by }) => {
    try {
      const existingUser = await getUserByUsernameDb(name);
      if (existingUser) throw new ErrorHandler(400, "Username already taken");

      const hashedPassword = await hashPassword(password);

      const userId = await createUserDb({
        user_fullname: fullname,
        user_name: name,
        user_email: email,
        user_phone: phone,
        user_password: hashedPassword,
        role_id,
        is_sa,
        is_active,
        is_approve: 1,
        approved_by,
        approved_at: new Date()
      });

      return {
        user_id: userId,
        user_fullname: fullname,
        user_name: name,
        user_email: email,
        user_phone: phone,
        role_id,
        is_sa,
        is_active,
        is_approve: 1,
        approved_by
      };
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Update user
  updateUser = async ({ user_id, fullname, name, email, phone, role_id, is_sa, is_active, is_approve }) => {
    try {
      const user = await getUserByIdDb(user_id);
      if (!user) throw new ErrorHandler(404, "User not found");

      // Cek username
      if (name && user.user_name.toLowerCase() !== name.toLowerCase()) {
        const userByName = await getUserByUsernameDb(name);
        if (userByName) throw new ErrorHandler(400, "Username already taken");
      }

      const updateData = {
        ...(fullname && { user_fullname: fullname }),
        ...(name && { user_name: name }),
        ...(email && { user_email: email }),
        ...(phone && { user_phone: phone }),
        ...(role_id !== undefined && { role_id }),
        ...(is_sa !== undefined && { is_sa }),
        ...(is_active !== undefined && { is_active }),
        ...(is_approve !== undefined && { is_approve })
      };

      await updateUserDb(user_id, updateData);

      const updatedUser = await getUserByIdDb(user_id);
      delete updatedUser.user_password;
      updatedUser.is_active = updatedUser.is_active == 1;
      updatedUser.is_active_name = statusName.find(s => s.status === updatedUser.is_active)?.status_name;

      return updatedUser;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Approve user
  approveUser = async (userId, approverId) => {
    try {
      const updateData = {
        is_approve: 1,
        approved_by: approverId,
        approved_at: new Date()
      };
      await updateUserDb(userId, updateData);

      const updatedUser = await getUserByIdDb(userId);
      delete updatedUser.user_password;
      return updatedUser;
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Delete user (soft delete)
  deleteUser = async (userId, deletedBy) => {
    try {
      await deleteUserDb(userId, deletedBy);
      return { message: "User deleted successfully" };
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };

  // Change password
  changeUserPassword = async (userId, newPassword) => {
    try {
      const hashedPassword = await hashPassword(newPassword);
      await changeUserPasswordDb(userId, hashedPassword);
      return { message: "Password updated successfully" };
    } catch (error) {
      throw new ErrorHandler(error.statusCode || 500, error.message);
    }
  };
}

module.exports = new UserService();