// ═══════════════════════════════════════════════════
//  app/lib/hooks/useUsers.ts
// ═══════════════════════════════════════════════════

import { useState, useEffect, useCallback } from "react";
import toast from "react-hot-toast";
import { getUsers, getRoles, approveUser, rejectUser, deleteUser, verifyUserEmail } from "./../../api/user.api";
import { mapUsers } from "../mappers/user.mapper";
import { UserMapped, RoleRaw } from "../types/user.types";

interface UseUsersReturn {
  users: UserMapped[];
  roles: RoleRaw[];
  loading: boolean;
  error: string | null;
  pendingCount: number;
  refresh: () => void;
  handleApprove: (id: number) => Promise<void>;
  handleReject: (id: number) => Promise<void>;
  handleDelete: (id: number) => Promise<void>;
   handleVerify: (id: number) => Promise<void>; // ✅ add this
}

export function useUsers(refreshFlag?: boolean): UseUsersReturn {
  const [users, setUsers] = useState<UserMapped[]>([]);
  const [roles, setRoles] = useState<RoleRaw[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  const fetchAll = useCallback(async () => {
    setLoading(true);
    setError(null);
    try {
      const [usersRaw, rolesRaw] = await Promise.all([
        getUsers(),
        getRoles(),
      ]);
      setUsers(mapUsers(usersRaw));
      setRoles(Array.isArray(rolesRaw) ? rolesRaw : []);
    } catch (err: any) {
      setError(err.message || "Failed to load data");
      toast.error(err.message || "Failed to load users");
    } finally {
      setLoading(false);
    }
  }, []);

  // Re-fetch when refreshFlag changes
  useEffect(() => {
    fetchAll();
  }, [refreshFlag, fetchAll]);

  const handleApprove = useCallback(async (id: number) => {
    try {
      await approveUser(id);
      toast.success("User approved! Approval email sent.");
      fetchAll();
    } catch (err: any) {
      toast.error(err.message || "Failed to approve user");
    }
  }, [fetchAll]);

  const handleReject = useCallback(async (id: number) => {
    if (!confirm("Reject this user account?")) return;
    try {
      await rejectUser(id);
      toast.success("User rejected.");
      fetchAll();
    } catch (err: any) {
      toast.error(err.message || "Failed to reject user");
    }
  }, [fetchAll]);

  const handleDelete = useCallback(async (id: number) => {
    if (!confirm("Are you sure you want to permanently delete this user?")) return;
    try {
      await deleteUser(id);
      toast.success("User deleted successfully.");
      fetchAll();
    } catch (err: any) {
      toast.error(err.message || "Failed to delete user");
    }
  }, [fetchAll]);

  // ✅ ADD HERE — after handleDelete
  const handleVerify = useCallback(async (id: number) => {
    if (!confirm("Manually verify this user's email?")) return;
    try {
      await verifyUserEmail(id);
      toast.success("User email verified! They can now be approved.");
      fetchAll();
    } catch (err: any) {
      toast.error(err.message || "Failed to verify user");
    }
  }, [fetchAll]);

  const pendingCount = users.filter(
    (u) => u.isEmailVerified && !u.isApprovedByAdmin && u.status !== "rejected"
  ).length;

  return {
    users,
    roles,
    loading,
    error,
    pendingCount,
    refresh: fetchAll,
    handleApprove,
    handleReject,
    handleDelete,
    handleVerify,
  };
}