<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Http\Requests\Admin\CreateUserRequest;
use App\Http\Requests\Learner\UpdateLearnerProfile;
use App\Http\Requests\Manager\AddSubManagerRequest;
use App\Http\Requests\Manager\EditSubManagerRequest;
use App\Http\Requests\UpdateUserRequest;
use App\Http\Resources\Admin\UserResource;
use App\Http\Resources\LessonResource;
use App\Mail\UserCredentialsMail;
use App\Models\Quiz;
use App\Models\QuizScore;
use App\Models\Section;
use App\Traits\Response\ResponseTrait;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Storage;
use App\Models\CompletedCourse;
use App\Models\Enrollment;
use Illuminate\Support\Facades\Hash;

class UserController extends Controller
{
    use ResponseTrait;

    public function index(Request $request): \Illuminate\Http\JsonResponse
    {
        $auth = auth()->user();

        $query = User::query()
            ->with('roles', 'teacherProfile', 'managerProfile', 'learnerProfile', 'directorProfile', 'submanagerProfile', 'managerGeneralProfile');

        // ✅ Role-based visibility
        if ($auth->hasRole('admin') || $auth->hasRole('manager')) {

            $query->whereDoesntHave('roles', function ($q) {
                $q->where('name', 'admin');
            });
        } elseif ($auth->hasRole('director')) {

            // $query->whereDoesntHave('roles', function ($q) {
            //     $q->whereIn('name', ['admin', 'manager', 'director']);
            // });
            $query->where('parent_id', $auth->id);
        } elseif ($auth->hasRole('manager_general')) {

            // $query->whereDoesntHave('roles', function ($q) {
            //     $q->whereIn('name', ['admin', 'manager', 'director', 'manager_general']);
            // });
            $query->where('parent_id', $auth->id);
        } elseif ($auth->hasRole('sub_manager')) {

            $query->where('parent_id', $auth->id);
        }

        // ✅ Search (query level)
        if ($request->filled('search')) {
            $search = $request->search;
            $query->where(function ($q) use ($search) {
                $q->where('first_name', 'like', "%{$search}%")
                    ->orWhere('email', 'like', "%{$search}%");
            });
        }

        // ✅ Sorting (query level)
        if ($request->filled('sort.key') && $request->filled('sort.value')) {

            $allowedSortKeys = ['id', 'first_name', 'email', 'role', 'is_active'];
            $key = $request->input('sort.key');
            $dir = strtolower($request->input('sort.value')) === 'desc' ? 'desc' : 'asc';

            if (in_array($key, $allowedSortKeys, true)) {

                // 🔹 Sort by role name (Spatie)
                if ($key === 'role') {
                    $query
                        ->leftJoin('model_has_roles as mhr', function ($join) {
                            $join->on('users.id', '=', 'mhr.model_id')
                                ->where('mhr.model_type', User::class);
                        })
                        ->leftJoin('roles', 'roles.id', '=', 'mhr.role_id')
                        ->select('users.*')
                        ->orderBy('roles.name', $dir);
                }
                // 🔹 Normal user table columns
                else {
                    if ($key === 'is_active') {
                        $dir = $dir == 'asc' ? 'desc' : 'asc';
                    }
                    $query->orderBy($key, $dir);
                }
            }
        } else {
            $query->latest('users.id');
        }


        // ✅ Paginate LAST
        $users = $query->paginate(20);

        return $this->jsonResponseSuccess([
            'Users' => UserResource::collection($users)->response()->getData(true)
        ]);
    }


