<?php

namespace App\Services;

use App\Models\ApiLog;
use Illuminate\Http\Client\RequestException;
use Illuminate\Http\Client\Response;
use Illuminate\Support\Str;
use Throwable;

class ApiLogger
{
    /**
     * Cap the stored response body. MEDIUMTEXT can hold ~16MB, but
     * persisting more than 64KB is rarely useful for debugging and
     * blows up the row size on busy services.
     */
    private const int RESPONSE_BODY_CAP = 65_536;

    /**
     * Execute an HTTP request and log it to api_logs.
     *
     * The callable must return an Illuminate\Http\Client\Response.
     * Exceptions are logged and re-thrown so the caller handles them.
     *
     * Persists the response body to `api_logs.response_body` ONLY when
     * the call failed (non-2xx) or threw. Truncates to RESPONSE_BODY_CAP.
     *
     * @param  callable(): Response  $request
     */
    public function send(string $service, string $method, string $url, callable $request): Response
    {
        $start = microtime(true);
        $statusCode = null;
        $error = null;
        $responseBody = null;

        try {
            $response = $request();
            $statusCode = $response->status();

            if ($response->failed()) {
                $body = $response->body();
                $error = Str::limit($body, 1000);
                $responseBody = $this->truncate($body);
            }

            return $response;
        } catch (Throwable $e) {
            $error = $e->getMessage();

            // RequestException carries the response, ConnectionException
            // doesn't. Pull the body when it's available.
            if ($e instanceof RequestException) {
                $responseBody = $this->truncate($e->response->body());
            }

            throw $e;
        } finally {
            ApiLog::create([
                'service' => $service,
                'method' => strtoupper($method),
                'url' => $url,
                'status_code' => $statusCode,
                'duration_ms' => (int) round((microtime(true) - $start) * 1000),
                'error' => $error,
                'response_body' => $responseBody,
            ]);
        }
    }

    private function truncate(string $body): string
    {
        return strlen($body) > self::RESPONSE_BODY_CAP
            ? substr($body, 0, self::RESPONSE_BODY_CAP)
            : $body;
    }
}