SpeedtestCallbackController.php

<?php

namespace App\Http\Controllers\Api\V1;

use App\Enums\ResultStatus;
use App\Events\SpeedtestCompleted;
use App\Events\SpeedtestFailed;
use App\Events\SpeedtestRunning;
use App\Http\Controllers\Controller;
use App\Jobs\Ookla\BenchmarkSpeedtestJob;
use App\Models\Result;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Log;

class SpeedtestCallbackController extends Controller
{
    /**
     * Handle callback from Rust speedtest service.
     */
    public function __invoke(Request $request): JsonResponse
    {
        Log::debug('received speedtest callback', [
            'test_id' => $request->input('test_id'),
            'status' => $request->input('status'),
        ]);

        $resultId = $request->input('metadata.result_id');

        if (! $resultId) {
            Log::warning('callback missing result_id in metadata');

            return response()->json(['error' => 'missing result_id'], 400);
        }

        $result = Result::find($resultId);

        if (! $result) {
            Log::warning('callback for unknown result', ['result_id' => $resultId]);

            return response()->json(['error' => 'result not found'], 404);
        }

        $status = $request->input('status');

        if ($status === 'failed') {
            return $this->handleFailed($result, $request);
        }

        if ($status === 'completed') {
            return $this->handleCompleted($result, $request);
        }

        // Running status update
        if ($status === 'running') {
            $result->update(['status' => ResultStatus::Running]);
            SpeedtestRunning::dispatch($result);

            return response()->json(['status' => 'acknowledged']);
        }

        return response()->json(['status' => 'ignored']);
    }

    /**
     * Handle completed speedtest callback.
     */
    protected function handleCompleted(Result $result, Request $request): JsonResponse
    {
        Log::info('speedtest completed via rust service', [
            'result_id' => $result->id,
            'test_id' => $request->input('test_id'),
        ]);

        // Extract data from Rust service response
        $rawOutput = $request->input('raw_output', []);

        // Update result with speedtest data
        $result->update([
            'ping' => $request->input('ping'),
            'download' => $this->mbpsToBytes($request->input('download')),
            'upload' => $this->mbpsToBytes($request->input('upload')),
            'download_bytes' => Arr::get($rawOutput, 'download.bytes'),
            'upload_bytes' => Arr::get($rawOutput, 'upload.bytes'),
            'data' => $rawOutput,
            'status' => ResultStatus::Benchmarking,
        ]);

        // Dispatch benchmark job
        BenchmarkSpeedtestJob::dispatch($result);

        // Complete the speedtest
        $result->update(['status' => ResultStatus::Completed]);
        SpeedtestCompleted::dispatch($result);

        return response()->json(['status' => 'processed']);
    }

    /**
     * Handle failed speedtest callback.
     */
    protected function handleFailed(Result $result, Request $request): JsonResponse
    {
        Log::error('speedtest failed via rust service', [
            'result_id' => $result->id,
            'error' => $request->input('error'),
        ]);

        $result->update([
            'data->type' => 'log',
            'data->level' => 'error',
            'data->message' => $request->input('error', 'Unknown error from Rust service'),
            'status' => ResultStatus::Failed,
        ]);

        SpeedtestFailed::dispatch($result);

        return response()->json(['status' => 'processed']);
    }

    /**
     * Convert Mbps to bytes per second (Ookla format).
     */
    protected function mbpsToBytes(?float $mbps): ?int
    {
        if ($mbps === null) {
            return null;
        }

        // Convert Mbps to bytes/s (Ookla stores bandwidth in bytes/s)
        return (int) (($mbps * 1_000_000) / 8);
    }
}