<?php
/**
 * Social preview ("OpenGraph") card rendering.
 *
 * Every repository gets a 1200x630 PNG drawn with GD and cached on disk at
 * uploads/og/{slug}-{hash}.png. The hash digests the repository's mutable
 * state and is carried in the public URL — /{slug}/og-{hash}.png — because
 * social crawlers cache og:image by URL essentially forever. Changing the
 * repository changes the URL, which is the only reliable way to make Facebook,
 * Slack, X and friends fetch a fresh card.
 */

require_once __DIR__ . '/helpers.php';

const OG_WIDTH   = 1200;
const OG_HEIGHT  = 630;
const OG_PAD     = 64;

/** Palette — GitHub Primer dark, matching assets/style.css. */
const OG_COLORS = [
    'bg'     => [0x0d, 0x11, 0x17],
    'panel'  => [0x16, 0x1b, 0x22],
    'fg'     => [0xe6, 0xed, 0xf3],
    'muted'  => [0x8b, 0x94, 0x9e],
    'body'   => [0xc9, 0xd1, 0xd9],
    'border' => [0x30, 0x36, 0x3d],
    'accent' => [0x58, 0xa6, 0xff],
];

/** Dot colours for the language badge (GitHub Linguist-ish). */
const OG_LANG_COLORS = [
    'PHP' => '#4F5D95', 'JavaScript' => '#F1E05A', 'TypeScript' => '#3178C6',
    'Python' => '#3572A5', 'Java' => '#B07219', 'CSS' => '#563D7C',
    'SCSS' => '#C6538C', 'Sass' => '#A53B70', 'Less' => '#1D365D',
    'HTML' => '#E34C26', 'Vue' => '#41B883', 'Svelte' => '#FF3E00',
    'JSON' => '#8B949E', 'C' => '#555555', 'C++' => '#F34B7D', 'C#' => '#178600',
    'Go' => '#00ADD8', 'Ruby' => '#701516', 'Rust' => '#DEA584',
    'Swift' => '#F05138', 'Kotlin' => '#A97BFF', 'SQL' => '#E38C00',
    'Shell' => '#89E051', 'XML' => '#0060AC', 'YAML' => '#CB171E', 'TOML' => '#9C4221',
];

// ---- Capability / assets ----------------------------------------------------

/** Absolute path to one of the bundled TrueType faces. */
function og_font(string $style = 'regular'): string
{
    $files = [
        'regular' => 'DejaVuSans.ttf',
        'bold'    => 'DejaVuSans-Bold.ttf',
        'mono'    => 'DejaVuSansMono-Bold.ttf',
    ];
    return __DIR__ . '/../assets/fonts/' . ($files[$style] ?? $files['regular']);
}

/**
 * True when this server can actually draw a card: GD compiled with FreeType
 * and PNG support, plus the bundled fonts present. Callers use this to decide
 * whether to advertise an og:image at all.
 */
function og_available(): bool
{
    static $ok = null;
    if ($ok !== null) {
        return $ok;
    }
    if (!function_exists('imagettftext') || !function_exists('imagepng')) {
        return $ok = false;
    }
    foreach (['regular', 'bold', 'mono'] as $style) {
        if (!is_readable(og_font($style))) {
            return $ok = false;
        }
    }
    return $ok = true;
}

// ---- Text measuring / drawing ----------------------------------------------

/** Rendered width of a string, in pixels. */
function og_text_width(string $text, string $font, float $size): int
{
    if ($text === '') {
        return 0;
    }
    $box = imagettfbbox($size, 0, $font, $text);
    if ($box === false) {
        return 0;
    }
    return (int) ceil(max($box[2], $box[4]) - min($box[0], $box[6]));
}

/**
 * Draw a string with its left edge at $x and its baseline at $y.
 *
 * @param \GdImage|resource $im
 * @param int               $color
 */
function og_text($im, string $text, string $font, float $size, int $x, int $y, $color): void
{
    if ($text !== '') {
        imagettftext($im, $size, 0, $x, $y, $color, $font, $text);
    }
}

