<?php

namespace App\Services;

use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;
use Throwable;

/**
 * Shared logic for downloading a model's Instagram-hosted media into local
 * storage and rewriting its url columns to point at the cached copy.
 * Instagram's CDN urls are signed and expire, so caching is a one-way trip:
 * once a field holds a local url it's left alone on every later call, which
 * makes cache() safe to call repeatedly. It also repairs any url that was
 * cached as an absolute address before switching to relative ones, without
 * re-downloading — the file is already on disk.
 */
abstract class MediaCacher
{
    private const INSTAGRAM_HOST_SUFFIXES = ['fbcdn.net', 'cdninstagram.com'];

    /**
     * True if the url still points at Instagram's own CDN (i.e. hasn't been
     * cached locally yet). Public so callers writing scraped data back to
     * an existing row can check it before deciding whether to overwrite a
     * field a cache pass already replaced.
     */
    public function isInstagramUrl(?string $url): bool
    {
        if (! $url) {
            return false;
        }

        $host = parse_url($url, PHP_URL_HOST);

        if (! $host) {
            return false;
        }

        foreach (self::INSTAGRAM_HOST_SUFFIXES as $suffix) {
            if (str_ends_with($host, $suffix)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Figures out what, if anything, a url field needs to become: null if
     * it's already a relative path we generated (nothing to do), a
     * rewritten relative path if it's an absolute url pointing at our own
     * /storage/ (cached before the relative-path fix, no download needed),
     * a freshly downloaded local path if it's still on Instagram's CDN, or
     * null for anything else we don't recognize.
     */
    protected function resolveUrl(?string $url, string $pathWithoutExtension): ?string
    {
        if (! $url || str_starts_with($url, '/storage/')) {
            return null;
        }

        if (($pos = strpos($url, '/storage/')) !== false) {
            return substr($url, $pos);
        }

        if ($this->isInstagramUrl($url)) {
            return $this->download($url, $pathWithoutExtension);
        }

        return null;
    }

    private function download(string $url, string $pathWithoutExtension): ?string
    {
        // Stream the response straight to disk via Guzzle's `sink` option
        // instead of buffering the whole body in memory — a several-MB
        // video/reel can easily exceed PHP's default memory_limit if
        // fetched the normal way (Http::get()->body() reads it all into a
        // string first). The extension isn't known until we see the
        // response, so this writes to a temp file and renames it after.
        $tempPath = $pathWithoutExtension.'.downloading-'.uniqid();
        $absoluteTempPath = Storage::disk('public')->path($tempPath);

        File::ensureDirectoryExists(dirname($absoluteTempPath));

        try {
            $response = Http::withHeaders(['User-Agent' => 'Mozilla/5.0'])
                ->timeout(60)
                ->withOptions(['sink' => $absoluteTempPath])
                ->get($url);
        } catch (Throwable $e) {
            Log::warning(static::class.": failed to fetch {$url}: {$e->getMessage()}");
            @unlink($absoluteTempPath);

            return null;
        }

        if (! $response->successful()) {
            Log::warning(static::class.": got {$response->status()} fetching {$url}");
            @unlink($absoluteTempPath);

            return null;
        }

        $path = $pathWithoutExtension.'.'.$this->guessExtension($url, $response->header('Content-Type'));
        Storage::disk('public')->move($tempPath, $path);

        return '/storage/'.$path;
    }

    private function guessExtension(string $url, ?string $contentType): string
    {
        $fromUrl = pathinfo(parse_url($url, PHP_URL_PATH) ?? '', PATHINFO_EXTENSION);

        if ($fromUrl && strlen($fromUrl) <= 4) {
            return strtolower($fromUrl);
        }

        return str_contains((string) $contentType, 'video') ? 'mp4' : 'jpg';
    }
}