    public function updateUserProfile(UpdateUserRequest $request, $id)
    {
        $validated = $request->validated();

        $managerialRole = ['director', 'sub_manager', 'manager_general'];

        if (in_array($validated['role'], $managerialRole, true)) {
            $request->validate(
                [
                    'user'   => 'required|array|min:1',
                    'user.*' => 'exists:users,id',
                ],
                [
                    'user.required' => 'Veuillez sélectionner au moins un utilisateur à affecter.',
                    'user.array'    => 'Le format des utilisateurs sélectionnés est invalide.',
                    'user.min'      => 'Veuillez sélectionner au moins un utilisateur.',
                    'user.*.exists' => 'Un ou plusieurs utilisateurs sélectionnés sont invalides.',
                ]
            );
        }
        $user = User::with('managerProfile', 'teacherProfile', 'learnerProfile')->find($id);

        if (empty($user)) {
            return $this->jsonResponseFail(trans('common.no_record_found'), 401);
        }


        if (!empty($validated['role']) && $validated['role'] !== $user->role) {

            $newRole = $validated['role'];
            $oldRole = $user->getRoleNames()[0] ?? null;

            // Optional: validate allowed roles
            $allowedRoles = ['admin', 'manager_general', 'sub_manager', 'learner', 'teacher', 'manager', 'director'];
            if (!in_array($newRole, $allowedRoles, true)) {
                return $this->jsonResponseFail('Invalid role provided.', 422);
            }
            // Update role in users table
            $user->removeRole($user->getRoleNames());
            $user->assignRole($newRole);
            if (in_array($validated['role'], $managerialRole, true)) {
                User::where('parent_id', $user->id)
                    ->update(['parent_id' => null]);

                User::whereIn('id', $validated['user'])
                    ->update(['parent_id' => $user->id]);
            }
            // ✅ Ensure correct profile exists based on role
            // Map roles to profile relationships
            $roleProfileMap = [
                'manager' => 'managerProfile',
                'sub_manager'   => 'submanagerProfile',
                'manager_general'       => 'managerGeneralProfile',
                'teacher'       => 'teacherProfile',
                'learner'       => 'learnerProfile',
                'director'      => 'directorProfile',
            ];

            // Create profile if missing
            if ($oldRole !== $newRole) {

                // 1) Delete all profile rows
                $user->managerProfile()->delete();
                $user->teacherProfile()->delete();
                $user->learnerProfile()->delete();
                $user->submanagerProfile()->delete();
                $user->directorProfile()->delete();

                // 2) VERY IMPORTANT: clear relation cache from the current model instance
                $user->unsetRelation('managerProfile');
                $user->unsetRelation('teacherProfile');
                $user->unsetRelation('learnerProfile');
                $user->unsetRelation('submanagerProfile');
                $user->unsetRelation('directorProfile');

                // OR you can do: $user->refresh(); (heavier but simple)
                // $user->refresh();
            }

            // 3) Create the profile for the new role
            if (isset($roleProfileMap[$newRole])) {
                $relation = $roleProfileMap[$newRole];

                // After unsetRelation/refresh, this will be empty correctly
                if (empty($user->$relation)) {
                    $user->$relation()->create([]);
                }
            }


            if (isset($roleProfileMap[$newRole])) {
                $relation = $roleProfileMap[$newRole];

                if (empty($user->$relation)) {
                    $user->$relation()->create([
                        // add default fields if needed
                        // 'avatar' => null,
                    ]);
                }
            }
            unset($validated['role']);
        }
        // Helper to handle image update and remove old one
        $handleAvatarUpdate = function ($profile, &$validated) {
            if (!empty($validated['avatar']) && Str::startsWith($validated['avatar'], 'data:image')) {
                // Delete old avatar if exists
                if (!empty($profile->avatar) && \Storage::disk('public')->exists($profile->avatar)) {
                    \Storage::disk('public')->delete($profile->avatar);
                }

                // Save new avatar
                $avatar = $validated['avatar'];
                $avatarPath = $this->storeBase64Image($avatar, 'avatars');
                $validated['avatar'] = $avatarPath;
            } else {
                unset($validated['avatar']);
            }
        };
        if (!empty($user->managerProfile) || $user->getRoleNames()[0] === 'manager') {
            $handleAvatarUpdate($user->managerProfile, $validated);

            // Separate user fields from profile fields
            if (!empty($validated['password'])) {
                $validated['password'] = Hash::make($validated['password']);
            } else {
                unset($validated['password']);
            }

            $userFields = ['first_name', 'last_name', 'email', 'password'];
            $profileFields = ['bio', 'avatar']; // ✅ ONLY real DB columns

            $userData = array_intersect_key($validated, array_flip($userFields));
            $profileData = array_intersect_key($validated, array_flip($profileFields));

            if (!empty($userData)) {
                $user->update($userData);
            }

            if (!empty($profileData)) {
                $user->managerProfile()->update($profileData);
            }

            return response()->json([
                'status' => true,
                'message' => __('common.profile_updated'),
                'data' => $user->fresh('managerProfile')
            ]);
        } elseif (!empty($user->teacherProfile) || $user->getRoleNames()[0] === 'teacher') {
            $handleAvatarUpdate($user->teacherProfile, $validated);

            if (!empty($validated['password'])) {
                $validated['password'] = Hash::make($validated['password']);
            } else {
                unset($validated['password']);
            }

            $userFields = ['first_name', 'last_name', 'email', 'password'];
            $profileFields = ['bio', 'avatar']; // ✅ ONLY real DB columns

            $userData = array_intersect_key($validated, array_flip($userFields));
            $profileData = array_intersect_key($validated, array_flip($profileFields));

            if (!empty($userData)) {
                $user->update($userData);
            }

            $user->teacherProfile()->update($profileData);

            return response()->json([
                'status' => true,
                'message' =>  __('common.profile_updated'),
                'data' => $user->fresh('teacherProfile')
            ]);
        } elseif (!empty($user->learnerProfile) || $user->getRoleNames()[0] === 'learner') {

            $handleAvatarUpdate($user->learnerProfile, $validated);

            if (!empty($validated['password'])) {
                $validated['password'] = Hash::make($validated['password']);
            } else {
                unset($validated['password']);
            }

            $userFields = ['first_name', 'last_name', 'email', 'password'];
            $profileFields = ['bio', 'avatar']; // ✅ ONLY real DB columns

            $userData = array_intersect_key($validated, array_flip($userFields));
            $profileData = array_intersect_key($validated, array_flip($profileFields));

            if (!empty($userData)) {
                $user->update($userData);
            }

            $user->learnerProfile()->update($profileData);

            return response()->json([
                'status' => true,
                'message' => __('common.profile_updated'),
                'data' => $user->fresh('learnerProfile')
            ]);
        } elseif (!empty($user->directorProfile) || $user->getRoleNames()[0] === 'director') {
            $handleAvatarUpdate($user->directorProfile, $validated);

            if (!empty($validated['password'])) {
                $validated['password'] = Hash::make($validated['password']);
            } else {
                unset($validated['password']);
            }

            $userFields = ['first_name', 'last_name', 'email', 'password'];
            $profileFields = ['bio', 'avatar']; // ✅ ONLY real DB columns

            $userData = array_intersect_key($validated, array_flip($userFields));
            $profileData = array_intersect_key($validated, array_flip($profileFields));

            if (!empty($userData)) {
                $user->update($userData);
            }

            if (!empty($profileData)) {
                $user->directorProfile()->update($profileData);
            }


            return response()->json([
                'status' => true,
                'message' => __('common.profile_updated'),
                'data' => $user->fresh('directorProfile')
            ]);
        } elseif (!empty($user->managerGeneralProfile) || $user->getRoleNames()[0] === 'manager_general') {
            $handleAvatarUpdate($user->managerGeneralProfile, $validated);

            if (!empty($validated['password'])) {
                $validated['password'] = Hash::make($validated['password']);
            } else {
                unset($validated['password']);
            }

            $userFields = ['first_name', 'last_name', 'email', 'password'];
            $profileFields = ['bio', 'avatar']; // ✅ ONLY real DB columns

            $userData = array_intersect_key($validated, array_flip($userFields));
            $profileData = array_intersect_key($validated, array_flip($profileFields));

            if (!empty($userData)) {
                $user->update($userData);
            }

            $user->managerGeneralProfile()->update($profileData);

            return response()->json([
                'status' => true,
                'message' => __('common.profile_updated'),
                'data' => $user->fresh('managerGeneralProfile')
            ]);
        } elseif (!empty($user->submanagerProfile()) || $user->getRoleNames()[0] === 'sub_manager') {
            $handleAvatarUpdate($user->submanagerProfile, $validated);

            if (!empty($validated['password'])) {
                $validated['password'] = Hash::make($validated['password']);
            } else {
                unset($validated['password']);
            }

            $userFields = ['first_name', 'last_name', 'email', 'password'];
            $profileFields = ['bio', 'avatar']; // ✅ ONLY real DB columns

            $userData = array_intersect_key($validated, array_flip($userFields));
            $profileData = array_intersect_key($validated, array_flip($profileFields));

            if (!empty($userData)) {
                $user->update($userData);
            }

            $user->submanagerProfile()->update($profileData);

            return response()->json([
                'status' => true,
                'message' => __('common.profile_updated'),
                'data' => $user->fresh('submanagerProfile')
            ]);
        }
    }

