buckets/app/Http/Controllers/ProjectionController.php

<?php

namespace App\Http\Controllers;

use App\Http\Requests\CalculateProjectionRequest;
use App\Http\Requests\PreviewAllocationRequest;
use App\Http\Resources\ProjectionResource;
use App\Models\Bucket;
use App\Models\Scenario;
use App\Services\Projection\PipelineAllocationService;
use App\Services\Projection\ProjectionGeneratorService;
use Carbon\Carbon;
use Illuminate\Http\JsonResponse;

class ProjectionController extends Controller
{
    public function __construct(
        private readonly ProjectionGeneratorService $projectionGeneratorService,
        private readonly PipelineAllocationService $pipelineAllocationService,
    ) {}

    public function calculate(CalculateProjectionRequest $request, Scenario $scenario): ProjectionResource
    {
        $startDate = Carbon::parse($request->input('start_date'));
        $endDate = Carbon::parse($request->input('end_date'));

        $projections = $this->projectionGeneratorService->generateProjections(
            $scenario,
            $startDate,
            $endDate
        );

        return new ProjectionResource($projections);
    }

    /**
     * All amounts in cents. Frontend handles conversion to display units.
     */
    public function preview(PreviewAllocationRequest $request, Scenario $scenario): JsonResponse
    {
        $amountInCents = (int) $request->input('amount');

        $draws = $this->pipelineAllocationService->allocateInflow($scenario, $amountInCents);

        /** @var array<int, Bucket> $bucketLookup */
        $bucketLookup = $scenario->buckets->keyBy('id')->all();

        $allocations = $draws->map(function ($draw) use ($bucketLookup) {
            $bucket = $bucketLookup[$draw->bucket_id];

            return [
                'bucket_id' => $bucket->uuid,
                'bucket_name' => $bucket->name,
                'bucket_type' => $bucket->type->value,
                'allocated_amount' => $draw->amount,
                'remaining_capacity' => $bucket->hasFiniteCapacity()
                    ? max(0, $bucket->getEffectiveCapacity() - $draw->amount)
                    : null,
            ];
        })->values();

        $totalAllocated = $draws->sum('amount');

        return response()->json([
            'allocations' => $allocations,
            'total_allocated' => $totalAllocated,
            'unallocated' => $amountInCents - $totalAllocated,
        ]);
    }
}