<?php
/**
 * Small, regex-based syntax highlighter. Deliberately "basic" — it is not a
 * full lexer. Keyword-based languages (php, js, python, java, c, cpp, go, ruby,
 * sql, bash) share one master-regex builder; the structural formats css, html,
 * json and markdown get tailored regexes. Everything else falls back to plain
 * (escape-only) output.
 *
 * The source is scanned with a single master regex whose alternatives are named
 * groups (comment / string / number / variable / keyword / function / tag /
 * attribute / selector). Each character is consumed once, so tokens are never
 * re-processed and output is always HTML-escaped exactly once.
 *
 * Note: the file view highlights one line at a time, so patterns are kept
 * single-line friendly (block comments only colour within a line).
 */

/** Keyword lists per language. */
function highlight_keywords(string $lang): array
{
    switch ($lang) {
        case 'php':
            return ['abstract','and','array','as','break','callable','case','catch',
                'class','clone','const','continue','declare','default','do','echo','else',
                'elseif','empty','enddeclare','endfor','endforeach','endif','endswitch',
                'endwhile','enum','extends','final','finally','fn','for','foreach','function',
                'global','goto','if','implements','include','include_once','instanceof',
                'insteadof','interface','isset','list','match','namespace','new','or','print',
                'private','protected','public','readonly','require','require_once','return',
                'static','switch','throw','trait','try','unset','use','var','while','xor',
                'yield','true','false','null'];
        case 'javascript':
            return ['await','async','break','case','catch','class','const','continue',
                'debugger','default','delete','do','else','export','extends','finally','for',
                'function','if','import','in','instanceof','let','new','of','return','super',
                'switch','this','throw','try','typeof','var','void','while','with','yield',
                'true','false','null','undefined'];
        case 'python':
            return ['and','as','assert','async','await','break','class','continue','def',
                'del','elif','else','except','finally','for','from','global','if','import',
                'in','is','lambda','nonlocal','not','or','pass','raise','return','try','while',
                'with','yield','True','False','None','self'];
        case 'java':
            return ['abstract','assert','boolean','break','byte','case','catch','char',
                'class','const','continue','default','do','double','else','enum','extends',
                'final','finally','float','for','goto','if','implements','import','instanceof',
                'int','interface','long','native','new','package','private','protected',
                'public','return','short','static','strictfp','super','switch','synchronized',
                'this','throw','throws','transient','try','void','volatile','while','var',
                'true','false','null'];
        case 'c':
            return ['auto','break','case','char','const','continue','default','do','double',
                'else','enum','extern','float','for','goto','if','inline','int','long',
                'register','restrict','return','short','signed','sizeof','static','struct',
                'switch','typedef','union','unsigned','void','volatile','while','bool','true',
                'false','NULL'];
        case 'cpp':
            return ['alignas','auto','bool','break','case','catch','char','class','const',
                'constexpr','continue','default','delete','do','double','else','enum','explicit',
                'extern','false','float','for','friend','goto','if','inline','int','long',
                'namespace','new','nullptr','operator','override','private','protected','public',
                'return','short','signed','sizeof','static','struct','switch','template','this',
                'throw','true','try','typedef','typename','union','unsigned','using','virtual',
                'void','volatile','while'];
        case 'go':
            return ['break','case','chan','const','continue','default','defer','else',
                'fallthrough','for','func','go','goto','if','import','interface','map','package',
                'range','return','select','struct','switch','type','var','true','false','nil',
                'iota','string','int','int64','float64','bool','byte','rune','error'];
        case 'ruby':
            return ['def','end','if','elsif','else','unless','while','until','for','in','do',
                'begin','rescue','ensure','raise','return','yield','class','module','self','nil',
                'true','false','and','or','not','then','case','when','break','next','redo',
                'retry','super','require','require_relative','attr_accessor','attr_reader',
                'attr_writer','puts','new'];
        case 'sql':
            return ['select','from','where','insert','into','values','update','set','delete',
                'create','alter','drop','table','database','view','index','join','left','right',
                'inner','outer','full','cross','on','as','and','or','not','null','is','in',
                'between','like','order','by','group','having','limit','offset','distinct',
                'union','all','asc','desc','primary','key','foreign','references','unique',
                'default','constraint','auto_increment','int','integer','varchar','text','char',
                'datetime','timestamp','date','boolean','count','sum','avg','min','max','case',
                'when','then','else','end','if','exists','begin','commit','rollback'];
        case 'bash':
            return ['if','then','else','elif','fi','for','while','until','do','done','case',
                'esac','function','in','select','return','break','continue','local','export',
                'readonly','declare','unset','echo','printf','cd','exit','test','true','false',
                'source','alias'];
        default:
            return [];
    }
}

/** Comment pattern for a keyword-based language. */
function highlight_comment(string $lang): string
{
    switch ($lang) {
        case 'python':
        case 'ruby':
        case 'bash':
            return '#[^\n]*';
        case 'sql':
            return '--[^\n]*|\/\*[\s\S]*?\*\/';
        default: // php, js, java, c, cpp, go
            return '\/\/[^\n]*|\/\*[\s\S]*?\*\/';
    }
}

