<?php

declare(strict_types=1);

class ArticleManager
{
    private const MAX_REVISIONS = 50;

    public function __construct(private string $dataDir)
    {
    }

    // ------------------------------------------------------------------ //
    //  Lecture
    // ------------------------------------------------------------------ //

    public function getAll(bool $publishedOnly = false): array
    {
        $articles = [];
        if (!is_dir($this->dataDir)) {
            return $articles;
        }

        foreach (scandir($this->dataDir) as $entry) {
            if ($entry === '.' || $entry === '..') {
                continue;
            }
            $dir = $this->dataDir . '/' . $entry;
            if (!is_dir($dir) || !file_exists($dir . '/meta.json')) {
                continue;
            }

            $article = $this->loadArticle($dir);
            if (!$article) {
                continue;
            }
            if ($publishedOnly && !$article['published']) {
                continue;
            }
            $articles[] = $article;
        }

        usort($articles, static fn ($a, $b) => strcmp($b['published_at'] ?? '', $a['published_at'] ?? ''));

        return $articles;
    }

    public function getBySlug(string $slug): ?array
    {
        foreach ($this->getAll() as $article) {
            if (($article['slug'] ?? '') === $slug) {
                return $article;
            }
        }
        return null;
    }

    public function getByUuid(string $uuid): ?array
    {
        if (!$this->isValidUuid($uuid)) {
            return null;
        }
        $dir = $this->dataDir . '/' . $uuid;
        if (!is_dir($dir) || !file_exists($dir . '/meta.json')) {
            return null;
        }
        return $this->loadArticle($dir);
    }

    public function getRevisionContent(string $uuid, int $n): ?string
    {
        if (!$this->isValidUuid($uuid) || $n < 1) {
            return null;
        }
        $path = sprintf('%s/%s/revisions/%04d.md', $this->dataDir, $uuid, $n);
        if (!file_exists($path)) {
            return null;
        }
        $c = file_get_contents($path);
        return $c !== false ? $c : null;
    }

    // ------------------------------------------------------------------ //
    //  Écriture
    // ------------------------------------------------------------------ //

    public function create(string $title, string $content, bool $published, string $slug = '', string $publishedAt = '', string $author = '', string $seoTitle = '', string $seoDescription = '', string $ogImage = '', string $category = ''): string
    {
        $uuid        = $this->generateUuid();
        $slug        = $slug !== '' ? $this->sanitizeSlug($slug) : $this->generateSlug($title);
        $slug        = $this->uniqueSlug($slug, $uuid);
        $now         = date('Y-m-d H:i:s');
        $publishedAt = $publishedAt !== '' ? $publishedAt : $now;

        $dir = $this->dataDir . '/' . $uuid;
        mkdir($dir, 0755, true);
        mkdir($dir . '/files', 0755, true);

        $meta = [
            'uuid'            => $uuid,
            'slug'            => $slug,
            'title'           => $title,
            'author'          => $author,
            'published'       => $published,
            'published_at'    => $publishedAt,
            'created_at'      => $now,
            'updated_at'      => $now,
            'revisions'       => [],
            'cover'           => '',
            'files_meta'      => [],
            'external_links'  => [],
            'seo_title'       => $seoTitle,
            'seo_description' => $seoDescription,
            'og_image'        => $ogImage,
            'category'        => $category,
        ];
        $this->writeMeta($dir, $meta);
        file_put_contents($dir . '/index.md', ltrim($content));
        $this->rebuildSearchIndex();

        return $uuid;
    }