    public function show(Request $request, $id): \Illuminate\Http\JsonResponse
    {
        $user = User::find($id);
        $user->load('learnerProfile', 'managerProfile', 'teacherProfile', 'sub_manager_learners', 'enrollment.course');
        $user->role = $user->getRoleNames()[0];
        if (!$user) {
            return $this->jsonResponseFail(trans('common.no_record_found'), 401);
        }

        return $this->jsonResponseSuccess(['user' => new UserResource($user)]);
    }

    public function learnerDetail(Request $request, $id): \Illuminate\Http\JsonResponse
    {
        $perPage = $request->get('per_page', 10); // items per page
        $page = $request->get('page', 1);         // current page

        // Step 1: Get enrollments for this learner, only with a course
        $enrollments = Enrollment::with(['learner', 'course'])
            ->where('learner_id', $id)
            ->whereHas('course') // only enrollments with a course
            ->get();

        $rows = collect();

        foreach ($enrollments as $enrollment) {
            $learner = $enrollment->learner;
            $course = $enrollment->course;

            // Step 2: Determine status and certificate
            $status = 'En cours';
            $gotCertificate = false;

            if ($course) {
                $completed = CompletedCourse::where('learner_id', $learner->id)
                    ->where('course_id', $course->id)
                    ->first();

                if ($completed) {
                    $gotCertificate = !empty($completed->certificate_path);
                    $status = $gotCertificate ? 'Finalisé' : 'Réalisé';
                }
            }

            // Step 3: Get unique quizzes for this course
            $quizzes = $course ? DB::table('quizzes')
                ->join('sections', 'quizzes.section_id', '=', 'sections.id')
                ->where('sections.course_id', $course->id)
                ->select('quizzes.id', 'quizzes.name', 'quizzes.is_required')
                ->distinct('quizzes.id')
                ->get() : collect();

            // Step 4: Handle cases with no quizzes
            if ($quizzes->isEmpty()) {
                $rows->push([
                    'learner' => $learner,
                    'course' => $course,
                    'quiz_name' => null,
                    'quiz_score' => null,
                    'status' => $status,
                    'got_certificate' => $gotCertificate,
                    'enrollment_date' => $enrollment->created_at ? $enrollment->created_at->format('Y-m-d') : null
                ]);
            } else {
                foreach ($quizzes as $quiz) {
                    $totalQuestions = QuizScore::where('quiz_id', $quiz->id)
                        ->distinct('question_id')
                        ->count('question_id');

                    $correctAnswers = QuizScore::where('quiz_id', $quiz->id)
                        ->where('learner_id', $learner->id)
                        ->where('is_correct', 1)
                        ->count();

                    $scorePercentage = $totalQuestions > 0
                        ? round(($correctAnswers / $totalQuestions) * 100, 2)
                        : 0;

                    $rows->push([
                        'learner' => $learner,
                        'course' => $course,
                        'quiz_name' => $quiz->name,
                        'quiz_score' => $scorePercentage,
                        'status' => $status,
                        'got_certificate' => $gotCertificate,
                        'enrollment_date' => $enrollment->created_at ? $enrollment->created_at->format('Y-m-d') : null
                    ]);
                }
            }
        }

        // Step 5: Manual Pagination
        $total = $rows->count();
        $paginated = $rows->slice(($page - 1) * $perPage, $perPage)->values();

        $pagination = [
            'current_page' => (int)$page,
            'per_page' => (int)$perPage,
            'total' => $total,
            'last_page' => ceil($total / $perPage),
        ];

        return $this->jsonResponseSuccess([
            'learner_detail' => $paginated,
            'pagination' => $pagination
        ]);
    }