/** Clip a string to $maxWidth, appending an ellipsis when it does not fit. */
function og_ellipsize(string $text, string $font, float $size, int $maxWidth): string
{
    if (og_text_width($text, $font, $size) <= $maxWidth) {
        return $text;
    }
    $chars = preg_split('//u', $text, -1, PREG_SPLIT_NO_EMPTY) ?: [];
    $out   = '';
    foreach ($chars as $char) {
        if (og_text_width($out . $char . '…', $font, $size) > $maxWidth) {
            break;
        }
        $out .= $char;
    }
    return rtrim($out) . '…';
}

/**
 * Word-wrap $text to at most $maxLines lines of $maxWidth pixels. Overflow is
 * folded onto the last line and clipped with an ellipsis, so the card never
 * silently drops the fact that there was more text.
 */
function og_wrap(string $text, string $font, float $size, int $maxWidth, int $maxLines): array
{
    $text = trim((string) preg_replace('/\s+/u', ' ', $text));
    if ($text === '' || $maxLines < 1) {
        return [];
    }

    $words = explode(' ', $text);
    $lines = [];
    $line  = '';

    foreach ($words as $i => $word) {
        $try = $line === '' ? $word : $line . ' ' . $word;
        if ($line !== '' && og_text_width($try, $font, $size) > $maxWidth) {
            $lines[] = $line;
            if (count($lines) === $maxLines) {
                // Out of room: tack the remainder onto the last line so the
                // ellipsis pass below shows that it was cut short.
                $lines[$maxLines - 1] .= ' ' . implode(' ', array_slice($words, $i));
                break;
            }
            $line = $word;
        } else {
            $line = $try;
        }
    }
    if (count($lines) < $maxLines && $line !== '') {
        $lines[] = $line;
    }

    // Also catches single words longer than the line box.
    return array_map(
        static fn(string $l): string => og_ellipsize($l, $font, $size, $maxWidth),
        $lines
    );
}

/**
 * Allocate a colour from an [r, g, b] triple.
 *
 * @param \GdImage|resource $im
 */
function og_color($im, array $rgb)
{
    return imagecolorallocate($im, $rgb[0], $rgb[1], $rgb[2]);
}

/**
 * Allocate a colour from a "#rrggbb" string.
 *
 * @param \GdImage|resource $im
 */
function og_hex_color($im, string $hex)
{
    $hex = ltrim($hex, '#');
    return imagecolorallocate(
        $im,
        (int) hexdec(substr($hex, 0, 2)),
        (int) hexdec(substr($hex, 2, 2)),
        (int) hexdec(substr($hex, 4, 2))
    );
}

/**
 * Filled rectangle with rounded corners.
 *
 * @param \GdImage|resource $im
 * @param int               $color
 */
function og_rounded_rect($im, int $x1, int $y1, int $x2, int $y2, int $r, $color): void
{
    imagefilledrectangle($im, $x1 + $r, $y1, $x2 - $r, $y2, $color);
    imagefilledrectangle($im, $x1, $y1 + $r, $x2, $y2 - $r, $color);
    $d = $r * 2;
    imagefilledellipse($im, $x1 + $r, $y1 + $r, $d, $d, $color);
    imagefilledellipse($im, $x2 - $r, $y1 + $r, $d, $d, $color);
    imagefilledellipse($im, $x1 + $r, $y2 - $r, $d, $d, $color);
    imagefilledellipse($im, $x2 - $r, $y2 - $r, $d, $d, $color);
}

// ---- Card rendering ---------------------------------------------------------

/**
 * Draw a card and return the GD image. Takes a plain array so it stays
 * independent of the database:
 *
 *   brand       string  small monospace line at the top
 *   title       string  repository name (up to 2 lines)
 *   subtitle    string  e.g. "/my-repo"
 *   description string  optional, up to 3 lines
 *   language    string  optional, shown as a badge
 *   stats       array   short strings joined with separators along the bottom
 */
