Verde-Web/app/Http/Controllers/Api/V1/Admin/AdminUserController.php

<?php

namespace App\Http\Controllers\Api\V1\Admin;

use App\Http\Controllers\Api\V1\ApiController;
use App\Http\Requests\Admin\RejectProfileRequest;
use App\Http\Requests\Admin\UpdateUserRequest;
use App\Http\Resources\HouseholdResource;
use App\Http\Resources\UserDetailResource;
use App\Models\Household;
use App\Models\HouseholdMember;
use App\Models\User;
use App\Services\DropOff\DropOffPointFinder;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use MatanYadaev\EloquentSpatial\Objects\Point;

class AdminUserController extends ApiController
{
    public function index(Request $request): JsonResponse
    {
        $request->validate([
            'role' => [
                'nullable',
                Rule::in([
                    User::ROLE_ADMIN,
                    User::ROLE_RESIDENT,
                    User::ROLE_DRIVER,
                    User::ROLE_HELPER,
                    User::ROLE_SCANNER,
                    User::ROLE_STORE_PARTNER,
                ]),
            ],
            'status' => [
                'nullable',
                Rule::in([
                    User::STATUS_ACTIVE,
                    User::STATUS_SUSPENDED,
                    User::STATUS_PENDING,
                ]),
            ],
            'verification_status' => ['nullable', 'in:pending,approved,rejected'],
            'without_household' => ['nullable', 'boolean'],
            'q' => ['nullable', 'string', 'max:100'],
            'per_page' => ['nullable', 'integer', 'min:1', 'max:500'],
        ]);

        $perPage = (int) $request->input('per_page', 25);

        $users = User::query()
            ->when($request->filled('role'), fn ($q) => $q->where('role', $request->string('role')))
            ->when($request->filled('status'), fn ($q) => $q->where('status', $request->string('status')))
            ->when($request->boolean('without_household'), fn ($q) => $q->whereDoesntHave('headedHousehold'))
            ->when($request->filled('q'), function ($q) use ($request) {
                $term = '%'.$request->string('q').'%';
                $q->where(function ($qq) use ($term) {
                    $qq->where('email', 'like', $term)
                        ->orWhere('phone', 'like', $term)
                        ->orWhere('first_name', 'like', $term)
                        ->orWhere('last_name', 'like', $term);
                });
            })
            ->when($request->filled('verification_status'), function ($q) use ($request) {
                $vs = $request->string('verification_status');
                $q->where(function ($qq) use ($vs) {
                    $qq->whereHas('driverProfile', fn ($p) => $p->where('verification_status', $vs))
                        ->orWhereHas('helperProfile', fn ($p) => $p->where('verification_status', $vs))
                        ->orWhereHas('scannerProfile', fn ($p) => $p->where('verification_status', $vs))
                        ->orWhereHas('storePartnerProfile', fn ($p) => $p->where('verification_status', $vs));
                });
            })
            ->orderByDesc('id')
            ->paginate($perPage);

        $users->load(['residentProfile', 'driverProfile', 'helperProfile', 'scannerProfile', 'storePartnerProfile', 'tenant']);

        return $this->ok(
            UserDetailResource::collection($users),
            null,
            [
                'page' => $users->currentPage(),
                'per_page' => $users->perPage(),
                'total' => $users->total(),
                'last_page' => $users->lastPage(),
            ],
        );
    }

    public function show(User $user): JsonResponse
    {
        $user->load(['residentProfile', 'driverProfile', 'helperProfile', 'scannerProfile', 'storePartnerProfile']);

        return $this->ok(new UserDetailResource($user));
    }

    public function update(UpdateUserRequest $request, User $user): JsonResponse
    {
        $user->update($request->validated());
        $user->load(['residentProfile', 'driverProfile', 'helperProfile', 'scannerProfile', 'storePartnerProfile']);

        return $this->ok(new UserDetailResource($user), 'User updated');
    }

    public function suspend(User $user): JsonResponse
    {
        if ($user->role === User::ROLE_ADMIN) {
            return $this->fail('Admin users cannot be suspended via this endpoint', null, 422);
        }

        $user->forceFill(['status' => User::STATUS_SUSPENDED])->save();

        return $this->ok(new UserDetailResource($user->fresh()), 'User suspended');
    }

    public function activate(User $user): JsonResponse
    {
        if ($user->role === User::ROLE_RESIDENT) {
            if (! auth()->user()->isSuperAdmin()) {
                return $this->forbidden('Only Super Admins can activate or approve resident profiles');
            }

            $householdMember = HouseholdMember::where('user_id', $user->id)->first();
            $household = $householdMember ? $householdMember->household : $user->headedHousehold;

            if (! $household || ! $household->coordinates) {
                return $this->fail('Resident household must have coordinates pinned before activation', null, 422);
            }
        }

        $user->forceFill(['status' => User::STATUS_ACTIVE])->save();

        return $this->ok(new UserDetailResource($user->fresh()), 'User activated');
    }

    public function destroy(User $user): JsonResponse
    {
        if ($user->role === User::ROLE_ADMIN) {
            return $this->fail('Admin users cannot be deleted via this endpoint', null, 422);
        }

        $user->delete();

        return $this->ok(null, 'User deleted');
    }

