math_cms/app/Services/MathFormulaProcessor.php

<?php

namespace App\Services;

class MathFormulaProcessor
{
    /**
     * 处理数学公式，确保有正确的 LaTeX 标记
     * 
     * 策略：
     * 1. 清理 HTML 标签和实体
     * 2. 规范化反斜杠（处理多重转义）
     * 3. 修复丢失反斜杠的常见 LaTeX 命令
     * 4. 确保公式被正确的定界符包裹
     */
    public static function processFormulas(string $content): string
    {
        if (empty($content)) {
            return $content;
        }

        // 1. 基础清理
        // 递归解码 HTML 实体
        $decoded = html_entity_decode($content, ENT_QUOTES, 'UTF-8');
        while ($decoded !== $content) {
            $content = $decoded;
            $decoded = html_entity_decode($content, ENT_QUOTES, 'UTF-8');
        }
        
        $content = trim($content);

        // 2. 规范化反斜杠
        $content = preg_replace('/\\\\+([a-zA-Z])/', '\\\\$1', $content);

        // 3. 修复常见 LaTeX 命令
        $commands = [
            'sqrt', 'frac', 'times', 'div', 'pm', 'cdot', 
            'sin', 'cos', 'tan', 'log', 'ln', 'lim',
            'alpha', 'beta', 'gamma', 'theta', 'pi', 'sigma', 'omega', 'Delta',
            'leq', 'geq', 'neq', 'approx', 'infty',
            'sum', 'prod', 'int', 'partial', 'nabla'
        ];
        
        $pattern = '/(?<!\\\\)\b(' . implode('|', $commands) . ')\b/';
        $content = preg_replace($pattern, '\\\\$1', $content);

        // 4. 处理定界符
        // 如果内容已经是完整的公式（被 $ 或 $$ 包裹），则保持原样
        if (self::hasDelimiters($content)) {
            $content = self::cleanInsideDelimiters($content);
            return $content;
        }

        // 5. 智能包装 (统一处理混合内容)
        // 无论是纯文本还是富文本，都使用智能识别来包裹公式
        // 这能同时处理:
        // - "已知函数 f(x) = ..." (未包裹的混合内容)
        // - "验证：$2x...$" (部分包裹的混合内容)
        // - "4x^2 - 25y^2" (未包裹的纯公式)
        
        // 先清理已有的定界符内部
        $content = self::cleanInsideDelimiters($content);
        // 然后智能包裹剩余的数学部分
        $content = self::smartWrapMixedContent($content);

        return $content;
    }

    /**
     * 清理定界符内部的 HTML 标签
     */
    private static function cleanInsideDelimiters(string $content): string
    {
        // 定义定界符模式
        $patterns = [
            '/\$\$([\s\S]*?)\$\$/', // $$...$$
            '/\$([\s\S]*?)\$/',     // $...$
            '/\\\\\(([\s\S]*?)\\\\\)/', // \(...\)
            '/\\\\\[([\s\S]*?)\\\\\]/'  // \[...\]
        ];

        foreach ($patterns as $pattern) {
            $content = preg_replace_callback($pattern, function ($matches) {
                // $matches[0] 是完整匹配 (如 $...$)
                // $matches[1] 是内部内容
                
                // 清理内部的 HTML 标签
                $cleanContent = strip_tags($matches[1]);
                // 解码实体
                $cleanContent = html_entity_decode($cleanContent, ENT_QUOTES, 'UTF-8');
                $cleanContent = trim($cleanContent);
                
                // 重建定界符 (保持原样)
                // 注意：我们需要根据原来的定界符类型来重建
                // 这里简单起见，我们直接用匹配到的完整字符串的定界符部分
                // 但 preg_replace_callback 不容易直接获取定界符，所以我们硬编码
                
                if (str_starts_with($matches[0], '$$')) return '$$' . $cleanContent . '$$';
                if (str_starts_with($matches[0], '$')) return '$' . $cleanContent . '$';
                if (str_starts_with($matches[0], '\[')) return '\[' . $cleanContent . '\]';
                if (str_starts_with($matches[0], '\(')) return '\(' . $cleanContent . '\)';
                
                // 默认回退 (不应该发生)
                return $matches[0];
            }, $content);
        }

        return $content;
    }