    public function store(CreateUserRequest $request)
    {
        $validated = $request->validated();

        // Keep raw password for email before hashing
        $plainPassword = $validated['password'];

        // Conditional validation (managerial roles must include users to assign)
        $managerialRole = ['director', 'sub_manager', 'manager_general'];

        if (in_array($validated['role'], $managerialRole, true)) {
            $request->validate(
                [
                    'user'   => 'required|array|min:1',
                    'user.*' => 'exists:users,id',
                ],
                [
                    'user.required' => 'Veuillez sélectionner au moins un utilisateur à affecter.',
                    'user.array'    => 'Le format des utilisateurs sélectionnés est invalide.',
                    'user.min'      => 'Veuillez sélectionner au moins un utilisateur.',
                    'user.*.exists' => 'Un ou plusieurs utilisateurs sélectionnés sont invalides.',
                ]
            );
        }

        // Handle base64 avatar
        if (!empty($validated['avatar']) && Str::startsWith($validated['avatar'], 'data:image')) {
            $validated['avatar'] = $this->storeBase64Image($validated['avatar'], 'avatars');
        } else {
            unset($validated['avatar']);
        }

        // Extract user fields and hash password
        $userFields = ['first_name', 'last_name', 'email', 'password'];
        $userData = array_intersect_key($validated, array_flip($userFields));

        $userData['password'] = bcrypt($plainPassword);
        $userData['password_changed_at'] = now();

        // Create user
        $user = User::create($userData);

        // Assign role via Spatie
        $user->assignRole($validated['role']);

        // Assign selected users to this new manager (parent_id)
        if (in_array($validated['role'], $managerialRole, true)) {
            User::whereIn('id', $validated['user'])
                ->update(['parent_id' => $user->id]);
        }

        // Extract profile fields (exclude base user fields + role + user assignment list)
        $profileFields = array_diff_key($validated, array_flip([...$userFields, 'role', 'user']));

        // Send credentials email
        Mail::to($validated['email'])->send(
            new UserCredentialsMail($validated['email'], $plainPassword, $validated['role'])
        );

        // Create associated profile based on role
        switch ($validated['role']) {
            case 'manager':
                $user->managerProfile()->create($profileFields);
                $relation = 'managerProfile';
                break;

            case 'teacher':
                $user->teacherProfile()->create($profileFields);
                $relation = 'teacherProfile';
                break;

            case 'learner':
                $user->learnerProfile()->create($profileFields);
                $relation = 'learnerProfile';
                break;

            case 'sub_manager':
                $user->submanagerProfile()->create($profileFields);
                $relation = 'submanagerProfile';
                break;

            case 'manager_general':
                $user->managerGeneralProfile()->create($profileFields);
                $relation = 'managerGeneralProfile';
                break;

            case 'director':
                $user->directorProfile()->create($profileFields);
                $relation = 'directorProfile';
                break;

            default:
                return response()->json([
                    'status' => false,
                    'message' => __('common.invalid_role'),
                ], 400);
        }

        return response()->json([
            'status'  => true,
            'message' => __('common.user.created'),
            'data'    => $user->fresh($relation),
        ]);
    }


