<?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']));

}