    /**
     * 智能识别并包裹富文本中的数学公式
     */
    private static function smartWrapMixedContent(string $content): string
    {
        // 正则策略：匹配 HTML 标签 OR 数学公式候选
        // 捕获组 1: HTML 标签 (忽略)
        // 捕获组 2: 已有的定界符 (忽略)
        // 捕获组 3: 数学公式 (处理)
        
        $tagPattern = '<[^>]+>';
        
        // 匹配已有的定界符
        $existingDelimiterPattern = '(?:\$\$[\s\S]*?\$\$|\$[\s\S]*?\$|\\\\\([\s\S]*?\\\\\)|\\\\\[[\s\S]*?\\\\\])';
        
        // 数学公式特征：
        // 1. 函数定义: f(x) = ...
        // 2. 等式/不等式: ... = ..., ... > ..., ... < ...
        // 3. 包含 LaTeX 命令: \sqrt, \frac 等
        // 4. 包含上标/下标: x^2, a_n
        
        // 匹配函数定义或等式 (例如 f(x) = 2x^2 + 1)
        // 必须包含 = 或 > 或 <，且周围有类数学字符
        $equationPattern = '(?<![\w\\\\])(?:[a-zA-Z]\([a-zA-Z0-9,]+\)|[a-zA-Z0-9\^_\{\}]+)\s*[=<>]\s*[\w\s\+\-\*\/\^\.\(\)\{\}\\\\]+(?=\s|$|<|[.,;])';
        
        // 匹配显式 LaTeX 命令 (例如 \sqrt{...})
        $latexPattern = '\\\\[a-zA-Z]+(?:\{[^\}]*\})?';
        
        // 匹配简单的代数项 (例如 x^2, a_n) - 需谨慎，避免匹配普通单词
        $algebraPattern = '(?<![\w\\\\])[a-zA-Z0-9]+\^[\w\{]+';

        // 匹配多项式/复杂表达式 (例如 4x^2 - 25y^2, 2x \times 2 + ...)
        // 特征：包含变量、数字、运算符 (+, -, *, /)、LaTeX命令、上标/下标
        // 必须包含至少一个运算符，且长度适中
        $polynomialPattern = '(?<![\w\\\\])(?:[a-zA-Z0-9\.]+(?:[\^_\{\}][a-zA-Z0-9\.\{\}]+)?|\\\\[a-zA-Z]+(?:\{[^\}]*\})?)(?:\s*[\+\-\*\/]\s*(?:[a-zA-Z0-9\.]+(?:[\^_\{\}][a-zA-Z0-9\.\{\}]+)?|\\\\[a-zA-Z]+(?:\{[^\}]*\})?))+';

        $pattern = "/($tagPattern)|($existingDelimiterPattern)|($equationPattern|$polynomialPattern|$latexPattern|$algebraPattern)/u";

        return preg_replace_callback($pattern, function ($matches) {
            // 如果是 HTML 标签 (组1)，原样返回
            if (!empty($matches[1])) {
                return $matches[1];
            }
            
            // 如果是已有的定界符 (组2)，原样返回
            if (!empty($matches[2])) {
                return $matches[2];
            }
            
            // 如果是数学公式 (组3)
            if (!empty($matches[3])) {
                $math = $matches[3];
                // 再次检查是否已经被包裹 (虽然外层逻辑应该处理了，但为了安全)
                if (str_contains($math, '$')) {
                    return $math;
                }
                // 排除纯数字或普通单词误判
                if (preg_match('/^[a-zA-Z0-9\s]+$/', $math)) {
                    return $math;
                }
                return '$' . $math . '$';
            }
            
            return $matches[0];
        }, $content);
    }


    /**
     * 检查是否已有定界符
     */
    private static function hasDelimiters(string $content): bool
    {
        $content = trim($content);
        // 检查 $$...$$
        if (str_starts_with($content, '$$') && str_ends_with($content, '$$')) {
            return true;
        }
        // 检查 $...$
        if (str_starts_with($content, '$') && str_ends_with($content, '$')) {
            return true;
        }
        // 检查 \[...\]
        if (str_starts_with($content, '\\[') && str_ends_with($content, '\\]')) {
            return true;
        }
        // 检查 \(...\)
        if (str_starts_with($content, '\\(') && str_ends_with($content, '\\)')) {
            return true;
        }
        return false;
    }

    /**
     * 检测数学特征
     */
    private static function containsMathFeatures(string $content): bool
    {
        // 1. 检查是否有 LaTeX 命令
        if (strpos($content, '\\') !== false) {
            return true;
        }

        // 2. 检查数学符号
        $symbols = ['+', '-', '*', '/', '=', '<', '>', '^', '_', '{', '}'];
        foreach ($symbols as $symbol) {
            if (strpos($content, $symbol) !== false) {
                // 排除普通文本中的符号（如连字符），这里做一个简单的宽容判断
                // 如果有数字紧随其后，或者是特定组合
                return true;
            }
        }

        // 3. 检查数字和字母的组合 (如 2x, x^2)
        if (preg_match('/[a-zA-Z]\d|\d[a-zA-Z]/', $content)) {
            return true;
        }

        return false;
    }

    /**
     * 批量处理
     */
    public static function processArray(array $data, array $fieldsToProcess): array
    {
        foreach ($data as $key => &$value) {
            if (in_array($key, $fieldsToProcess) && is_string($value)) {
                $value = self::processFormulas($value);
            } elseif (is_array($value)) {
                $value = self::processArray($value, $fieldsToProcess);
            }
        }
        return $data;
    }

    /**
     * 处理题目数据
     */
    public static function processQuestionData(array $question): array
    {
        $fieldsToProcess = [
            'stem', 'content', 'question_text', 'answer', 
            'correct_answer', 'student_answer', 'explanation', 
            'solution', 'question_content'
        ];
        return self::processArray($question, $fieldsToProcess);
    }
}