    public function destroy($id)
    {

        $user = User::find($id);
        if ($user) {
            $user->learnerProfile()->delete();
            $user->managerProfile()->delete();
            $user->teacherProfile()->delete();
            $user->submanagerProfile()->delete();
            $user->badges()->delete();
            $user->CompletedCourse()->delete();
            $user->enrollment()->delete();
            $user->learnerLesson()->delete();
            $user->delete();
            return $this->jsonResponseSuccess(trans('common.deleted'));
        } else {
            return $this->jsonResponseFail(trans('common.no_record_found'), 401);
        }
    }

    public function subManagerStore(AddSubManagerRequest $request)
    {
        $validated = $request->validated();
        if (!empty($validated['avatar']) && Str::startsWith($validated['avatar'], 'data:image')) {
            $avatarPath = $this->storeBase64Image($validated['avatar'], 'avatars');
            $validated['avatar'] = $avatarPath;
        } else {
            unset($validated['avatar']);
        }

        $userFields = ['first_name', 'last_name', 'email', 'password'];
        $userData = array_intersect_key($validated, array_flip($userFields));
        $userData['password'] = bcrypt($userData['password']);
        $userData['parent_id'] = auth()->user()->id;

        // Create user
        $user = User::create($userData);

        // Assign role via Spatie
        if ($user) {
            $user->assignRole("sub_manager");
            User::where('parent_id', $user->id)->update(['parent_id' => null]);
            User::whereIn('id', $validated['learner_ids'])->update(['parent_id' => $user->id]);
            if ($request->filled('course_id') && is_array($request->course_id)) {

                foreach ($request->course_id as $courseId) {

                    Enrollment::firstOrCreate(
                        [
                            'course_id'  => $courseId,
                            'learner_id' => $user->id,
                        ],
                        [
                            'status' => 'Approved' // optional default
                        ]
                    );
                }
            }
        }
        $user->managerProfile()->create(["bio" => $validated["bio"] ?? null]);

        Mail::to($validated['email'])->send(new UserCredentialsMail($validated['email'], $validated['password'], "sub_manager"));

        return response()->json([
            'status' => true,
            'message' => __('common.user.created'),
            'data' => $user->fresh("managerProfile")
        ]);
    }

