<?php
/**
 * Small shared view helpers used across public and admin pages.
 */

require_once __DIR__ . '/../config.php';

/** HTML-escape for output. */
function e($value): string
{
    return htmlspecialchars((string) $value, ENT_QUOTES, 'UTF-8');
}

/** Build an app URL respecting BASE_PATH. Pass a leading-slash path. */
function url(string $path = '/'): string
{
    if ($path === '' || $path[0] !== '/') {
        $path = '/' . $path;
    }
    return BASE_PATH . $path;
}

/**
 * Scheme + host the site is served from, with no trailing slash. Prefers the
 * SITE_URL constant; the Host header is only a fallback because a client can
 * put anything in it.
 */
function site_origin(): string
{
    if (defined('SITE_URL') && SITE_URL !== '') {
        return rtrim(SITE_URL, '/');
    }
    $https = (($_SERVER['HTTPS'] ?? 'off') !== 'off')
        || (($_SERVER['HTTP_X_FORWARDED_PROTO'] ?? '') === 'https')
        || (($_SERVER['SERVER_PORT'] ?? '') === '443');
    $host = (string) ($_SERVER['HTTP_HOST'] ?? 'localhost');
    $host = preg_replace('/[^A-Za-z0-9.\-:\[\]]/', '', $host) ?: 'localhost';
    return ($https ? 'https' : 'http') . '://' . $host;
}

/**
 * Absolute URL for a path. Social crawlers reject relative og:image / og:url
 * values, so share metadata must use this rather than url().
 */
function abs_url(string $path = '/'): string
{
    return site_origin() . url($path);
}

/** Normalise a user-supplied slug to a safe form: lowercase, [a-z0-9-]. */
function normalize_slug(string $raw): string
{
    $slug = strtolower(trim($raw));
    $slug = preg_replace('/[^a-z0-9]+/', '-', $slug);
    return trim($slug, '-');
}

/** True if the slug is well-formed for routing/storage. */
function valid_slug(string $slug): bool
{
    return (bool) preg_match('/^[a-z0-9][a-z0-9-]*$/', $slug);
}

/** Sanitise an uploaded filename to a safe basename. */
function safe_filename(string $name): string
{
    $name = basename($name);
    // Keep letters, numbers, dot, dash, underscore; collapse anything else.
    $name = preg_replace('/[^A-Za-z0-9._-]+/', '_', $name);
    $name = ltrim($name, '.');            // no leading dots / hidden files
    return $name === '' ? 'file' : $name;
}

/**
 * Sanitise a relative upload path (folder upload) into a safe form like
 * "sub/dir/file.js". Each segment is cleaned with safe_filename(); empty, "."
 * and ".." segments are dropped so the result can never escape its repo folder.
 */
function safe_relpath(string $raw): string
{
    $raw   = str_replace('\\', '/', $raw);
    $clean = [];
    foreach (explode('/', $raw) as $segment) {
        $segment = trim($segment);
        if ($segment === '' || $segment === '.' || $segment === '..') {
            continue;
        }
        $clean[] = safe_filename($segment);
    }
    return implode('/', $clean);
}

/** Encode each path segment for a URL but keep the slashes between them. */
function encode_path(string $path): string
{
    return implode('/', array_map('rawurlencode', explode('/', $path)));
}

/** Build a public blob URL, encoding each path segment but keeping slashes. */
function blob_url(string $slug, string $path): string
{
    return url('/' . $slug . '/blob/' . encode_path($path));
}

/** Build a folder (tree) URL. An empty path points at the repository root. */
function tree_url(string $slug, string $path = ''): string
{
    $path = trim($path, '/');
    return $path === '' ? url('/' . $slug) : url('/' . $slug . '/tree/' . encode_path($path));
}

/** Build a raw-file URL. Pass $download=true for an attachment (download) URL. */
function raw_url(string $slug, string $path, bool $download = false): string
{
    return url('/' . $slug . '/raw/' . encode_path($path)) . ($download ? '?dl=1' : '');
}

/** Build a URL that downloads the whole repository as a .zip archive. */
function archive_url(string $slug): string
{
    return url('/' . $slug . '/archive');
}

/** True if the filename looks like an image we can render in the browser. */
function is_image_file(string $filename): bool
{
    $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
    return in_array($ext, ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'bmp', 'ico', 'avif'], true);
}

/** True if the filename is an SVG (an image whose source is readable text). */
function is_svg_file(string $filename): bool
{
    return strtolower(pathinfo($filename, PATHINFO_EXTENSION)) === 'svg';
}

/** True if the filename is a 3D model / toolpath we can render in the browser. */
function is_model_file(string $filename): bool
{
    return model_format($filename) !== '';
}

/**
 * Normalised model-viewer format key for a filename, or '' if it is not a
 * model file. Fed to the client viewer as `data-format`.
 */
function model_format(string $filename): string
{
    $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
    $map = [
        'stl'   => 'stl',
        '3mf'   => '3mf',
        'obj'   => 'obj',
        'ply'   => 'ply',
        'gcode' => 'gcode', 'g' => 'gcode', 'gco' => 'gcode',
    ];
    return $map[$ext] ?? '';
}

/**
 * True if the model format is text-based (so a "Source" toggle can show it),
 * as opposed to a binary container we can only render.
 */
function is_text_model_format(string $format): bool
{
    return in_array($format, ['obj', 'ply', 'gcode'], true);
}

