// Streamdown内部解析未终止标记的简化实现
function parseIncompleteMarkdown(tokens) {
  const stack = [];
  const result = [];
  
  for (const token of tokens) {
    if (token.type === 'text') {
      // 处理文本中的未终止标记
      const textWithUnterminated = token.value.replace(
        /(\*\*|__|\*|_|`|~~)([^*_\s`~]+)/g,
        (match, marker, content) => {
          // 模拟未终止标记的样式应用
          return `<span class="unterminated-${marker}">${marker}${content}</span>`;
        }
      );
      result.push(textWithUnterminated);
    } else if (token.type === 'block_open') {
      stack.push(token);
    } else if (token.type === 'block_close') {
      stack.pop();
    }
  }
  
  // 处理栈中未关闭的块
  while (stack.length > 0) {
    const unclosedToken = stack.pop();
    result.push(`<!-- 未终止的${unclosedToken.tag}块 -->`);
  }
  
  return result.join('');
}

// Streamdown中数学公式处理的简化逻辑
import katex from 'katex';

function renderMath(content, isDisplayMode) {
  try {
    return katex.renderToString(content, {
      displayMode: isDisplayMode,
      throwOnError: false,
      strict: false // 允许部分解析错误，适合流式场景
    });
  } catch (error) {
    // 优雅降级：显示原始公式文本
    return `<code>${escapeHtml(content)}</code>`;
  }
}

// 在流式过程中处理不完整公式
function handleIncompleteFormula(formulaChunk) {
  // 检查公式是否可能不完整（缺少闭合符等）
  if (isLikelyIncomplete(formulaChunk)) {
    return `<span class="incomplete-math">${formulaChunk}</span>`;
  }
  return renderMath(formulaChunk, false);
}

// Streamdown中代码高亮的实现方式
import { getHighlighter } from 'shiki';

// 创建高性能的高亮器实例
const highlighter = await getHighlighter({
  theme: 'github-dark',
  langs: ['javascript', 'typescript', 'python', 'html', 'css']
});

function highlightCode(code, language) {
  // 检测语言是否支持，不支持时自动推断
  const detectedLang = highlighter.getLoadedLanguages().includes(language) 
    ? language 
    : 'plaintext';
  
  return highlighter.codeToHtml(code, {
    lang: detectedLang,
    theme: 'github-dark'
  });
}

// 处理流式中不完整的代码块
function handleIncompleteCodeBlock(code, language, isComplete) {
  if (!isComplete) {
    // 为不完整代码块添加特殊样式和提示
    return `
      <div class="incomplete-code-block">
        <div class="code-warning">⚠️ 代码块可能不完整</div>
        ${highlightCode(code, language)}
      </div>
    `;
  }
  return highlightCode(code, language);
}

// 安全过滤策略实现
const allowedProtocols = ['https', 'http', 'mailto', 'tel'];
const allowedImagePrefixes = ['https://', 'http://', '/'];
const allowedLinkPrefixes = ['https://', 'http://', '/', '#', 'mailto:', 'tel:'];

function sanitizeUrl(url, type) {
  try {
    const parsed = new URL(url, 'https://example.com');
    
    // 检查协议白名单
    if (!allowedProtocols.includes(parsed.protocol.replace(':', ''))) {
      return null; // 拒绝不安全协议
    }
    
    // 检查URL前缀
    const prefixes = type === 'image' ? allowedImagePrefixes : allowedLinkPrefixes;
    if (!prefixes.some(prefix => url.startsWith(prefix))) {
      return null;
    }
    
    return url;
  } catch {
    return null; // 无效URL
  }
}

// 记忆化渲染器的实现
const MemoizedMarkdownRenderer = React.memo(
  ({ content, options }) => {
    const parsedContent = useMemo(() => {
      return parseMarkdown(content, options);
    }, [content, options]);
    
    return renderToReactNodes(parsedContent);
  },
  (prevProps, nextProps) => {
    // 精细化的props比较逻辑
    return prevProps.content === nextProps.content &&
           deepEqual(prevProps.options, nextProps.options);
  }
);

// 单元测试示例
describe('parseIncompleteMarkdown', () => {
  test('处理未终止粗体标记', () => {
    const input = '这是**未终止粗体';
    const result = parseIncompleteMarkdown(input);
    expect(result).toContain('unterminated-bold');
  });
  
  test('处理不完整代码块', () => {
    const input = '```javascript\nconsole.log(';
    const result = parseIncompleteMarkdown(input);
    expect(result).toContain('incomplete-code-block');
  });
});

// 集成测试示例
describe('Streamdown组件', () => {
  test('渲染流式内容', async () => {
    const { getByText } = render(
      <Streamdown parseIncompleteMarkdown={true}>
        {'# 标题\n\n部分**粗体'}
      </Streamdown>
    );
    
    expect(getByText('标题')).toBeInTheDocument();
    expect(getByText('部分粗体')).toHaveClass('unterminated-bold');
  });
});

// vite.config.js 或 next.config.js 中的优化配置
export default {
  build: {
    rollupOptions: {
      external: ['react', 'react-dom'], // 外部化React
      output: {
        manualChunks: {
          // 代码分割策略
          markdown: ['streamdown', 'remark-parse'],
          highlighting: ['shiki'],
          math: ['katex', 'remark-math']
        }
      }
    }
  }
};

// 应用级错误边界
class StreamdownErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false };
  }
  
  static getDerivedStateFromError(error) {
    return { hasError: true };
  }
  
  componentDidCatch(error, errorInfo) {
    // 报告错误到监控服务
    logErrorToService(error, errorInfo);
  }
  
  render() {
    if (this.state.hasError) {
      return (
        <div className="error-fallback">
          <h3>Markdown渲染失败</h3>
          <button onClick={() => this.setState({ hasError: false })}>
            重试
          </button>
        </div>
      );
    }
    
    return this.props.children;
  }
}

// 使用错误边界
<StreamdownErrorBoundary>
  <Streamdown parseIncompleteMarkdown={true}>
    {content}
  </Streamdown>
</StreamdownErrorBoundary>