<?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;

}