    public function approveProfile(Request $request, User $user): JsonResponse
    {
        $profile = $user->profile();

        if (! $profile || ! method_exists($profile, 'markVerified')) {
            return $this->fail('User has no verifiable profile', null, 422);
        }

        if ($user->role === User::ROLE_RESIDENT) {
            if (! auth()->user()->isSuperAdmin()) {
                return $this->forbidden('Only Super Admins can activate or approve resident profiles');
            }

            $householdMember = HouseholdMember::where('user_id', $user->id)->first();
            $household = $householdMember ? $householdMember->household : $user->headedHousehold;

            if (! $household || ! $household->coordinates) {
                return $this->fail('Resident household must have coordinates pinned before activation', null, 422);
            }
        }

        $profile->markVerified($request->user());
        $user->forceFill(['status' => User::STATUS_ACTIVE])->save();

        return $this->ok(new UserDetailResource($user->fresh()->load($user->profileRelation())), 'Profile approved');
    }

    public function rejectProfile(RejectProfileRequest $request, User $user): JsonResponse
    {
        $profile = $user->profile();

        if (! $profile || ! method_exists($profile, 'markRejected')) {
            return $this->fail('User has no verifiable profile', null, 422);
        }

        $profile->markRejected($request->user(), $request->validated('reason'));

        return $this->ok(new UserDetailResource($user->fresh()->load($user->profileRelation())), 'Profile rejected');
    }

    public function groupIntoHousehold(Request $request, User $user): JsonResponse
    {
        if ($user->role !== User::ROLE_RESIDENT) {
            return $this->fail('Only Resident users can be grouped into households', null, 422);
        }

        $data = $request->validate([
            'household_id' => ['nullable', 'integer', 'exists:households,id'],
            // If household_id is null, require new household details:
            'address_line' => ['required_without:household_id', 'nullable', 'string', 'max:255'],
            'barangay_id' => ['required_without:household_id', 'nullable', 'integer', 'exists:barangays,id'],
            'lat' => ['required_without:household_id', 'nullable', 'numeric', 'between:-90,90'],
            'lng' => ['required_without:household_id', 'nullable', 'numeric', 'between:-180,180'],
            'household_size' => ['nullable', 'integer', 'min:1', 'max:50'],
        ]);

        if (! empty($data['household_id'])) {
            $isMemberOfCurrent = HouseholdMember::where('user_id', $user->id)
                ->where('household_id', $data['household_id'])
                ->exists();
            if ($isMemberOfCurrent) {
                return $this->fail('Resident already belongs to this household.', null, 422);
            }
        }

        $household = DB::transaction(function () use ($data, $user) {
            // Find all existing memberships of this user
            $existingMemberships = HouseholdMember::where('user_id', $user->id)->get();

            foreach ($existingMemberships as $oldMember) {
                $oldHousehold = $oldMember->household;
                if ($oldHousehold) {
                    // Delete the old membership
                    $oldMember->delete();

                    // If they were the head of that old household
                    if ($oldHousehold->head_user_id == $user->id) {
                        $otherMembers = $oldHousehold->members()->where('user_id', '!=', $user->id)->get();
                        if ($otherMembers->isEmpty()) {
                            // Delete empty household
                            $oldHousehold->delete();
                        } else {
                            // Reassign head to next available member
                            $nextHead = $otherMembers->first();
                            $oldHousehold->update([
                                'head_user_id' => $nextHead->user_id,
                            ]);
                            $nextHead->update([
                                'relationship' => HouseholdMember::RELATIONSHIP_HEAD,
                            ]);
                        }
                    } else {
                        if ($oldHousehold->members()->count() === 0) {
                            $oldHousehold->delete();
                        }
                    }
                }
            }

            if (! empty($data['household_id'])) {
                $h = Household::findOrFail($data['household_id']);
                HouseholdMember::create([
                    'household_id' => $h->id,
                    'user_id' => $user->id,
                    'relationship' => HouseholdMember::RELATIONSHIP_OTHER,
                    'full_name' => $user->full_name,
                ]);

                $currentMemberCount = $h->members()->count();
                if ($h->household_size < $currentMemberCount) {
                    $h->update(['household_size' => $currentMemberCount]);
                }

                return $h;
            } else {
                $point = new Point((float) $data['lat'], (float) $data['lng'], 4326);
                $dopFinder = app(DropOffPointFinder::class);
                $nearestDop = $dopFinder->nearest((float) $data['lat'], (float) $data['lng']);

                $h = Household::create([
                    'tenant_id' => $user->tenant_id,
                    'head_user_id' => $user->id,
                    'barangay_id' => $data['barangay_id'],
                    'address_line' => $data['address_line'],
                    'coordinates' => $point,
                    'household_size' => $data['household_size'] ?? 1,
                    'assigned_drop_off_point_id' => $nearestDop?->id,
                    'verification_status' => Household::VERIFICATION_PENDING,
                ]);

                HouseholdMember::create([
                    'household_id' => $h->id,
                    'user_id' => $user->id,
                    'relationship' => HouseholdMember::RELATIONSHIP_HEAD,
                    'full_name' => $user->full_name,
                ]);

                return $h;
            }
        });

        $user->load(['residentProfile', 'driverProfile', 'helperProfile', 'scannerProfile', 'storePartnerProfile']);

        return $this->ok([
            'user' => new UserDetailResource($user),
            'household' => new HouseholdResource($household->load(['head', 'barangay.serviceAreas'])),
        ], 'User successfully grouped into household');
    }
}