function og_render_card(array $card)
{
    $im = imagecreatetruecolor(OG_WIDTH, OG_HEIGHT);
    imagealphablending($im, true);

    $bg     = og_color($im, OG_COLORS['bg']);
    $panel  = og_color($im, OG_COLORS['panel']);
    $fg     = og_color($im, OG_COLORS['fg']);
    $muted  = og_color($im, OG_COLORS['muted']);
    $body   = og_color($im, OG_COLORS['body']);
    $border = og_color($im, OG_COLORS['border']);
    $accent = og_color($im, OG_COLORS['accent']);

    imagefilledrectangle($im, 0, 0, OG_WIDTH, OG_HEIGHT, $bg);
    imagefilledrectangle($im, 0, 0, OG_WIDTH, 11, $accent);

    $regular = og_font('regular');
    $bold    = og_font('bold');
    $mono    = og_font('mono');
    $maxW    = OG_WIDTH - (OG_PAD * 2);

    // Brand line.
    $y = 118;
    og_text($im, og_ellipsize((string) ($card['brand'] ?? ''), $mono, 22, $maxW), $mono, 22, OG_PAD, $y, $muted);

    // Title — up to two lines, shrinking once if a long name would wrap.
    $titleSize = 58;
    $title = trim((string) ($card['title'] ?? ''));
    if (og_text_width($title, $bold, $titleSize) > $maxW * 2) {
        $titleSize = 46;
    }
    $y += 96;
    foreach (og_wrap($title, $bold, $titleSize, $maxW, 2) as $line) {
        og_text($im, $line, $bold, $titleSize, OG_PAD, $y, $fg);
        $y += (int) round($titleSize * 1.32);
    }

    // Slug.
    $subtitle = trim((string) ($card['subtitle'] ?? ''));
    if ($subtitle !== '') {
        $y += 4;
        og_text($im, og_ellipsize($subtitle, $mono, 24, $maxW), $mono, 24, OG_PAD, $y, $accent);
        $y += 34;
    }

    $footerY = OG_HEIGHT - 118;

    // Description — as many lines as clear the footer rule, up to three. A
    // title that wrapped to two lines eats into the space available here.
    $description = trim((string) ($card['description'] ?? ''));
    if ($description !== '') {
        $y += 30;
        $room = min(3, intdiv(max(0, $footerY - 16 - $y), 44) + 1);
        foreach (og_wrap($description, $regular, 27, $maxW, $room) as $line) {
            og_text($im, $line, $regular, 27, OG_PAD, $y, $body);
            $y += 44;
        }
    }

    // Footer rule + stat row — omitted entirely when there is nothing to show.
    $language = trim((string) ($card['language'] ?? ''));
    $stats    = array_values(array_filter(array_map('strval', (array) ($card['stats'] ?? []))));
    if ($language === '' && !$stats) {
        return $im;
    }
    imagefilledrectangle($im, OG_PAD, $footerY, OG_WIDTH - OG_PAD, $footerY, $border);

    $x        = OG_PAD;
    $baseline = $footerY + 62;

    if ($language !== '') {
        $badgeW = og_text_width($language, $regular, 22) + 66;
        og_rounded_rect($im, $x, $baseline - 30, $x + $badgeW, $baseline + 12, 21, $panel);
        $dot = og_hex_color($im, OG_LANG_COLORS[$language] ?? '#8B949E');
        imagefilledellipse($im, $x + 26, $baseline - 9, 16, 16, $dot);
        og_text($im, $language, $regular, 22, $x + 44, $baseline, $body);
        $x += $badgeW + 28;
    }

    foreach ($stats as $i => $stat) {
        if ($i > 0) {
            og_text($im, '·', $regular, 22, $x, $baseline, $border);
            $x += 24;
        }
        og_text($im, $stat, $regular, 22, $x, $baseline, $muted);
        $x += og_text_width($stat, $regular, 22) + 20;
    }

    return $im;
}

// ---- Repository cards -------------------------------------------------------

/**
 * Cache-busting digest of everything the card displays. Any change here yields
 * a new og:image URL, which is what forces crawlers to re-fetch.
 */
function repo_og_hash(array $repo): string
{
    $files = function_exists('get_files_by_repo') && !empty($repo['id'])
        ? get_files_by_repo((int) $repo['id'])
        : [];

    $key = implode('|', [
        (string) ($repo['slug'] ?? ''),
        (string) ($repo['name'] ?? ''),
        (string) ($repo['description'] ?? ''),
        repo_language_display($repo),
        (string) count($files),
        (string) array_sum(array_map(static fn($f) => (int) ($f['filesize'] ?? 0), $files)),
    ]);

    return substr(md5($key), 0, 12);
}