    public function update(string $uuid, string $title, string $content, bool $published, string $slug, string $publishedAt, string $revisionComment = '', string $seoTitle = '', string $seoDescription = '', string $ogImage = '', string $category = ''): void
    {
        $article = $this->getByUuid($uuid);
        if (!$article) {
            return;
        }

        $slug = $slug !== '' ? $this->sanitizeSlug($slug) : $this->generateSlug($title);
        $slug = $this->uniqueSlug($slug, $uuid);

        // Snapshot de l'état courant avant écrasement — uniquement si le contenu ou le titre a changé
        $revisions      = $article['revisions'] ?? [];
        $contentChanged = ltrim($content) !== ($article['content'] ?? '');
        $titleChanged   = $title !== ($article['title'] ?? '');

        if ($contentChanged || $titleChanged) {
            $revDir = $this->dataDir . '/' . $uuid . '/revisions';
            if (!is_dir($revDir)) {
                mkdir($revDir, 0755, true);
            }
            $n       = count($revisions) + 1;
            $revFile = sprintf('%s/%04d.md', $revDir, $n);
            file_put_contents($revFile, $article['content']);

            $revisions[] = [
                'n'       => $n,
                'date'    => date('Y-m-d H:i:s'),
                'comment' => $revisionComment,
                'title'   => $article['title'],
            ];

            // Limite à MAX_REVISIONS
            if (count($revisions) > self::MAX_REVISIONS) {
                $oldest = array_shift($revisions);
                @unlink(sprintf('%s/%04d.md', $revDir, (int)($oldest['n'] ?? 0)));
            }
        } // fin if ($contentChanged || $titleChanged)

        $meta = [
            'uuid'            => $uuid,
            'slug'            => $slug,
            'title'           => $title,
            'author'          => $article['author'] ?? '',
            'published'       => $published,
            'published_at'    => $publishedAt !== '' ? $publishedAt : ($article['published_at'] ?? date('Y-m-d H:i:s')),
            'created_at'      => $article['created_at'] ?? date('Y-m-d H:i:s'),
            'updated_at'      => date('Y-m-d H:i:s'),
            'revisions'       => $revisions,
            'cover'           => $article['cover'] ?? '',
            'files_meta'      => $article['files_meta'] ?? [],
            'external_links'  => $article['external_links'] ?? [],
            'seo_title'       => $seoTitle,
            'seo_description' => $seoDescription,
            'og_image'        => $ogImage,
            'category'        => $category,
        ];
        $dir = $this->dataDir . '/' . $uuid;
        $this->writeMeta($dir, $meta);
        file_put_contents($dir . '/index.md', ltrim($content));
        $this->rebuildSearchIndex();
    }

    public function autosave(string $uuid, string $title, string $content, string $slug): bool
    {
        if (!$this->isValidUuid($uuid)) {
            return false;
        }
        $dir = $this->dataDir . '/' . $uuid;
        $raw = @file_get_contents($dir . '/meta.json');
        if ($raw === false) {
            return false;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta)) {
            return false;
        }

        $slug = $slug !== '' ? $this->sanitizeSlug($slug) : $this->generateSlug($title);
        $slug = $this->uniqueSlug($slug, $uuid);

        $meta['title']      = $title;
        $meta['slug']       = $slug;
        $meta['updated_at'] = date('Y-m-d H:i:s');