/** Build the master regex for a language, or null for the plain fallback. */
function highlight_regex(string $lang): ?string
{
    // --- Structural formats with tailored token sets. ---
    if ($lang === 'css') {
        return '/(?<com>\/\*[\s\S]*?\*\/)'
            . '|(?<str>"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')'
            . '|(?<kw>@[\w-]+|!important)'
            . '|(?<fn>[\w-]+(?=\s*\())'
            . '|(?<attr>[A-Za-z-]+(?=\s*:))'
            . '|(?<num>#[0-9A-Fa-f]{3,8}\b|\b\d+(?:\.\d+)?(?:px|em|rem|ex|ch|vw|vh|vmin|vmax|%|pt|cm|mm|in|deg|s|ms|fr)?\b)'
            . '|(?<sel>[.#][A-Za-z_][\w-]*|::?[A-Za-z-]+)/';
    }
    if ($lang === 'html') {
        return '/(?<com><!--[\s\S]*?-->)'
            . '|(?<str>"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')'
            . '|(?<tag><\/?[A-Za-z][\w:-]*|\/?>)'
            . '|(?<attr>\s[A-Za-z_:][\w:.-]*(?=\s*=))/';
    }
    if ($lang === 'json') {
        return '/(?<attr>"(?:\\\\.|[^"\\\\])*"(?=\s*:))'
            . '|(?<str>"(?:\\\\.|[^"\\\\])*")'
            . '|(?<kw>\b(?:true|false|null)\b)'
            . '|(?<num>-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b)/';
    }
    if ($lang === 'markdown') {
        return '/(?<tag>^\s{0,3}#{1,6}\s.*$|^\s*[-*+]\s|^\s*>\s)'
            . '|(?<str>`[^`]+`)'
            . '|(?<kw>\*\*[^*]+\*\*|__[^_]+__)'
            . '|(?<fn>\[[^\]]+\]\([^)]+\))/m';
    }

    // --- Keyword-based languages share one builder. ---
    $keywords = highlight_keywords($lang);
    if (!$keywords) {
        return null;
    }

    $comment = highlight_comment($lang);

    // String styles (single, double; backticks for js/bash).
    $string = '"(?:\\\\.|[^"\\\\])*"' . '|' . "'(?:\\\\.|[^'\\\\])*'";
    if ($lang === 'javascript' || $lang === 'bash') {
        $string .= '|`(?:\\\\.|[^`\\\\])*`';
    }

    $number = '\b\d+(?:\.\d+)?\b';
    if ($lang === 'php' || $lang === 'bash') {
        $variable = '\$\{[^}]+\}|\$[A-Za-z_]\w*';
    } else {
        $variable = '(?!)'; // never matches
    }
    $kw   = '\b(?:' . implode('|', array_map('preg_quote', $keywords)) . ')\b';
    $func = '[A-Za-z_]\w*(?=\s*\()';

    $flags = ($lang === 'sql') ? 'i' : '';

    return '/(?<com>' . $comment . ')'
        . '|(?<str>' . $string . ')'
        . '|(?<num>' . $number . ')'
        . '|(?<var>' . $variable . ')'
        . '|(?<kw>' . $kw . ')'
        . '|(?<fn>' . $func . ')/' . $flags;
}

/**
 * Return HTML for the given source code with token <span>s. The result is safe
 * to embed directly (all literal text is HTML-escaped).
 */
function highlight_code(string $code, string $lang): string
{
    $lang  = strtolower($lang);
    $regex = highlight_regex($lang);

    // Unknown language: escape and return as-is.
    if ($regex === null) {
        return htmlspecialchars($code, ENT_QUOTES, 'UTF-8');
    }

    // Every group name that may appear in any language's regex.
    $groups = ['com', 'str', 'num', 'var', 'kw', 'fn', 'tag', 'attr', 'sel'];
    $out    = '';
    $offset = 0;

    if (preg_match_all($regex, $code, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) {
        foreach ($matches as $m) {
            $full = $m[0][0];
            $pos  = $m[0][1];

            if ($pos > $offset) {
                $out .= htmlspecialchars(substr($code, $offset, $pos - $offset), ENT_QUOTES, 'UTF-8');
            }

            $class = null;
            foreach ($groups as $g) {
                if (isset($m[$g]) && $m[$g][1] !== -1 && $m[$g][0] !== '') {
                    $class = $g;
                    break;
                }
            }

            // Preserve any leading whitespace captured by a token (e.g. HTML
            // attributes, markdown list markers) outside the coloured span.
            $lead = '';
            if ($class !== null && ($class === 'attr' || $class === 'tag') && preg_match('/^\s+/', $full, $ws)) {
                $lead = $ws[0];
                $full = substr($full, strlen($lead));
            }

            $esc = htmlspecialchars($full, ENT_QUOTES, 'UTF-8');
            $out .= $lead . ($class ? '<span class="tok-' . $class . '">' . $esc . '</span>' : $esc);

            $offset = $pos + strlen($m[0][0]);
        }
    }

    if ($offset < strlen($code)) {
        $out .= htmlspecialchars(substr($code, $offset), ENT_QUOTES, 'UTF-8');
    }

    return $out;
}