    public function subManagerUpdate($id, EditSubManagerRequest $request)
    {
        $validated = $request->validated();
        $user = User::where('id', $id)->first();
        if (!$user) {
            return $this->jsonResponseFail(trans('common.no_record_found'), 401);
        }

        if (!empty($validated['avatar']) && Str::startsWith($validated['avatar'], 'data:image')) {
            $avatarPath = $this->storeBase64Image($validated['avatar'], 'avatars');
            $validated['avatar'] = $avatarPath;
        } elseif (empty($validated['avatar'])) {
            unset($validated['avatar']);
        }

        $userFields = ['first_name', 'last_name', 'email', 'password', 'bio', 'avatar'];
        $userData = array_intersect_key($validated, array_flip($userFields));

        if (!empty($validated['password'])) {
            $userData['password'] = bcrypt($validated['password']);
        }
        $user->update($userData);

        if ($request->filled('course_id') && is_array($request->course_id)) {

            // Remove existing enrollments for this learner & selected courses
            Enrollment::where('learner_id', $user->id)
                ->whereIn('course_id', $request->course_id)
                ->delete();

            // Recreate enrollments
            foreach ($request->course_id as $courseId) {
                Enrollment::create([
                    'course_id'  => $courseId,
                    'learner_id' => $user->id,
                    'status' => 'Approved'
                ]);
            }
        }


        if (isset($validated['learner_ids']) && is_array($validated['learner_ids'])) {
            User::where('parent_id', $user->id)->update(['parent_id' => null]);
            User::whereIn('id', $validated['learner_ids'])->update(['parent_id' => $user->id]);
        }

        $user->managerProfile()->update(["bio" => $validated["bio"] ?? null]);

        return response()->json([
            'status' => true,
            'message' => __('common.user.updated'),
            'data' => $user->fresh("managerProfile"),
        ]);
    }
    public function updateUserStatus(Request $request, $id)
    {
        $data = $request->validate([
            'is_active' => 'required|boolean',
        ]);

        $user = User::find($id);

        if (empty($user)) {
            return $this->jsonResponseFail(trans('common.no_record_found'), 401);
        }

        $user->is_active =   $data['is_active'];
        $user->save();

        return $this->jsonResponseSuccess(trans('common.updated'));
    }

    public function assigningListUser(Request $request)
    {
        $request->validate(
            [
                'role' => 'required|in:admin,manager_general,sub_manager,teacher,learner,director,manager',
            ],
            [
                'role.required' => 'Le champ rôle est obligatoire.',
                'role.in'       => 'Le rôle sélectionné n’est pas valide.',
            ]
        );

        $query = User::query()
            ->select('id', 'first_name', 'last_name')
            ->where(function ($q) {
                $q->whereNull('parent_id')
                    ->orWhere('parent_id', '');
            });

        $query->whereDoesntHave(
            'roles',
            fn($q) =>
            $q->whereIn('name', ['teacher'])
        );

        if ($request->role === 'manager') {
            $query->whereDoesntHave(
                'roles',
                fn($q) =>
                $q->whereIn('name', ['admin', 'manager'])
            );
        } elseif ($request->role === 'director') {
            $query->whereDoesntHave(
                'roles',
                fn($q) =>
                $q->whereIn('name', ['admin', 'manager', 'director'])
            );
        } elseif ($request->role === 'manager_general') {
            $query->whereDoesntHave(
                'roles',
                fn($q) =>
                $q->whereIn('name', ['admin', 'manager', 'director', 'manager_general'])
            );
        } elseif ($request->role === 'sub_manager') {
            $query->whereDoesntHave(
                'roles',
                fn($q) =>
                $q->whereIn('name', [
                    'admin',
                    'manager',
                    'director',
                    'manager_general',
                    'sub_manager'
                ])
            );
        }

        $users = $query->get()->map(function ($user) {
            return [
                'id'         => $user->id,
                'first_name' => $user->first_name,
                'last_name'  => $user->last_name,
                'role'       => $user->getRoleNames()->first(), // ✅ Spatie role
            ];
        });

        return $this->jsonResponseSuccess([
            'users' => $users
        ]);
    }
}