        $this->writeMeta($dir, $meta);
        @file_put_contents($dir . '/index.md', ltrim($content));
        return true;
    }

    public function addFileMeta(string $uuid, string $filename, string $author, string $sourceUrl, string $title = '', array $extraMeta = []): void
    {
        if (!$this->isValidUuid($uuid)) {
            return;
        }
        $filename = basename($filename);

        $raw = file_get_contents($this->dataDir . '/' . $uuid . '/meta.json');
        if ($raw === false) {
            return;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta)) {
            return;
        }
        if (!isset($meta['files_meta']) || !is_array($meta['files_meta'])) {
            $meta['files_meta'] = [];
        }
        $entry = ['author' => $author, 'source_url' => $sourceUrl];
        if ($title !== '') {
            $entry['title'] = $title;
        }
        if (!empty($extraMeta)) {
            $clean = $extraMeta;
            unset($clean['title'], $clean['author'], $clean['credit'], $clean['source']);
            $entry['meta'] = $clean;
        }
        $meta['files_meta'][$filename] = $entry;
        $this->writeMeta($this->dataDir . '/' . $uuid, $meta);
    }

    public function setCover(string $uuid, string $filename): void
    {
        $article = $this->getByUuid($uuid);
        if (!$article) {
            return;
        }
        $filename  = basename($filename);
        $filesDir  = $this->dataDir . '/' . $uuid . '/files';
        $targetPath = $filesDir . '/' . $filename;
        if (!file_exists($targetPath)) {
            return;
        }

        $mime      = mime_content_type($targetPath) ?: '';
        $ext       = $this->extFromMime($mime) ?? strtolower(pathinfo($filename, PATHINFO_EXTENSION)) ?: 'jpg';
        $coverName = 'cover.' . $ext;

        // Rename old cover back to hash name
        $oldCover = $article['cover'] ?? '';
        if ($oldCover && $oldCover !== $filename && $oldCover !== $coverName) {
            $oldPath = $filesDir . '/' . basename($oldCover);
            if (file_exists($oldPath)) {
                $hash    = substr(hash_file('sha256', $oldPath), 0, 16);
                $size    = filesize($oldPath);
                $oldExt  = strtolower(pathinfo($oldCover, PATHINFO_EXTENSION));
                rename($oldPath, $filesDir . '/' . "{$hash}-{$size}.{$oldExt}");
            }
        }

        // Rename target to cover.{ext}
        $newPath = $filesDir . '/' . $coverName;
        if ($targetPath !== $newPath) {
            rename($targetPath, $newPath);
        }

        $raw = file_get_contents($this->dataDir . '/' . $uuid . '/meta.json');
        if ($raw === false) {
            return;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta)) {
            return;
        }
        $meta['cover'] = $coverName;
        $this->writeMeta($this->dataDir . '/' . $uuid, $meta);
    }

    public function addFileFromUrl(string $uuid, string $url, bool $isCover = false, string $author = '', string $sourceUrl = '', string $title = '', array $extraMeta = []): ?string
    {
        if (!$this->isValidUuid($uuid)) {
            return null;
        }
        if (!filter_var($url, FILTER_VALIDATE_URL) || !preg_match('#^https?://#i', $url)) {
            return null;
        }

        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_FOLLOWLOCATION => true,
            CURLOPT_MAXREDIRS      => 3,
            CURLOPT_TIMEOUT        => 20,
            CURLOPT_CONNECTTIMEOUT => 5,
            CURLOPT_USERAGENT      => 'varlog/1.0',
        ]);
        $body = curl_exec($ch);
        $info = curl_getinfo($ch);
        curl_close($ch);

        if ($body === false || (int)$info['http_code'] !== 200) {
            return null;
        }

        $tmp = tempnam(sys_get_temp_dir(), 'vl_');
        file_put_contents($tmp, $body);

        $mime     = mime_content_type($tmp) ?: 'application/octet-stream';
        $isImage  = str_starts_with($mime, 'image/');
        $filesDir = $this->dataDir . '/' . $uuid . '/files';
        if (!is_dir($filesDir)) {
            mkdir($filesDir, 0755, true);
        }

        if ($isImage) {
            $ext = $this->extFromMime($mime) ?? strtolower(pathinfo(parse_url($url, PHP_URL_PATH) ?? '', PATHINFO_EXTENSION)) ?: 'jpg';

            if ($isCover) {
                // Gérer l'ancienne cover
                $article  = $this->getByUuid($uuid);
                $oldCover = $article['cover'] ?? '';
                if ($oldCover) {
                    $oldPath = $filesDir . '/' . basename($oldCover);
                    if (file_exists($oldPath)) {
                        $hash   = substr(hash_file('sha256', $oldPath), 0, 16);
                        $size   = filesize($oldPath);
                        $oldExt = strtolower(pathinfo($oldCover, PATHINFO_EXTENSION));
                        rename($oldPath, $filesDir . '/' . "{$hash}-{$size}.{$oldExt}");
                    }
                }
                $filename = 'cover.' . $ext;
            } else {
                $hash     = substr(hash_file('sha256', $tmp), 0, 16);
                $size     = strlen($body);
                $filename = "{$hash}-{$size}.{$ext}";
            }
        } else {
            // Non-image : nom extrait de l'URL, sanitisé, dédupliqué
            $urlPath  = parse_url($url, PHP_URL_PATH) ?? '';
            $filename = preg_replace('/[^a-zA-Z0-9._-]/', '_', basename($urlPath)) ?: 'file';
            $i        = 1;
            $info     = pathinfo($filename);
            while (file_exists($filesDir . '/' . $filename)) {
                $filename = $info['filename'] . '_' . $i . (isset($info['extension']) ? '.' . $info['extension'] : '');
                $i++;
            }
        }

        rename($tmp, $filesDir . '/' . $filename);

        if ($author !== '' || $sourceUrl !== '' || $title !== '' || !empty($extraMeta)) {
            $this->addFileMeta($uuid, $filename, $author, $sourceUrl, $title, $extraMeta);
        }

        if ($isCover && $isImage) {
            $raw = file_get_contents($this->dataDir . '/' . $uuid . '/meta.json');
            if ($raw !== false) {
                $meta = json_decode($raw, true);
                if (is_array($meta)) {
                    $meta['cover'] = $filename;
                    $this->writeMeta($this->dataDir . '/' . $uuid, $meta);
                }
            }
        }

        return $filename;
    }

    public function addExternalLink(string $uuid, string $url, string $title = '', string $author = '', array $extraMeta = []): bool
    {
        if (!$this->isValidUuid($uuid) || !filter_var($url, FILTER_VALIDATE_URL)) {
            return false;
        }
        $dir = $this->dataDir . '/' . $uuid;
        $raw = file_get_contents($dir . '/meta.json');
        if ($raw === false) {
            return false;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta)) {
            return false;
        }
        if (!isset($meta['external_links']) || !is_array($meta['external_links'])) {
            $meta['external_links'] = [];
        }
        foreach ($meta['external_links'] as $link) {
            if ($link['url'] === $url) {
                return true; // already exists
            }
        }
        $urlPath = parse_url($url, PHP_URL_PATH) ?? '';
        $name    = $title !== '' ? $title : (rawurldecode(basename($urlPath)) ?: $url);
        $entry = ['url' => $url, 'name' => $name, 'added_at' => date('Y-m-d H:i:s')];
        $resolvedAuthor = $author !== '' ? $author : ($extraMeta['author'] ?? '');
        if ($resolvedAuthor !== '') {
            $entry['author'] = $resolvedAuthor;
        }
        if (!empty($extraMeta)) {
            $clean = $extraMeta;
            unset($clean['title'], $clean['author'], $clean['credit']);
            $entry['meta'] = $clean;
        }
        $meta['external_links'][] = $entry;
        $this->writeMeta($dir, $meta);
        return true;
    }

    public function updateExternalLinkMeta(string $uuid, string $url, array $metaUpdates): bool
    {
        if (!$this->isValidUuid($uuid)) {
            return false;
        }
        $dir = $this->dataDir . '/' . $uuid;
        $raw = file_get_contents($dir . '/meta.json');
        if ($raw === false) {
            return false;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta)) {
            return false;
        }
        $found = false;
        foreach ($meta['external_links'] as &$link) {
            if ($link['url'] === $url) {
                $link['meta'] = array_merge($link['meta'] ?? [], $metaUpdates);
                $found = true;
                break;
            }
        }
        unset($link);
        if (!$found) {
            return false;
        }
        $this->writeMeta($dir, $meta);
        return true;
    }

    public function removeExternalLink(string $uuid, string $url): bool
    {
        if (!$this->isValidUuid($uuid)) {
            return false;
        }
        $dir = $this->dataDir . '/' . $uuid;
        $raw = file_get_contents($dir . '/meta.json');
        if ($raw === false) {
            return false;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta)) {
            return false;
        }
        $meta['external_links'] = array_values(array_filter(
            $meta['external_links'] ?? [],
            static fn ($l) => $l['url'] !== $url
        ));
        $this->writeMeta($dir, $meta);
        return true;
    }

    public function getCategories(): array
    {
        $cats = [];
        foreach ($this->getAll() as $article) {
            $cat = trim($article['category'] ?? '');
            if ($cat !== '') {
                $cats[$cat] = ($cats[$cat] ?? 0) + 1;
            }
        }
        ksort($cats);
        return $cats;
    }

    public function renameCategory(string $old, string $new): void
    {
        if (!is_dir($this->dataDir)) {
            return;
        }
        foreach (scandir($this->dataDir) as $entry) {
            if ($entry === '.' || $entry === '..') {
                continue;
            }
            $metaPath = $this->dataDir . '/' . $entry . '/meta.json';
            if (!file_exists($metaPath)) {
                continue;
            }
            $raw = file_get_contents($metaPath);
            if ($raw === false) {
                continue;
            }
            $meta = json_decode($raw, true);
            if (!is_array($meta) || trim($meta['category'] ?? '') !== $old) {
                continue;
            }
            $meta['category'] = $new;
            $this->writeMeta($this->dataDir . '/' . $entry, $meta);
        }
    }

    public function deleteCategory(string $name): void
    {
        $this->renameCategory($name, '');
    }

    public function getPrivateCategories(): array
    {
        $path = $this->dataDir . '/private_cats.json';
        if (!file_exists($path)) {
            return [];
        }
        $data = json_decode((string)file_get_contents($path), true);
        return is_array($data) ? $data : [];
    }

    public function togglePrivateCategory(string $cat): void
    {
        $cats = $this->getPrivateCategories();
        if (in_array($cat, $cats, true)) {
            $cats = array_values(array_filter($cats, fn ($c) => $c !== $cat));
        } else {
            $cats[] = $cat;
        }
        file_put_contents(
            $this->dataDir . '/private_cats.json',
            json_encode(array_values($cats), JSON_UNESCAPED_UNICODE)
        );
    }

    public function delete(string $uuid): void
    {
        if (!$this->isValidUuid($uuid)) {
            return;
        }
        $dir = $this->dataDir . '/' . $uuid;
        if (is_dir($dir)) {
            $this->removeDir($dir);
        }
        $this->rebuildSearchIndex();
    }

    // ------------------------------------------------------------------ //
    //  Index de recherche (fichier plat)
    // ------------------------------------------------------------------ //

    /**
     * Reconstruit search_index.json à partir de tous les articles.
     * Appelé automatiquement après chaque create/update/delete.
     */
    public function rebuildSearchIndex(): void
    {
        $index = [];
        foreach ($this->getAll() as $article) {
            $index[] = [
                'uuid'         => $article['uuid'],
                'slug'         => $article['slug'] ?? '',
                'title'        => $article['title'] ?? '',
                'category'     => $article['category'] ?? '',
                'published'    => $article['published'],
                'published_at' => $article['published_at'] ?? '',
                'updated_at'   => $article['updated_at'] ?? '',
                'plain'        => $this->stripForIndex($article['content'] ?? ''),
            ];
        }
        file_put_contents(
            $this->dataDir . '/search_index.json',
            json_encode($index, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
        );
    }

    /** Retourne l'index pré-construit, ou null s'il n'existe pas encore. */
    public function getSearchIndex(): ?array
    {
        $path = $this->dataDir . '/search_index.json';
        if (!file_exists($path)) {
            return null;
        }
        $data = json_decode((string) file_get_contents($path), true);
        return is_array($data) ? $data : null;
    }

    /** Retire la syntaxe Markdown pour stocker du texte brut dans l'index. */
    private function stripForIndex(string $md): string
    {
        $t = preg_replace('/!\[[^\]]*\]\([^)]+\)/', '', $md)            ?? $md;
        $t = preg_replace('/\[([^\]]+)\]\([^)]+\)/', '$1', $t)          ?? $t;
        $t = preg_replace('/```[\s\S]*?```/', '', $t)                    ?? $t;
        $t = preg_replace('/`[^`]+`/', '', $t)                           ?? $t;
        $t = preg_replace('/^#{1,6}\s*/m', '', $t)                      ?? $t;
        $t = preg_replace('/[*_~]{1,3}([^*_~]+)[*_~]{1,3}/', '$1', $t) ?? $t;
        $t = preg_replace('/^\s*[-*+|>]\s*/m', '', $t)                  ?? $t;
        $t = preg_replace('/\n{2,}/', ' ', $t)                          ?? $t;
        return trim($t);
    }

    // ------------------------------------------------------------------ //
    //  Fichiers associés
    // ------------------------------------------------------------------ //

    public function getFiles(string $uuid): array
    {
        $dir = $this->dataDir . '/' . $uuid . '/files';
        if (!is_dir($dir)) {
            return [];
        }

        $files = [];
        foreach (scandir($dir) as $name) {
            if ($name === '.' || $name === '..') {
                continue;
            }
            $path = $dir . '/' . $name;
            if (!is_file($path)) {
                continue;
            }
            $mime    = mime_content_type($path) ?: 'application/octet-stream';
            $files[] = [
                'name'        => $name,
                'size'        => filesize($path),
                'mime'        => $mime,
                'is_image'    => str_starts_with($mime, 'image/'),
                'is_video'    => str_starts_with($mime, 'video/'),
                'is_audio'    => str_starts_with($mime, 'audio/'),
                'uploaded_at' => date('Y-m-d H:i:s', (int)filemtime($path)),
            ];
        }
        return $files;
    }

    public function deleteFile(string $uuid, string $name): bool
    {
        if (!$this->isValidUuid($uuid)) {
            return false;
        }
        $name = basename($name);
        if ($name === '' || $name[0] === '.') {
            return false;
        }
        $path = $this->dataDir . '/' . $uuid . '/files/' . $name;
        if (!is_file($path)) {
            return false;
        }
        return unlink($path);
    }

    public function addFile(string $uuid, array $uploadedFile): ?string
    {
        if (!$this->isValidUuid($uuid)) {
            return null;
        }
        $dir = $this->dataDir . '/' . $uuid . '/files';
        if (!is_dir($dir)) {
            mkdir($dir, 0755, true);
        }

        $mime = mime_content_type($uploadedFile['tmp_name']) ?: 'application/octet-stream';

        if (str_starts_with($mime, 'image/')) {
            // HEIC/HEIF : converti en JPEG (non supporté nativement par les navigateurs)
            if (in_array($mime, ['image/heic', 'image/heif'], true) && extension_loaded('imagick')) {
                try {
                    $img = new \Imagick($uploadedFile['tmp_name']);
                    $img->setImageFormat('jpeg');
                    $img->setImageCompressionQuality(88);
                    $converted = tempnam(sys_get_temp_dir(), 'vl_heic_') . '.jpg';
                    $img->writeImage($converted);
                    $img->destroy();
                    $uploadedFile['tmp_name'] = $converted;
                    $mime = 'image/jpeg';
                } catch (\Exception $e) {
                    // Échec conversion → stocke tel quel
                }
            }

            $ext  = $this->extFromMime($mime)
                 ?? strtolower(pathinfo($uploadedFile['name'], PATHINFO_EXTENSION))
                 ?: 'jpg';
            $hash = substr(hash_file('sha256', $uploadedFile['tmp_name']), 0, 16);
            $size = filesize($uploadedFile['tmp_name']);
            $name = "{$hash}-{$size}.{$ext}";
            $dest = $dir . '/' . $name;
            if (!rename($uploadedFile['tmp_name'], $dest) && !move_uploaded_file($uploadedFile['tmp_name'], $dest)) {
                return null;
            }
            return $name;
        }

        // Non-image : nom sanitisé + déduplication
        $name = preg_replace('/[^a-zA-Z0-9._-]/', '_', basename($uploadedFile['name']));
        $dest = $dir . '/' . $name;
        $i    = 1;
        $info = pathinfo($name);
        while (file_exists($dest)) {
            $dest = $dir . '/' . $info['filename'] . '_' . $i . (isset($info['extension']) ? '.' . $info['extension'] : '');
            $i++;
        }
        if (!move_uploaded_file($uploadedFile['tmp_name'], $dest)) {
            return null;
        }
        return basename($dest);
    }

    // ------------------------------------------------------------------ //
    //  Rendu
    // ------------------------------------------------------------------ //

    public function resolveFileUrls(string $uuid, string $markdown): string
    {
        $base = '/file?uuid=' . rawurlencode($uuid) . '&name=';

        return preg_replace_callback(
            '/(!?\[([^\]]*)\])\((?!https?:\/\/)(?!\/)([^)]+)\)/',
            static function (array $m) use ($base): string {
                return $m[1] . '(' . $base . rawurlencode($m[3]) . ')';
            },
            $markdown
        ) ?? $markdown;
    }

    // ------------------------------------------------------------------ //
    //  Helpers privés
    // ------------------------------------------------------------------ //

    private function extFromMime(string $mime): ?string
    {
        return match($mime) {
            'image/jpeg'    => 'jpg',
            'image/png'     => 'png',
            'image/webp'    => 'webp',
            'image/gif'     => 'gif',
            'image/avif'    => 'avif',
            'image/svg+xml' => 'svg',
            'image/heic'    => 'jpg',
            'image/heif'    => 'jpg',
            default         => null,
        };
    }

    private function loadArticle(string $dir): ?array
    {
        $metaPath    = $dir . '/meta.json';
        $contentPath = $dir . '/index.md';

        $raw = file_get_contents($metaPath);
        if ($raw === false) {
            return null;
        }
        $meta = json_decode($raw, true);
        if (!is_array($meta) || empty($meta['uuid'])) {
            return null;
        }

        $meta['content']        = file_exists($contentPath) ? (string)file_get_contents($contentPath) : '';
        $meta['published']      = (bool)($meta['published'] ?? false);
        $meta['files_meta']     = $meta['files_meta'] ?? [];
        $meta['external_links'] = $meta['external_links'] ?? [];

        if (!empty($meta['cover'])) {
            $coverPath = $dir . '/files/' . basename((string)$meta['cover']);
            if (!file_exists($coverPath)) {
                $meta['cover'] = '';
            }
        }

        return $meta;
    }

    public function deleteRevision(string $uuid, int $revN): void
    {
        if (!$this->isValidUuid($uuid) || $revN < 1) {
            return;
        }
        $dir  = $this->dataDir . '/' . $uuid;
        $raw  = @file_get_contents($dir . '/meta.json');
        $meta = $raw !== false ? json_decode($raw, true) : null;
        if (!is_array($meta)) {
            return;
        }
        $revisions    = $meta['revisions'] ?? [];
        $newRevisions = [];
        foreach ($revisions as $rev) {
            if ((int)($rev['n'] ?? 0) === $revN) {
                @unlink(sprintf('%s/revisions/%04d.md', $dir, $revN));
            } else {
                $newRevisions[] = $rev;
            }
        }
        $meta['revisions'] = array_values($newRevisions);
        $this->writeMeta($dir, $meta);
    }

    public function deleteAllRevisions(string $uuid): void
    {
        if (!$this->isValidUuid($uuid)) {
            return;
        }
        $dir    = $this->dataDir . '/' . $uuid;
        $revDir = $dir . '/revisions';
        if (is_dir($revDir)) {
            foreach (glob($revDir . '/*.md') ?: [] as $f) {
                @unlink($f);
            }
        }
        $raw  = @file_get_contents($dir . '/meta.json');
        $meta = $raw !== false ? json_decode($raw, true) : null;
        if (is_array($meta)) {
            $meta['revisions'] = [];
            $this->writeMeta($dir, $meta);
        }
    }

    private function writeMeta(string $dir, array $meta): void
    {
        file_put_contents(
            $dir . '/meta.json',
            json_encode($meta, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n"
        );
    }

    private function generateSlug(string $title): string
    {
        $map = [
            'à' => 'a', 'â' => 'a', 'ä' => 'a',
            'é' => 'e', 'è' => 'e', 'ê' => 'e', 'ë' => 'e',
            'î' => 'i', 'ï' => 'i',
            'ô' => 'o', 'ö' => 'o',
            'ù' => 'u', 'û' => 'u', 'ü' => 'u',
            'ç' => 'c', 'æ' => 'ae', 'œ' => 'oe',
        ];
        $slug = mb_strtolower($title, 'UTF-8');
        $slug = strtr($slug, $map);
        $slug = preg_replace('/[^a-z0-9]+/', '-', $slug);
        return trim((string)$slug, '-') ?: 'article';
    }

    private function sanitizeSlug(string $slug): string
    {
        $slug = mb_strtolower(trim($slug), 'UTF-8');
        $slug = preg_replace('/[^a-z0-9-]/', '-', $slug);
        $slug = preg_replace('/-+/', '-', $slug);
        return trim((string)$slug, '-') ?: 'article';
    }

    private function uniqueSlug(string $slug, string $excludeUuid): string
    {
        $taken = array_column(
            array_filter($this->getAll(), static fn ($a) => $a['uuid'] !== $excludeUuid),
            'slug'
        );

        if (!in_array($slug, $taken, true)) {
            return $slug;
        }
        $i = 2;
        while (in_array($slug . '-' . $i, $taken, true)) {
            $i++;
        }
        return $slug . '-' . $i;
    }

    private function generateUuid(): string
    {
        $bytes    = random_bytes(16);
        $bytes[6] = chr(ord($bytes[6]) & 0x0f | 0x40);
        $bytes[8] = chr(ord($bytes[8]) & 0x3f | 0x80);
        return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($bytes), 4));
    }

    private function isValidUuid(string $uuid): bool
    {
        return (bool)preg_match(
            '/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i',
            $uuid
        );
    }

    private function removeDir(string $dir): void
    {
        foreach (scandir($dir) as $entry) {
            if ($entry === '.' || $entry === '..') {
                continue;
            }
            $path = $dir . '/' . $entry;
            is_dir($path) ? $this->removeDir($path) : unlink($path);
        }
        rmdir($dir);
    }
}