/** Best-effort MIME type from a filename extension, for serving raw files. */
function mime_for_filename(string $filename): string
{
    $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
    $map = [
        'png' => 'image/png', 'jpg' => 'image/jpeg', 'jpeg' => 'image/jpeg',
        'gif' => 'image/gif', 'svg' => 'image/svg+xml', 'webp' => 'image/webp',
        'bmp' => 'image/bmp', 'ico' => 'image/x-icon', 'avif' => 'image/avif',
        'pdf' => 'application/pdf', 'json' => 'application/json',
        'css' => 'text/css', 'html' => 'text/html', 'htm' => 'text/html',
        'js'  => 'text/javascript', 'txt' => 'text/plain', 'md' => 'text/plain',
        'xml' => 'application/xml',
        'stl' => 'model/stl', '3mf' => 'model/3mf',
        'obj' => 'text/plain', 'ply' => 'application/octet-stream',
        'gcode' => 'text/plain', 'g' => 'text/plain', 'gco' => 'text/plain',
    ];
    return $map[$ext] ?? 'text/plain';
}

/** Human-readable file size. */
function human_size(int $bytes): string
{
    $units = ['B', 'KB', 'MB', 'GB'];
    $i = 0;
    $n = (float) $bytes;
    while ($n >= 1024 && $i < count($units) - 1) {
        $n /= 1024;
        $i++;
    }
    return ($i === 0 ? $n : round($n, 1)) . ' ' . $units[$i];
}

/** Guess a highlight language from a filename extension. */
function language_from_filename(string $filename): string
{
    $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
    $map = [
        'php'  => 'php',
        'js'   => 'javascript', 'mjs' => 'javascript', 'jsx' => 'javascript',
        'ts'   => 'javascript', 'tsx' => 'javascript',
        'py'   => 'python',
        'java' => 'java',
        'css'  => 'css', 'scss' => 'css', 'less' => 'css',
        'html' => 'html', 'htm' => 'html', 'xml' => 'html', 'svg' => 'html',
        'vue'  => 'html',
        'json' => 'json',
        'c'    => 'c', 'h' => 'c',
        'cpp'  => 'cpp', 'cc' => 'cpp', 'cxx' => 'cpp', 'hpp' => 'cpp',
        'go'   => 'go',
        'rb'   => 'ruby',
        'sql'  => 'sql',
        'sh'   => 'bash', 'bash' => 'bash', 'zsh' => 'bash',
        'md'   => 'markdown', 'markdown' => 'markdown',
    ];
    return $map[$ext] ?? 'plain';
}

/**
 * Display language for a single file when counting a repository's languages,
 * or '' when the file should not count toward detection. Documentation
 * (.md/.txt), LICENSE/COPYING files and images are ignored; only files whose
 * extension maps to a known programming/markup language are counted.
 */
function code_language_label(string $filename): string
{
    $base = strtolower(basename($filename));
    // Ignore licence/readme/notice style files regardless of extension.
    if (preg_match('/^(license|licence|copying|notice|readme|changelog|authors|contributors)(\.|$)/', $base)) {
        return '';
    }
    if (is_image_file($filename)) {
        return '';
    }
    $ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
    $map = [
        'php'  => 'PHP', 'phtml' => 'PHP',
        'js'   => 'JavaScript', 'mjs' => 'JavaScript', 'cjs' => 'JavaScript', 'jsx' => 'JavaScript',
        'ts'   => 'TypeScript', 'tsx' => 'TypeScript',
        'py'   => 'Python',
        'java' => 'Java',
        'css'  => 'CSS', 'scss' => 'SCSS', 'sass' => 'Sass', 'less' => 'Less',
        'html' => 'HTML', 'htm' => 'HTML',
        'vue'  => 'Vue', 'svelte' => 'Svelte',
        'json' => 'JSON',
        'c'    => 'C', 'h' => 'C',
        'cpp'  => 'C++', 'cc' => 'C++', 'cxx' => 'C++', 'hpp' => 'C++', 'hh' => 'C++',
        'cs'   => 'C#',
        'go'   => 'Go',
        'rb'   => 'Ruby',
        'rs'   => 'Rust',
        'swift'=> 'Swift',
        'kt'   => 'Kotlin', 'kts' => 'Kotlin',
        'sql'  => 'SQL',
        'sh'   => 'Shell', 'bash' => 'Shell', 'zsh' => 'Shell',
        'xml'  => 'XML',
        'yml'  => 'YAML', 'yaml' => 'YAML',
        'toml' => 'TOML',
    ];
    return $map[$ext] ?? '';
}

/**
 * Count code files per display language in a list of file rows (or filenames),
 * ordered most-common first. Non-code files are skipped (see code_language_label).
 */
function language_breakdown(array $files): array
{
    $counts = [];
    foreach ($files as $f) {
        $name = is_array($f) ? (string) ($f['filename'] ?? '') : (string) $f;
        $lang = code_language_label($name);
        if ($lang === '') {
            continue;
        }
        $counts[$lang] = ($counts[$lang] ?? 0) + 1;
    }
    arsort($counts);
    return $counts;
}

/** The dominant language of a file list, or '' if no code files are present. */
function detect_language(array $files): string
{
    $counts = language_breakdown($files);
    return $counts ? (string) array_key_first($counts) : '';
}

/**
 * The language to show for a repository: its manual override when set,
 * otherwise the language auto-detected from its files. Returns '' if neither
 * is available.
 */
function repo_language_display(array $repo): string
{
    $manual = trim((string) ($repo['language'] ?? ''));
    if ($manual !== '') {
        return $manual;
    }
    if (!function_exists('get_files_by_repo') || empty($repo['id'])) {
        return '';
    }
    return detect_language(get_files_by_repo((int) $repo['id']));
}