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 = self::fixCorruptedFormulas($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. 规范化 LaTeX 命令中的空格 (OCR 常见问题)
        // 4.1 移除 LaTeX 命令后的空格: \frac { -> \frac{
        $content = preg_replace('/\\\\([a-zA-Z]+)\s+\{/', '\\\\$1{', $content);
        
        // 4.2 移除花括号内的前导和尾随空格: { 1 } -> {1}
        $content = preg_replace('/\{\s+/', '{', $content);
        $content = preg_replace('/\s+\}/', '}', $content);
        
        // 4.3 移除上标/下标符号周围的空格: x ^ { a } -> x^{a}
        $content = preg_replace('/\s*\^\s*\{\s*/', '^{', $content);
        $content = preg_replace('/\s*_\s*\{\s*/', '_{', $content);
        
        // 4.4 移除 \left 和 \right 后的空格: \left ( -> \left(
        $content = preg_replace('/\\\\(left|right)\s+/', '\\\\$1', $content);
        
        // 4.5 移除括号内侧的空格: ( x ) -> (x)
        $content = preg_replace('/\(\s+/', '(', $content);
        $content = preg_replace('/\s+\)/', ')', $content);
        
        // 4.6 规范化多个连续空格为单个空格
        $content = preg_replace('/\s+/', ' ', $content);
        
        // 4.7 清理 OCR 错误产生的多余 $ 符号
        // 移除花括号内的 $: {a$} -> {a}
        $content = preg_replace('/\{([^}]*)\$+([^}]*)\}/', '{$1$2}', $content);
        // 移除末尾的多余 $$$
        $content = preg_replace('/\$+\s*$/', '', $content);
        // 移除开头的多余 $$$
        $content = preg_replace('/^\s*\$+/', '', $content);
        // 移除连续的 $$$ (3个或更多)
        $content = preg_replace('/\$\$\$+/', '$$', $content);

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

        // 6. 智能包装 (统一处理混合内容)
        // 无论是纯文本还是富文本，都使用智能识别来包裹公式
        // 这能同时处理:
        // - "已知函数 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
    {
        // 修复：使用更精确的正则表达式，避免模式冲突
        // 先处理 $$...$$ 模式，然后处理单个 $...$ 模式（但确保不被$$包含）

        // 1. 处理 $$...$$ 显示公式
        $content = preg_replace_callback('/\$\$([\s\S]*?)\$\$/', function ($matches) {
            $cleanContent = strip_tags($matches[1]);
            $cleanContent = html_entity_decode($cleanContent, ENT_QUOTES, 'UTF-8');
            $cleanContent = trim($cleanContent);
            return '$$' . $cleanContent . '$$';
        }, $content);

        // 2. 处理 \(...\) 行内公式
        $content = preg_replace_callback('/\\\\\(([\s\S]*?)\\\\\)/', function ($matches) {
            $cleanContent = strip_tags($matches[1]);
            $cleanContent = html_entity_decode($cleanContent, ENT_QUOTES, 'UTF-8');
            $cleanContent = trim($cleanContent);
            return '\\(' . $cleanContent . '\\)';
        }, $content);

        // 3. 处理 \[...\] 显示公式
        $content = preg_replace_callback('/\\\\\[([\s\S]*?)\\\\\]/', function ($matches) {
            $cleanContent = strip_tags($matches[1]);
            $cleanContent = html_entity_decode($cleanContent, ENT_QUOTES, 'UTF-8');
            $cleanContent = trim($cleanContent);
            return '\\[' . $cleanContent . '\\]';
        }, $content);

        // 4. 最后处理 $...$ 行内公式（避免与$$冲突）
        $content = preg_replace_callback('/(?<!\$)\$([^$\n]+?)\$(?!\$)/', function ($matches) {
            $cleanContent = strip_tags($matches[1]);
            $cleanContent = html_entity_decode($cleanContent, ENT_QUOTES, 'UTF-8');
            $cleanContent = trim($cleanContent);
            return '$' . $cleanContent . '$';
        }, $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);
    }

    /**
     * 修复被污染的数学公式（包含重复的转义字符）
     */
    private static function fixCorruptedFormulas(string $content): string
    {
        // 简化的修复策略，只处理明确的问题

        // 1. 将超过2个连续的$符号减少为2个
        $content = preg_replace('/\${3,}/', '$$', $content);

        // 2. 修复$$B . - \frac{1}{2}$$ 这种格式，在选项前加空格
        $content = preg_replace('/\$\$([A-Z])\s*\.\s*/', '$$ $1. ', $content);

        // 3. 修复不完整的frac命令：\frac{1}{2} -> \frac{1}{2}
        $content = preg_replace('/\\\\frac\\\\({[^}]+)([^}]*)\\\\/', '\\\\frac$1}{$2}', $content);

        // 4. 移除孤立的反斜杠（在非LaTeX命令前的）
        $content = preg_replace('/\\\\(?![a-zA-Z{])/', '', $content);

        return $content;
    }
}