/** Absolute og:image URL for a repository, or null when GD cannot render. */
function repo_og_url(array $repo): ?string
{
    if (!og_available() || empty($repo['slug'])) {
        return null;
    }
    return abs_url('/' . $repo['slug'] . '/og-' . repo_og_hash($repo) . '.png');
}

/** Card fields for a repository row. */
function repo_og_card(array $repo): array
{
    $files = function_exists('get_files_by_repo') && !empty($repo['id'])
        ? get_files_by_repo((int) $repo['id'])
        : [];

    $count = count($files);
    $bytes = array_sum(array_map(static fn($f) => (int) ($f['filesize'] ?? 0), $files));

    $stats = [$count . ' ' . ($count === 1 ? 'file' : 'files')];
    if ($bytes > 0) {
        $stats[] = human_size($bytes);
    }
    $created = strtotime((string) ($repo['created_at'] ?? ''));
    if ($created) {
        $stats[] = date('M Y', $created);
    }

    return [
        'brand'       => "jefftml's </> code",
        'title'       => (string) ($repo['name'] ?? ''),
        'subtitle'    => '/' . (string) ($repo['slug'] ?? ''),
        'description' => (string) ($repo['description'] ?? ''),
        'language'    => repo_language_display($repo),
        'stats'       => $stats,
    ];
}

/** Absolute path of the on-disk cache entry for a rendered card. */
function repo_og_cache_path(string $slug, string $hash): string
{
    return UPLOAD_DIR . '/og/' . $slug . '-' . $hash . '.png';
}

/**
 * Render (or reuse) the cached PNG for a repository and return its path, or
 * null if it could not be written.
 */
function repo_og_file(array $repo, string $hash): ?string
{
    $path = repo_og_cache_path((string) $repo['slug'], $hash);
    if (is_readable($path) && filesize($path) > 0) {
        return $path;
    }

    $dir = dirname($path);
    if (!is_dir($dir) && !@mkdir($dir, 0775, true) && !is_dir($dir)) {
        return null;
    }

    $im = og_render_card(repo_og_card($repo));
    // Write to a temporary name first so a concurrent request never serves a
    // half-written PNG.
    $tmp = $path . '.' . getmypid() . '.tmp';
    $ok  = imagepng($im, $tmp, 6);
    unset($im);
    if (!$ok || !@rename($tmp, $path)) {
        @unlink($tmp);
        return null;
    }

    // Drop cards rendered from older states of this repository.
    foreach (glob($dir . '/' . $repo['slug'] . '-*.png') ?: [] as $old) {
        if ($old !== $path) {
            @unlink($old);
        }
    }

    return $path;
}

/**
 * Router entry point for /{slug}/og[-{hash}].png. Serves the current card
 * whatever hash was asked for — the hash is a cache key, not a lookup key —
 * but only promises immutability when it matches the current state.
 */
function render_repo_og(string $slug, string $requestedHash): void
{
    $repo = get_repository_by_slug($slug);
    if (!$repo || !og_available()) {
        og_error(404);
    }

    $hash = repo_og_hash($repo);
    $path = repo_og_file($repo, $hash);
    if ($path === null) {
        og_error(500);
    }

    $fresh = ($requestedHash === $hash);
    $etag  = '"' . $hash . '"';

    header('Content-Type: image/png');
    header('ETag: ' . $etag);
    header($fresh
        ? 'Cache-Control: public, max-age=31536000, immutable'
        : 'Cache-Control: public, max-age=300');

    if (trim((string) ($_SERVER['HTTP_IF_NONE_MATCH'] ?? '')) === $etag) {
        http_response_code(304);
        return;
    }

    header('Content-Length: ' . filesize($path));
    readfile($path);
}

/** Bail out of the image endpoint without emitting HTML chrome. */
function og_error(int $code): void
{
    http_response_code($code);
    header('Content-Type: text/plain; charset=utf-8');
    header('Cache-Control: no-store');
    echo $code === 404 ? "Not found\n" : "Unable to render the social card\n";
    exit;
}