Complete Example

skill_info:
  name: complete-example
  version: 1.4.1
  description: AI 增强版 LaTeX 示例智能生成器（项目级隐藏目录存储）
  author: "Bensz Conan"
  category: writing

# ========== LLM 配置 ==========
llm:
  provider: "claude"  # claude / openai / local
  model: "claude-sonnet-4-20250514"  # 或 gpt-4
  api_key_env: "ANTHROPIC_API_KEY"  # 环境变量名
  temperature:
    analysis: 0.3    # 分析任务（低温度，稳定）
    generation: 0.8  # 生成任务（高温度，创造性）
    refinement: 0.5  # 优化任务（中温度）
  max_tokens: 4000

# ========== 参数定义 ==========
parameters:
  project:
    type: string
    required: true
    description: 项目名称或路径

  content_density:
    type: string
    allowed_values: ["minimal", "moderate", "comprehensive"]
    default: "moderate"
    description: |
      minimal:    每章节 2 个资源，200 字
      moderate:   每章节 4 个资源，300 字
      comprehensive: 每章节 6 个资源，500 字

  output_mode:
    type: string
    allowed_values: ["preview", "apply", "report"]
    default: "preview"
    description: |
      preview:  只显示预览，不修改文件
      apply:    直接修改文件（有备份）
      report:   生成详细报告文件

  target_files:
    type: array
    default: null
    description: |
      目标文件列表（相对于项目根目录）
      null 表示自动检测所有 extraTex/*.tex

  narrative_hint:
    type: string
    default: null
    description: |
      用户自定义的叙事提示，用于指导 AI 生成特定风格的示例内容。
      这是"示例场景"而非"严肃场景"，因此 AI 可以根据提示编造相应的叙事。
      示例：
        - "生成一个关于深度学习在医疗影像分析中应用的示例"
        - "创建一个使用传统机器学习方法的示例研究"
        - "编写一个关于材料科学实验设计的示例，重点关注 XRD 表征"
        - "模拟一个多中心临床试验的设计与分析流程"
      null 表示 AI 根据章节主题自动推断叙事方向。

# ========== 运行管理配置 ==========
run_management:
  # 运行输出根目录（所有中间文件都存储在目标项目的隐藏目录中）
  runs_root: "{project_path}/.complete_example"

  # 运行 ID 生成策略
  run_id_strategy: "timestamp_uuid"  # timestamp_uuid / sequential / custom

  # 保留策略
  retention:
    max_runs: 50              # 最多保留 50 次运行记录
    max_age_days: 30          # 最多保留 30 天
    auto_cleanup: true        # 自动清理过期记录

  # 备份策略
  backup:
    location: ".complete_example/{run_id}/backups"  # 备份位置（项目隐藏目录）
    compress: false                                    # 是否压缩备份文件
    format: "tar.gz"                                   # 压缩格式（如果启用压缩）

  # 日志策略
  logging:
    location: ".complete_example/{run_id}/logs"     # 日志位置（项目隐藏目录）
    level: "INFO"                                   # 日志级别
    rotation: true                                  # 日志轮转
    max_size_mb: 10                                 # 单个日志文件最大大小

# ========== 资源扫描配置 ==========
scan:
  targets:
    - name: "figures"
      enabled: true
      patterns: ["*.jpg", "*.jpeg", "*.png", "*.pdf", "*.eps"]
      extract_metadata: true

    - name: "code"
      enabled: true
      patterns: ["*.py", "*.m", "*.r", "*.cpp", "*.c"]
      max_lines: 100  # 超过此行数只截取片段

    - name: "references"
      enabled: true
      patterns: ["*.bib"]
      parse_entries: true

# ========== 内容生成配置 ==========
generation:
  # 资源选择策略
  selection_strategy: "smart_allocation"  # smart_allocation / ai_score / random / manual
  # smart_allocation: 使用新的智能资源分配器，确保充分利用所有素材

  # 相关性阈值（仅在使用 ai_score 时有效）
  relevance_threshold: 0.5

  # 内容类型权重（AI 根据章节主题动态调整，作为提示而非强约束）
  content_type_weights:
    text: 0.5
    table: 0.2
    formula: 0.15
    figure: 0.1
    code: 0.05

  # 每种资源类型的数量限制
  max_figures_per_section: 2
  max_code_per_section: 1
  max_references_per_section: 3

  # 表格生成配置
  table_generation:
    enabled: true
    max_tables_per_section: 2
    complexity_levels:
      simple:
        max_columns: 5
        max_rows: 10
      moderate:
        max_columns: 8
        max_rows: 20
      complex:
        max_columns: 10
        max_rows: 50
        allow_multirow: true
        allow_multicolumn: true

  # 数学公式生成配置
  formula_generation:
    enabled: true
    max_formulas_per_section: 3
    types:
      - inline
      - display
      - equation
      - align

  # ========== 章节层级规范 ==========
  # 核心规则：main.tex 使用 section/subsection，input 类 tex 使用 subsubsection/subsubsubsection
  section_hierarchy:
    # main.tex 专用层级（禁止在 input 类 tex 中使用）
    main_tex_only:
      - "\\section"
      - "\\subsection"
    # input 类 tex 允许的层级
    input_tex_allowed:
      - "\\subsubsection"
      - "\\subsubsubsection"
    # 生成要求：每个 input tex 必须同时使用两个层级
    generation_requirement:
      require_both_levels: true  # 必须同时使用 subsubsection 和 subsubsubsection
      min_subsubsection: 1       # 每个文件至少 1 个 subsubsection
      min_subsubsubsection: 1    # 每个 subsubsection 下至少 1 个 subsubsubsection
    # 层级检查策略
    enforcement:
      enabled: true
      mode: "strict"  # strict: 拒绝违规 / warn: 警告但允许 / off: 关闭检查
      auto_fix: false  # 是否自动修正层级（危险，建议关闭）

  # 内容模板
  templates:
    figure_insertion: |
      \begin{figure}[htbp]
        \centering
        \includegraphics[width=0.8\textwidth]{{{path}}}
        \caption{{{caption}}}
        \label{{{label}}}
      \end{figure}

    code_listing: |
      \begin{lstlisting}[language={{lang}}, caption={{{caption}}}, firstline=1, lastline={{lastline}}]
      {{code}}
      \end{lstlisting}

    reference_citation: "\\cite{{{citekey}}}"

    # 简单表格模板（booktabs）
    simple_table: |
      \begin{table}[htbp]
        \centering
        \fontsize{11}{11}\selectfont
        \caption{\textbf{{{caption}}}}
        \begin{tabular}{{{column_spec}}}
        \toprule
        {{header_row}}
        \midrule
        {{data_rows}}
        \bottomrule
        \end{tabular}
        \captionsetup{font={footnotesize,stretch=1.25},justification=raggedright}
        \label{{{label}}}
      \end{table}

    # 复杂表格模板（多行表头）
    complex_table: |
      \begin{table}[htbp]
        \centering
        \fontsize{11}{11}\selectfont
        \caption{\textbf{{{caption}}}}
        \begin{tabular}{{{column_spec}}}
        \toprule
        {{header_rows}}
        \toprule
        {{data_rows}}
        \bottomrule
        \end{tabular}
        \captionsetup{font={footnotesize,stretch=1.25},justification=raggedright}
        \label{{{label}}}
      \end{table}

    # 数学公式模板
    inline_math: "${{formula}}$"
    display_math: |
      \[
      {{formula}}
      \]
    equation: |
      \begin{equation}
        {{formula}}
        \label{{{label}}}
      \end{equation}
    align: |
      \begin{align}
        {{formulas}}
      \end{align}

# ========== 🆕 篇幅控制配置 ==========
page_control:
  # 目标 PDF 页数范围
  target_pdf_pages: [12, 14]  # [最小页数, 最大页数]

  # 每页平均字数（用于估算）
  avg_words_per_page: 350

  # 各种元素占用的页数（估算值）
  figures_per_page_estimate: 0.3     # 每张图片占用 0.3 页
  code_per_page_estimate: 0.2        # 每段代码占用 0.2 页
  table_per_page_estimate: 0.25      # 每个表格占用 0.25 页
  references_per_page_estimate: 0.05 # 每个文献引用占用 0.05 页

  # 资源利用率目标
  resource_utilization:
    figures: 1.0  # 100% 利用率（所有图片都分配到章节）
    code: 1.0     # 100% 利用率（所有代码都分配到章节）

# ========== 格式保护配置 ==========
format_protection:
  # 受保护的 LaTeX 命令
  protected_commands:
    - "\\setlength"
    - "\\geometry"
    - "\\definecolor"
    - "\\setCJKfamilyfont"
    - "\\setmainfont"
    - "\\titleformat"
    - "\\setlist"
    - "\\newcommand"
    - "\\renewcommand"

  # 受保护的文件（绝对不修改）
  protected_files:
    - "extraTex/@config.tex"
    - "main.tex"

  # 备份策略
  backup:
    enabled: true
    keep_count: 5  # 保留最近 5 个备份

  # 编译验证
  compile_verify:
    enabled: true
    engine: "xelatex"
    timeout: 60  # 秒

# ========== 🔒 安全管理配置 ==========
security:
  # 系统文件保护
  system_files:
    blacklist:
      - "main.tex"
      - "extraTex/@config.tex"
      - "@config.tex"
    # 允许编辑的文件模式（白名单，正则表达式）
    editable_patterns:
      - "^extraTex/\\d+\\.\\d+.*\\.tex$"  # extraTex/1.1.xxx.tex
      - "^references/reference\\.tex$"      # 参考文献引用文件

  # 格式关键词黑名单（禁止在用户文件中使用）
  format_keywords_blacklist:
    - "\\\\geometry{"
    - "\\\\setlength{"
    - "\\\\definecolor{"
    - "\\\\setCJKfamilyfont"
    - "\\\\setmainfont"
    - "\\\\setCJKmainfont"
    - "\\\\renewcommand{\\\\baselinestretch}"
    - "\\\\titleformat{"
    - "\\\\titlespacing"
    - "\\\\setlist"
    - "\\\\newcommand"
    - "\\\\renewcommand"
    - "\\\\newcolumntype"
    - "\\\\DeclareMathOperator"
    - "\\\\usepackage{"
    - "\\\\documentclass"

  # 表格安全检查（生成后启发式过滤）
  table_security:
    max_size_kb: 50
    forbidden_commands:
      - "\\newcolumntype"
      - "\\setlength{\\tabcolsep}"
      - "\\renewcommand{\\arraystretch}"

  # 公式安全检查（生成后启发式过滤）
  formula_security:
    max_length: 1000
    forbidden_commands:
      - "\\DeclareMathOperator"
      - "\\newcommand"

  # 文件完整性校验
  integrity_check:
    enabled: true
    hash_algorithm: "sha256"
    hash_file: ".format_hashes.json"
    auto_init: true  # 如果哈希文件不存在，自动初始化

  # 内容安全扫描
  content_scanning:
    enabled: true
    auto_sanitize: true  # 自动清理格式注入
    fail_on_violation: false  # 发现违规时是否失败（false 则警告并清理）

  # 安全检查项开关
  enabled_checks:
    system_file: true       # 系统文件黑名单检查
    section_hierarchy: true # 章节层级规范检查
    integrity: true         # 完整性校验
    format_injection: true  # 格式注入检查

# ========== AI 提示词模板 ==========
prompts:
  analyze_theme: |
    你是一位专业的学术写作分析专家。请分析以下 LaTeX 章节的内容主题。

    章节内容（前 {max_chars} 字符）：
    {content}

    请返回 JSON 格式的分析结果：
    {{
      "theme": "章节的核心主题（一句话概括）",
      "key_concepts": ["关键概念1", "关键概念2", "关键概念3"],
      "writing_style": "学术/技术/说明/混合",
      "suggested_resources": ["建议的图片类型", "建议的文献领域"],
      "tone": "正式/半正式/通俗",
      "target_audience": "评审专家/同行/学生/大众"
    }}

  reason_relevance: |
    你是一位专业的学术写作顾问。请评估以下资源是否适合用于指定章节。

    章节信息：
    - 主题：{section_theme}
    - 关键概念：{key_concepts}
    - 写作风格：{writing_style}

    资源信息：
    - 路径：{resource_path}
    - 类型：{resource_type}
    - 元数据：{metadata}

    请返回 JSON 格式的评估结果：
    {{
      "relevance_score": 0.85,
      "reason": "详细说明理由（100-200字）",
      "suggested_usage": "建议如何使用这个资源"
    }}

  generate_narrative: |
    你是一位经验丰富的科研写作助手，专精于国家自然科学基金申请书的撰写。

    根据以下信息，生成一段连贯的示例内容。

    ## 章节信息
    - 主题：{theme}
    - 关键概念：{key_concepts}
    - 写作风格：{writing_style}
    - 目标读者：{target_audience}

    ## 用户叙事提示
    {narrative_hint}

    ## 上下文片段
    {context}

    ## 可用资源
    {resources}

    ## 生成要求
    1. 生成 {target_length} 字的示例段落
    2. 自然地引用资源
    3. 使用正式的学术写作风格
    4. **重要**：根据【用户叙事提示】调整内容方向和风格
    5. **允许编造**：这是示例场景，可以根据提示编造合理的研究内容、数据和结论
    6. 在应该插入 LaTeX 代码的地方用 {{{{PLACEHOLDER:资源路径}}}} 标记

    ## 🆕 多元内容格式支持
    根据章节主题，你可以生成以下类型的内容：

    ### 表格
    - 用于展示对比数据、实验结果、参数设置等
    - 使用占位符：{{{{TABLE:表格描述|复杂度}}}}
    - 复杂度选项：simple / moderate / complex
    - 示例：{{{{TABLE:临床特征对比表|complex}}}}

    ### 数学公式
    - 用于理论推导、模型描述、统计分析等
    - 行内公式：{{{{INLINE_MATH:公式内容}}}}
    - 独立公式：{{{{DISPLAY_MATH:公式内容}}}}
    - 带编号公式：{{{{EQUATION:公式内容|标签}}}}
    - 多行公式：{{{{ALIGN:公式1\\\\公式2\\\\公式3}}}}
    - 示例：{{{{EQUATION:E = mc^2|eq:energy}}}}

    ## ⚠️ 章节层级约束（必须遵守）
    当前文件类型：{file_type}
    - 如果是 input 类 tex 文件（extraTex/*.tex）：
      - ✅ 必须使用：\subsubsection 和 \subsubsubsection 两个层级
      - ❌ 禁止使用：\section、\subsection（这些仅在 main.tex 中使用）

    ## ⚠️ 双层级结构要求（必须遵守）
    每个 input 类 tex 文件必须同时包含两个层级的标题：
    - **\subsubsection{{主标题}}**：作为该文件的主要章节划分
    - **\subsubsubsection{{子标题}}**：在每个 subsubsection 下进一步细分

    示例结构：
    ```latex
    \subsubsection{{研究背景}}
    \subsubsubsection{{国内研究现状}}
    ...内容...
    \subsubsubsection{{国外研究现状}}
    ...内容...

    \subsubsection{{研究意义}}
    \subsubsubsection{{理论意义}}
    ...内容...
    \subsubsubsection{{实践意义}}
    ...内容...
    ```

    只返回生成的文本，不要其他解释。

  generate_table: |
    你是一位专业的科研数据可视化专家。请根据以下信息生成一个 LaTeX 表格。

    ## 表格需求
    - 主题：{table_theme}
    - 复杂度：{complexity}
    - 列数：{num_columns}
    - 行数：{num_rows}
    - 用途：{purpose}

    ## 上下文
    {context}

    ## 生成要求
    1. 表格数据应该合理且符合科研规范
    2. 使用适当的统计符号和单位
    3. 包含必要的表头和分组
    4. 数据精度合理（通常保留2-3位小数）
    5. 如果是对比表，应包含统计检验结果（如 P 值）

    请返回 JSON 格式：
    {{
      "caption": "表格标题",
      "column_spec": "列格式（如 lcccc）",
      "header_row": "表头行（用 & 分隔，末尾带 \\\\）",
      "data_rows": ["数据行1（末尾带 \\\\）", "数据行2（末尾带 \\\\）"],
      "label": "表格标签（如 tab:results）"
    }}

  generate_formula: |
    你是一位专业的数学建模专家。请根据以下信息生成一个 LaTeX 数学公式。

    ## 公式需求
    - 主题：{formula_theme}
    - 类型：{formula_type}  # inline / display / equation / align
    - 用途：{purpose}

    ## 上下文
    {context}

    ## 生成要求
    1. 公式应该数学上合理且符合领域规范
    2. 使用标准的 LaTeX 数学符号
    3. 变量命名清晰（使用希腊字母或英文字母）
    4. 如果是多行公式，应该对齐等号或关系符
    5. 包含必要的下标、上标和修饰符

    请返回 JSON 格式：
    {{
      "formula": "公式内容（LaTeX 格式）",
      "label": "公式标签（如果需要）",
      "description": "公式含义的简短描述"
    }}

# ========== 质量评估标准 ==========
quality_thresholds:
  coherence_min: 0.8        # 连贯性最低要求
  academic_tone_min: 0.75   # 学术风格最低要求
  overall_score_min: 0.8    # 总体评分最低要求

  # 表格质量评估（启发式）
  table_quality:
    min_columns: 3
    max_columns: 10
    min_rows: 3
    data_consistency: 0.9
    header_clarity: 0.85

  # 公式质量评估（启发式）
  formula_quality:
    syntax_correctness: 1.0
    semantic_relevance: 0.8
    notation_standard: 0.85

"""
complete-example skill - 工具函数模块
"""

from .llm_client import LLMClient
from .latex_parser import extract_format_lines, validate_latex_syntax
from .bibtex_parser import parse_bibtex_file, extract_bibtex_entries
from .file_utils import read_file_safe, write_file_safe, backup_file

__all__ = [
    "LLMClient",
    "extract_format_lines",
    "validate_latex_syntax",
    "parse_bibtex_file",
    "extract_bibtex_entries",
    "read_file_safe",
    "write_file_safe",
    "backup_file",
]

"""
Complete Example Skill - 高级使用示例
展示如何使用 narrative_hint 参数自定义叙事方向
"""

import sys
from pathlib import Path

# 添加 skill 目录到路径
skill_root = Path(__file__).parent.parent
sys.path.insert(0, str(skill_root))

from scripts.skill_controller import CompleteExampleSkill


def example_medical_imaging():
    """示例 1：医疗影像场景"""
    print("=" * 60)
    print("示例 1：医疗影像 - 深度学习在医疗影像分析中的应用")
    print("=" * 60)

    skill = create_skill()

    result = skill.execute(
        project_name="NSFC_Young",
        options={
            "content_density": "moderate",
            "output_mode": "preview",
            "narrative_hint": (
                "生成一个关于深度学习在医疗影像分析中应用的示例，"
                "重点关注 CNN 架构和数据增强策略。"
                "编造一个肺结节检测的研究场景。"
            )
        }
    )

    print_result(result)


def example_material_science():
    """示例 2：材料科学场景"""
    print("\n" + "=" * 60)
    print("示例 2：材料科学 - 新型纳米材料合成与表征")
    print("=" * 60)

    skill = create_skill()

    result = skill.execute(
        project_name="NSFC_Young",
        options={
            "content_density": "comprehensive",
            "output_mode": "preview",
            "narrative_hint": (
                "创建一个关于新型纳米材料合成与表征的示例，"
                "包括 XRD、SEM、TEM 等表征方法。"
                "编造一种用于催化的新型金属氧化物纳米材料。"
            )
        }
    )

    print_result(result)


def example_clinical_trial():
    """示例 3：临床试验场景"""
    print("\n" + "=" * 60)
    print("示例 3：临床试验 - 多中心随机对照试验")
    print("=" * 60)

    skill = create_skill()

    result = skill.execute(
        project_name="NSFC_Young",
        options={
            "content_density": "moderate",
            "output_mode": "preview",
            "narrative_hint": (
                "模拟一个多中心临床试验的设计与分析流程，"
                "重点描述随机化、盲法实施和统计分析计划。"
                "编造一个关于新药疗效评估的三期临床试验。"
            )
        }
    )

    print_result(result)


def example_traditional_ml():
    """示例 4：传统机器学习场景"""
    print("\n" + "=" * 60)
    print("示例 4：传统机器学习 - 支持向量机分类")
    print("=" * 60)

    skill = create_skill()

    result = skill.execute(
        project_name="NSFC_Young",
        options={
            "content_density": "minimal",
            "output_mode": "preview",
            "narrative_hint": (
                "编写一个使用支持向量机（SVM）进行分类的示例研究。"
                "对比不同核函数的性能，并使用网格搜索优化参数。"
            )
        }
    )

    print_result(result)


def example_apply_mode():
    """示例 5：应用模式（直接修改文件）"""
    print("\n" + "=" * 60)
    print("示例 5：应用模式（直接修改文件，有备份）")
    print("=" * 60)

    skill = create_skill()

    result = skill.execute(
        project_name="NSFC_Young",
        options={
            "content_density": "moderate",
            "output_mode": "apply",  # 注意：这会直接修改文件！
            "target_files": ["extraTex/2.1.研究内容.tex"],
            "narrative_hint": "生成一个示例段落"
        }
    )

    print_result(result)
    print("\n注意：文件已被修改，备份保存在 .complete_example/<run_id>/backups/")


def create_skill():
    """创建 skill 实例"""
    import yaml
    config_path = skill_root / "config.yaml"

    with open(config_path, 'r', encoding='utf-8') as f:
        config = yaml.safe_load(f)

    config['skill_root'] = str(skill_root)

    return CompleteExampleSkill(config)


def print_result(result):
    """打印结果摘要"""
    print(f"\n执行状态：{result['final_result']}")
    print(f"运行 ID：{result['run_id']}")
    print(f"运行目录：{result['run_dir']}")

    if result['final_result'] == 'success':
        print("\n各阶段摘要：")
        for stage_name, stage_data in result['stages'].items():
            print(f"  - {stage_name}: {stage_data['status']}")

            # 打印特定阶段的详细信息
            if stage_name == 'scan' and 'summary' in stage_data:
                for k, v in stage_data['summary'].items():
                    print(f"      {k}: {v}")

            if stage_name == 'quality' and 'evaluations' in stage_data:
                for file_path, eval_data in stage_data['evaluations'].items():
                    print(f"      {file_path}:")
                    print(f"        总体评分: {eval_data.get('overall_score', 'N/A')}")
    else:
        print(f"\n错误：{result.get('error', '未知错误')}")


def main():
    """运行所有示例"""
    print("Complete Example Skill - 高级使用示例")
    print("展示如何使用 narrative_hint 参数自定义叙事方向\n")

    # 运行示例（可以根据需要注释掉某些示例）
    example_medical_imaging()
    # example_material_science()
    # example_clinical_trial()
    # example_traditional_ml()
    # example_apply_mode()  # 谨慎使用：会直接修改文件！


if __name__ == "__main__":
    main()

"""
AIContentGenerator - AI 增强内容生成器
🧠 AI + 🤝 协作：生成连贯的叙述性文本，智能整合资源
"""

from typing import List, Dict, Any, Optional
from pathlib import Path
import re


class AIContentGenerator:
    """AI 驱动的智能内容生成器"""

    def __init__(self, llm_client, templates: dict, format_guard: 'FormatGuard', config: Optional[dict] = None):
        """
        Args:
            llm_client: LLM 客户端
            templates: Jinja2 模板字典
            format_guard: 格式保护器实例
            config: 完整配置（用于 prompts / generation / security 等；可选）
        """
        self.llm = llm_client
        self.templates = templates
        self.guard = format_guard
        self.config = config or {}

    def generate_section_content(
        self,
        resources: List['ResourceInfo'],
        section_theme: 'SectionTheme',
        existing_content: str,
        content_density: str = "moderate",
        narrative_hint: str = None,
        file_path: str = ""
    ) -> str:
        """
        为章节生成 AI 增强的示例内容

        Args:
            resources: 可用资源列表
            section_theme: 章节主题（AI 分析结果）
            existing_content: 现有内容
            content_density: 内容密度
            narrative_hint: 用户自定义的叙事提示（可选）

        Returns:
            str: 生成的内容（保留格式定义）

        工作流程：
        1. 🔧 硬编码：提取受保护的格式区域
        2. 🧠 AI：分析资源相关性并选择
        3. 🧠 AI：生成连贯的叙述性内容（支持用户提示）
        4. 🤝 协作：AI 内容 + 硬编码模板包装
        5. 🧠 AI：自我检查和优化
        """

        # ========== 阶段 1：硬编码 - 提取保护区域 ==========
        protected_zones = self.guard.extract_protected_zones(existing_content)

        # ========== 阶段 2：AI - 智能资源选择 ==========
        from .semantic_analyzer import SemanticAnalyzer
        analyzer = SemanticAnalyzer(self.llm)

        relevance_scores = {}
        for resource in resources:
            relevance = analyzer.reason_resource_relevance(resource, section_theme)
            relevance_scores[resource.path] = relevance.relevance_score

        # 根据密度级别选择资源数量
        k_map = {"minimal": 2, "moderate": 4, "comprehensive": 6}
        k = k_map.get(content_density, 4)

        # 硬编码：Top-K 选择
        selected_resources = sorted(
            resources,
            key=lambda r: relevance_scores.get(r.path, 0),
            reverse=True
        )[:k]

        # ========== 阶段 3：AI - 生成叙述性内容 ==========
        narrative = self._generate_narrative(
            selected_resources,
            section_theme,
            existing_content,
            narrative_hint,
            file_path=file_path,
        )

        # ========== 阶段 4：协作 - 包装 LaTeX 代码 ==========
        formatted_content = self._wrap_with_latex_code(
            narrative, selected_resources, protected_zones, context=existing_content
        )

        # ========== 阶段 5：AI - 自我优化 ==========
        refined_content = self._refine_content(
            formatted_content, section_theme
        )

        # ========== 阶段 6：硬编码 - 最终验证 ==========
        self._validate_format_preservation(protected_zones, refined_content)

        return refined_content

    def generate_section_content_with_allocation(
        self,
        allocated_resources: List['ResourceInfo'],
        target_word_count: int,
        section_theme: 'SectionTheme',
        existing_content: str,
        narrative_hint: str = None,
        file_path: str = ""
    ) -> str:
        """
        🆕 使用预分配的资源生成内容（优化版）

        与 generate_section_content 的区别：
        - 不再使用 Top-K 选择，直接使用预分配的资源
        - 支持自定义目标字数（用于篇幅控制）

        Args:
            allocated_resources: 已分配给该章节的资源列表
            target_word_count: 目标字数
            section_theme: 章节主题
            existing_content: 现有内容
            narrative_hint: 用户叙事提示
            file_path: 文件路径

        Returns:
            str: 生成的内容
        """
        # ========== 阶段 1：硬编码 - 提取保护区域 ==========
        protected_zones = self.guard.extract_protected_zones(existing_content)

        # ========== 阶段 2：AI - 生成叙述性内容（使用预分配资源） ==========
        narrative = self._generate_narrative_with_target(
            resources=allocated_resources,
            theme=section_theme,
            context=existing_content,
            narrative_hint=narrative_hint,
            target_word_count=target_word_count,
            file_path=file_path,
        )

        # ========== 阶段 3：协作 - 包装 LaTeX 代码 ==========
        formatted_content = self._wrap_with_latex_code(
            narrative, allocated_resources, protected_zones, context=existing_content
        )

        # ========== 阶段 4：AI - 自我优化 ==========
        refined_content = self._refine_content(
            formatted_content, section_theme
        )

        # ========== 阶段 5：硬编码 - 最终验证 ==========
        self._validate_format_preservation(protected_zones, refined_content)

        return refined_content

    def _generate_narrative_with_target(
        self,
        resources: List['ResourceInfo'],
        theme: 'SectionTheme',
        context: str,
        narrative_hint: str = None,
        target_word_count: int = 300,
        file_path: str = ""
    ) -> str:
        """🆕 AI：生成指定字数的连贯叙述性文本"""

        prompts = (self.config.get("prompts") or {})
        tmpl = prompts.get("generate_narrative")

        # 推断文件类型
        file_type = "main" if (file_path and file_path.endswith("main.tex")) else "input"

        if tmpl:
            prompt = tmpl.format(
                theme=theme.theme,
                key_concepts=", ".join(theme.key_concepts),
                writing_style=theme.writing_style,
                target_audience=theme.target_audience,
                narrative_hint=narrative_hint or "（未提供，AI 根据章节主题自动推断）",
                context=context[:800],
                resources=self._format_resources_for_prompt(resources),
                target_length=str(target_word_count),  # 🆕 使用目标字数
                file_type=file_type,
            )
        else:
            # 兼容旧逻辑
            prompt = (
                "你是一位经验丰富的科研写作助手，专精于国家自然科学基金申请书的撰写。\n"
                "根据以下信息，生成一段连贯的示例内容。\n\n"
                f"主题：{theme.theme}\n"
                f"关键概念：{', '.join(theme.key_concepts)}\n"
                f"写作风格：{theme.writing_style}\n"
                f"目标读者：{theme.target_audience}\n"
                f"目标字数：约 {target_word_count} 字\n"  # 🆕 明确字数要求
                f"用户叙事提示：{narrative_hint or '（未提供）'}\n\n"
                f"可用资源：\n{self._format_resources_for_prompt(resources)}\n\n"
                "请在应插入 LaTeX 代码处使用双大括号占位符，例如：\n"
                "- 图片：{{{{PLACEHOLDER:figures/xxx.jpg}}}}\n"
                "- 文献：{{{{PLACEHOLDER:references:zhang2023deep}}}}\n"
                "- 表格：{{{{TABLE:临床特征对比表|complex}}}}\n"
                "- 公式：{{{{EQUATION:E=mc^2|eq:energy}}}}\n\n"
                "只返回生成的文本，不要解释。\n"
            )

        temp = 0.8
        llm_temp_cfg = (self.config.get("llm") or {}).get("temperature")
        if isinstance(llm_temp_cfg, dict):
            temp = float(llm_temp_cfg.get("generation", temp))

        return self.llm.complete(prompt, temperature=temp)

    def _generate_narrative(
        self,
        resources: List['ResourceInfo'],
        theme: 'SectionTheme',
        context: str,
        narrative_hint: str = None,
        file_path: str = ""
    ) -> str:
        """AI：生成连贯的叙述性文本"""

        prompts = (self.config.get("prompts") or {})
        tmpl = prompts.get("generate_narrative")

        # 推断文件类型（用于提示约束）
        file_type = "main" if (file_path and file_path.endswith("main.tex")) else "input"

        if tmpl:
            prompt = tmpl.format(
                theme=theme.theme,
                key_concepts=", ".join(theme.key_concepts),
                writing_style=theme.writing_style,
                target_audience=theme.target_audience,
                narrative_hint=narrative_hint or "（未提供，AI 根据章节主题自动推断）",
                context=context[:800],
                resources=self._format_resources_for_prompt(resources),
                target_length="200-400",
                file_type=file_type,
            )
        else:
            # 兼容旧逻辑：最小提示（但注意要让 AI 输出双大括号占位符）
            prompt = (
                "你是一位经验丰富的科研写作助手，专精于国家自然科学基金申请书的撰写。\n"
                "根据以下信息，生成一段连贯的示例内容。\n\n"
                f"主题：{theme.theme}\n"
                f"关键概念：{', '.join(theme.key_concepts)}\n"
                f"写作风格：{theme.writing_style}\n"
                f"目标读者：{theme.target_audience}\n\n"
                f"用户叙事提示：{narrative_hint or '（未提供）'}\n\n"
                "请在应插入 LaTeX 代码处使用双大括号占位符，例如：\n"
                "- 图片：{{{{PLACEHOLDER:figures/xxx.jpg}}}}\n"
                "- 文献：{{{{PLACEHOLDER:references:zhang2023deep}}}}\n"
                "- 表格：{{{{TABLE:临床特征对比表|complex}}}}\n"
                "- 公式：{{{{EQUATION:E=mc^2|eq:energy}}}}\n\n"
                "只返回生成的文本，不要解释。\n"
            )

        temp = 0.8
        llm_temp_cfg = (self.config.get("llm") or {}).get("temperature")
        if isinstance(llm_temp_cfg, dict):
            temp = float(llm_temp_cfg.get("generation", temp))

        return self.llm.complete(prompt, temperature=temp)

    def _format_resources_for_prompt(self, resources: List['ResourceInfo']) -> str:
        """格式化资源列表供 AI 使用"""
        lines = []
        for i, r in enumerate(resources, 1):
            lines.append(f"{i}. **{r.filename}** ({r.type})")
            # 明确告诉 AI 应该输出什么占位符 ID，避免“写对了资源但占位符写错”导致替换失败。
            lines.append(f"   - placeholder_id: {self._resource_placeholder_id(r)}")
            if r.metadata:
                for key, value in r.metadata.items():
                    lines.append(f"   - {key}: {value}")
        return "\n".join(lines)

    def _wrap_with_latex_code(
        self,
        narrative: str,
        resources: List['ResourceInfo'],
        protected_zones: List['ProtectedZone'],
        context: str = ""
    ) -> str:
        """🤝 协作点：AI 叙述 + 硬编码 LaTeX 包装"""

        from .placeholder_parser import iter_placeholders, replace_spans
        from .table_generator import TableGenerator
        from .formula_generator import FormulaGenerator

        # 🔧 硬编码：构建资源占位符 -> LaTeX 代码映射
        latex_code_map: Dict[str, str] = {}
        for resource in resources:
            placeholder_id = self._resource_placeholder_id(resource)
            if resource.type == "figure":
                latex_code_map[placeholder_id] = self._generate_figure_latex(resource)
            elif resource.type == "code":
                latex_code_map[placeholder_id] = self._generate_code_latex(resource)
            elif resource.type == "reference":
                latex_code_map[placeholder_id] = self._generate_reference_latex(resource)

        # 🔧 硬编码：先替换资源占位符（支持 references:citekey 这种“虚拟路径”）
        result = narrative
        replacements: list[tuple[int, int, str]] = []
        for ph in iter_placeholders(result):
            if ph.kind != "resource" or not ph.resource_id:
                continue
            rep = latex_code_map.get(ph.resource_id)
            if rep is not None:
                replacements.append((ph.start, ph.end, rep))
        result = replace_spans(result, replacements)

        # 🔧 硬编码：再替换表格/公式占位符
        table_gen = TableGenerator(self.llm, self.config, self.templates)
        formula_gen = FormulaGenerator(self.templates)

        forbidden_table = ((self.config.get("security") or {}).get("table_security") or {}).get("forbidden_commands") or []
        forbidden_formula = ((self.config.get("security") or {}).get("formula_security") or {}).get("forbidden_commands") or []

        replacements = []
        for ph in iter_placeholders(result):
            if ph.kind == "table" and ph.description and ph.complexity:
                latex = table_gen.generate(ph.description, ph.complexity, context=context)
                latex = self._sanitize_generated_block(latex, forbidden_table)
                replacements.append((ph.start, ph.end, latex))
            elif ph.kind == "inline_math" and ph.formula:
                latex = formula_gen.inline(ph.formula)
                latex = self._sanitize_generated_block(latex, forbidden_formula)
                replacements.append((ph.start, ph.end, latex))
            elif ph.kind == "display_math" and ph.formula:
                latex = formula_gen.display(ph.formula)
                latex = self._sanitize_generated_block(latex, forbidden_formula)
                replacements.append((ph.start, ph.end, latex))
            elif ph.kind == "equation" and ph.formula and ph.label is not None:
                latex = formula_gen.equation(ph.formula, ph.label)
                latex = self._sanitize_generated_block(latex, forbidden_formula)
                replacements.append((ph.start, ph.end, latex))
            elif ph.kind == "align" and ph.formula:
                latex = formula_gen.align(ph.formula)
                latex = self._sanitize_generated_block(latex, forbidden_formula)
                replacements.append((ph.start, ph.end, latex))
        result = replace_spans(result, replacements)

        # 🔧 硬编码：验证格式区域未被破坏
        for zone in protected_zones:
            if zone.content not in result:
                from .format_guard import FormatProtectionError
                raise FormatProtectionError(
                    f"保护区域被破坏：{zone.name}\n"
                    f"原内容：{zone.content[:50]}..."
                )

        return result

    def _sanitize_generated_block(self, latex: str, forbidden_commands: List[str]) -> str:
        """对生成的 LaTeX 片段做最小化安全过滤（不做全局清理）。"""
        if not forbidden_commands:
            return latex
        sanitized_lines = []
        for line in latex.splitlines():
            if any(cmd in line for cmd in forbidden_commands):
                sanitized_lines.append(f"% 🚨 已自动移除不安全命令：{line}")
            else:
                sanitized_lines.append(line)
        return "\n".join(sanitized_lines)

    def _resource_placeholder_id(self, resource: 'ResourceInfo') -> str:
        """
        资源占位符的唯一 ID。
        - figure/code: 使用相对路径（figures/... / code/...)
        - reference: 使用 references:<citekey>（避免同一 .bib 下多个条目冲突）
        """
        if resource.type == "reference":
            citekey = (resource.metadata or {}).get("citekey") or resource.filename
            return f"references:{citekey}"
        return resource.path

    def _generate_figure_latex(self, resource: 'ResourceInfo') -> str:
        """硬编码：生成图片 LaTeX 代码"""
        from .template_renderer import render_template
        template = self.templates.get("figure_insertion",
            r"""\begin{figure}[htbp]
  \centering
  \includegraphics[width=0.8\textwidth]{{{path}}}
  \caption{{{caption}}}
  \label{{{label}}}
\end{figure}""")
        caption = resource.metadata.get("caption", "示例图片")
        # 从路径提取文件名作为标签
        label = resource.filename.replace('.', '_')
        return render_template(template, {"path": resource.path, "caption": caption, "label": label})

    def _generate_code_latex(self, resource: 'ResourceInfo') -> str:
        """硬编码：生成代码清单 LaTeX 代码"""
        # 读取代码片段
        code_snippet = self._read_code_snippet(resource.path, max_lines=20)
        lastline = max(1, len(code_snippet.splitlines()))

        from .template_renderer import render_template
        template = self.templates.get("code_listing",
            r"""\begin{lstlisting}[language={{lang}}, caption={{{caption}}}, firstline=1, lastline={{lastline}}]
{{code}}
\end{lstlisting}""")
        return render_template(template, {
            "lang": resource.metadata.get("language", "Python"),
            "code": code_snippet,
            "caption": f"示例代码：{resource.filename}",
            "lastline": lastline,
        })

    def _read_code_snippet(self, file_path: str, max_lines: int = 20) -> str:
        """读取代码片段"""
        try:
            # resource.path 是相对于 project_path 的路径
            base = getattr(self.guard, "project_path", Path("."))
            full_path = Path(base) / file_path
            if not full_path.exists():
                return f"% 文件不存在：{file_path}"

            lines = full_path.read_text(encoding='utf-8').split('\n')
            return '\n'.join(lines[:max_lines])
        except Exception as e:
            return f"% 读取失败：{e}"

    def _generate_reference_latex(self, resource: 'ResourceInfo') -> str:
        """硬编码：生成文献引用 LaTeX 代码"""
        citekey = resource.metadata.get("citekey", "unknown")
        return f"\\cite{{{citekey}}}"

    def _refine_content(
        self,
        content: str,
        theme: 'SectionTheme'
    ) -> str:
        """🧠 AI：自我检查和优化生成的内容"""

        prompt = f"""
你是一位严谨的学术写作评审专家。请检查以下生成的 LaTeX 内容。

## 章节主题
{theme.theme}

## 待检查内容
{content[:2000]}

## 检查项
1. 叙述是否连贯自然？
2. 资源引用是否合理？是否生硬？
3. 是否符合学术写作风格？
4. 有无语法或逻辑问题？
5. LaTeX 代码是否可能破坏格式？

## 输出要求
- 如果发现明显问题，返回优化后的完整内容
- 如果没有重大问题，返回 "OK"
- 如果有轻微问题但不影响整体，返回 "OK" 并在注释中指出

只返回结果，不要解释。
"""

        response = self.llm.complete(prompt, temperature=0.5)

        if response.strip() == "OK":
            return content
        else:
            # AI 返回了优化后的内容
            return response

    def _validate_format_preservation(
        self,
        protected_zones: List['ProtectedZone'],
        new_content: str
    ):
        """硬编码：验证格式区域未被破坏"""
        for zone in protected_zones:
            if zone.content not in new_content:
                from .format_guard import FormatProtectionError
                raise FormatProtectionError(
                    f"格式保护验证失败：{zone.name}\n"
                    f"保护内容：{zone.content[:50]}..."
                )

"""
Complete Example Skill - 基本使用示例
"""

import sys
from pathlib import Path

# 添加 skill 目录到路径
skill_root = Path(__file__).parent.parent
sys.path.insert(0, str(skill_root))

from scripts.skill_controller import CompleteExampleSkill


def main():
    """基本使用示例"""

    # 1. 加载配置
    import yaml
    config_path = skill_root / "config.yaml"

    with open(config_path, 'r', encoding='utf-8') as f:
        config = yaml.safe_load(f)

    config['skill_root'] = str(skill_root)

    # 2. 创建 skill 实例
    skill = CompleteExampleSkill(config)

    # 3. 执行（基本使用，AI 自动推断）
    result = skill.execute(
        project_name="NSFC_Young",
        options={
            "content_density": "moderate",
            "output_mode": "preview",
            "target_files": ["extraTex/2.1.研究内容.tex"]
        }
    )

    # 4. 查看结果
    print(f"执行状态：{result['final_result']}")
    print(f"运行 ID：{result['run_id']}")
    print(f"运行目录：{result['run_dir']}")

    if result['final_result'] == 'success':
        print("\n各阶段状态：")
        for stage_name, stage_data in result['stages'].items():
            print(f"  - {stage_name}: {stage_data['status']}")


if __name__ == "__main__":
    main()

"""
BibTeX Parser - BibTeX 解析工具
提供 BibTeX 文件解析和条目提取功能
"""

import re
from typing import List, Dict, Optional
from pathlib import Path


def parse_bibtex_file(file_path: Path) -> List[Dict[str, str]]:
    """
    解析 BibTeX 文件

    Args:
        file_path: BibTeX 文件路径

    Returns:
        List[Dict]: 条目列表，每个条目包含所有字段
    """
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()

    return parse_bibtex_content(content)


def parse_bibtex_content(content: str) -> List[Dict[str, str]]:
    """
    解析 BibTeX 内容

    Args:
        content: BibTeX 文件内容

    Returns:
        List[Dict]: 条目列表
    """
    entries = []

    # 匹配条目
    # 支持多行条目，包括嵌套的花括号
    entry_pattern = r'@(\w+)\s*\{([^,]+),\s*((?:[^@]|(?:\{[^{}]*\}))*)\}'

    # 为了正确处理嵌套的花括号，我们需要更复杂的解析
    # 这里使用简化的方法
    lines = content.split('\n')
    i = 0

    while i < len(lines):
        line = lines[i].strip()

        # 查找条目开始
        if line.startswith('@'):
            # 提取条目类型和键
            match = re.match(r'@(\w+)\s*\{([^,]+),', line)
            if match:
                entry_type = match.group(1)
                citekey = match.group(2)

                # 收集条目内容
                entry_content = line[match.end():]
                i += 1

                # 继续读取直到找到条目结束
                brace_count = entry_content.count('{') - entry_content.count('}')

                while i < len(lines) and brace_count > 0:
                    entry_content += '\n' + lines[i]
                    brace_count += lines[i].count('{') - lines[i].count('}')
                    i += 1

                # 解析字段
                entry = {
                    'key': citekey,
                    'type': entry_type
                }

                # 提取字段
                fields = extract_bibtex_fields(entry_content)
                entry.update(fields)

                entries.append(entry)
        else:
            i += 1

    return entries


def extract_bibtex_fields(content: str) -> Dict[str, str]:
    """
    从 BibTeX 条目内容中提取字段

    Args:
        content: 条目内容（不包含 @type{key, 部分）

    Returns:
        Dict[str, str]: 字段字典
    """
    fields = {}

    # 匹配字段
    # 字段格式：field_name = {value} 或 field_name = "value"
    field_pattern = r'(\w+)\s*=\s*(?:\{([^}]*)\}|"([^"]*)")'

    matches = re.finditer(field_pattern, content)
    for match in matches:
        field_name = match.group(1)
        # 值可能在 group(2) 或 group(3)
        field_value = match.group(2) if match.group(2) is not None else match.group(3)
        fields[field_name] = field_value

    return fields


def extract_bibtex_entries(file_path: Path, entry_type: Optional[str] = None) -> List[Dict[str, str]]:
    """
    提取 BibTeX 条目

    Args:
        file_path: BibTeX 文件路径
        entry_type: 条目类型过滤（可选），如 "article", "book" 等

    Returns:
        List[Dict]: 条目列表
    """
    entries = parse_bibtex_file(file_path)

    if entry_type:
        entries = [e for e in entries if e.get('type') == entry_type]

    return entries


def find_bibtex_entry_by_key(file_path: Path, citekey: str) -> Optional[Dict[str, str]]:
    """
    根据 citekey 查找条目

    Args:
        file_path: BibTeX 文件路径
        citekey: 引用键

    Returns:
        Optional[Dict]: 找到的条目，如果未找到则返回 None
    """
    entries = parse_bibtex_file(file_path)

    for entry in entries:
        if entry.get('key') == citekey:
            return entry

    return None


def format_bibtex_entry(entry: Dict[str, str]) -> str:
    """
    将条目字典格式化为 BibTeX 字符串

    Args:
        entry: 条目字典

    Returns:
        str: BibTeX 格式的字符串
    """
    entry_type = entry.get('type', 'misc')
    citekey = entry.get('key', 'unknown')

    # 排除键和类型字段
    fields = {k: v for k, v in entry.items() if k not in ['key', 'type']}

    # 构建字段字符串
    field_strings = []
    for field_name, field_value in fields.items():
        field_strings.append(f"  {field_name} = {{{field_value}}}")

    fields_str = ',\n'.join(field_strings)

    return f"@{entry_type}{{{citekey},\n{fields_str}\n}}"


def validate_bibtex_syntax(content: str) -> tuple[bool, list[str]]:
    """
    验证 BibTeX 语法

    Args:
        content: BibTeX 内容

    Returns:
        tuple[bool, list[str]]: (是否有效, 错误列表)
    """
    errors = []

    try:
        entries = parse_bibtex_content(content)

        # 检查基本要求
        for entry in entries:
            # 检查必需字段（根据类型）
            entry_type = entry.get('type', '')

            if entry_type == 'article':
                required_fields = ['author', 'title', 'journal', 'year']
            elif entry_type == 'book':
                required_fields = ['author', 'title', 'publisher', 'year']
            elif entry_type == 'inproceedings':
                required_fields = ['author', 'title', 'booktitle', 'year']
            else:
                required_fields = ['title', 'year']

            for field in required_fields:
                if field not in entry or not entry[field]:
                    errors.append(f"条目 '{entry.get('key', 'unknown')}' 缺少必需字段：{field}")

    except Exception as e:
        errors.append(f"解析错误：{str(e)}")

    return len(errors) == 0, errors

"""
File Utils - 文件操作工具
提供安全的文件读写和备份功能
"""

from pathlib import Path
import shutil
from typing import Optional


def read_file_safe(file_path: Path, encoding: str = 'utf-8') -> Optional[str]:
    """
    安全读取文件

    Args:
        file_path: 文件路径
        encoding: 文件编码

    Returns:
        Optional[str]: 文件内容，如果读取失败则返回 None
    """
    try:
        path = Path(file_path)
        if not path.exists():
            return None

        return path.read_text(encoding=encoding)
    except Exception as e:
        print(f"读取文件失败：{file_path}，错误：{e}")
        return None


def write_file_safe(
    file_path: Path,
    content: str,
    encoding: str = 'utf-8',
    backup: bool = True
) -> bool:
    """
    安全写入文件

    Args:
        file_path: 文件路径
        content: 文件内容
        encoding: 文件编码
        backup: 是否在写入前备份

    Returns:
        bool: 是否成功
    """
    try:
        path = Path(file_path)

        # 备份原文件
        if backup and path.exists():
            backup_file(path)

        # 确保父目录存在
        path.parent.mkdir(parents=True, exist_ok=True)

        # 写入文件
        path.write_text(content, encoding=encoding)

        return True

    except Exception as e:
        print(f"写入文件失败：{file_path}，错误：{e}")
        return False


def backup_file(
    file_path: Path,
    backup_dir: Optional[Path] = None,
    suffix: str = '.backup'
) -> Optional[Path]:
    """
    备份文件

    Args:
        file_path: 文件路径
        backup_dir: 备份目录（如果为 None，则在原文件同目录下创建备份）
        suffix: 备份文件后缀

    Returns:
        Optional[Path]: 备份文件路径，如果失败则返回 None
    """
    try:
        path = Path(file_path)

        if not path.exists():
            return None

        # 确定备份文件路径
        if backup_dir is None:
            backup_path = path.with_suffix(path.suffix + suffix)
        else:
            backup_dir = Path(backup_dir)
            backup_dir.mkdir(parents=True, exist_ok=True)
            backup_path = backup_dir / f"{path.name}{suffix}"

        # 复制文件
        shutil.copy2(path, backup_path)

        return backup_path

    except Exception as e:
        print(f"备份文件失败：{file_path}，错误：{e}")
        return None


def create_directory(
    dir_path: Path,
    parents: bool = True,
    exist_ok: bool = True
) -> bool:
    """
    创建目录

    Args:
        dir_path: 目录路径
        parents: 是否创建父目录
        exist_ok: 如果目录已存在是否报错

    Returns:
        bool: 是否成功
    """
    try:
        path = Path(dir_path)
        path.mkdir(parents=parents, exist_ok=exist_ok)
        return True
    except Exception as e:
        print(f"创建目录失败：{dir_path}，错误：{e}")
        return False


def ensure_extension(file_path: Path, extension: str) -> Path:
    """
    确保文件有指定的扩展名

    Args:
        file_path: 文件路径
        extension: 扩展名（如 '.tex'）

    Returns:
        Path: 带正确扩展名的文件路径
    """
    path = Path(file_path)

    if not extension.startswith('.'):
        extension = '.' + extension

    if path.suffix != extension:
        return path.with_suffix(extension)

    return path


def get_relative_path(file_path: Path, base_path: Path) -> Path:
    """
    获取相对路径

    Args:
        file_path: 文件路径
        base_path: 基准路径

    Returns:
        Path: 相对路径
    """
    try:
        return Path(file_path).relative_to(Path(base_path))
    except ValueError:
        # 如果无法计算相对路径，返回绝对路径
        return Path(file_path).resolve()


def count_lines(file_path: Path) -> int:
    """
    统计文件行数

    Args:
        file_path: 文件路径

    Returns:
        int: 行数
    """
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            return sum(1 for _ in f)
    except Exception:
        return 0


def get_file_size(file_path: Path) -> int:
    """
    获取文件大小（字节）

    Args:
        file_path: 文件路径

    Returns:
        int: 文件大小（字节）
    """
    try:
        return Path(file_path).stat().st_size
    except Exception:
        return 0


def format_file_size(size_bytes: int) -> str:
    """
    格式化文件大小

    Args:
        size_bytes: 字节数

    Returns:
        str: 格式化的大小字符串
    """
    for unit in ['B', 'KB', 'MB', 'GB']:
        if size_bytes < 1024.0:
            return f"{size_bytes:.1f} {unit}"
        size_bytes /= 1024.0
    return f"{size_bytes:.1f} TB"

"""
FormatGuard - 硬编码格式守护器
🔧 硬编码：严格保护格式设置不被修改
🔒 集成 SecurityManager 增强安全保护
"""

import hashlib
import re
import shutil
import subprocess
import json
from pathlib import Path
from dataclasses import dataclass
from typing import List, Dict, Optional, Any
from datetime import datetime


class FormatProtectionError(Exception):
    """格式保护异常"""
    pass


class CompilationError(Exception):
    """编译异常"""
    pass


# 导入安全管理器
try:
    from .security_manager import SecurityManager, SecurityError
    SECURITY_MANAGER_AVAILABLE = True
except ImportError:
    SECURITY_MANAGER_AVAILABLE = False


@dataclass
class ProtectedZone:
    """受保护的格式区域"""
    name: str           # 区域名称
    start: int          # 起始位置
    end: int            # 结束位置
    content: str        # 原始内容
    line_number: int    # 行号


class FormatGuard:
    """硬编码：严格的格式保护机制"""

    # 受保护的 LaTeX 命令（正则模式）
    PROTECTED_PATTERNS = [
        r'\\setlength\{[^}]+\}\{[^}]+\}',           # \setlength{\parindent}{2em}
        r'\\geometry\{[^}]+\}',                      # \geometry{left=3cm,...}
        r'\\definecolor\{[^}]+\}\{[^}]+\}\{[^}]+\}', # \definecolor{MsBlue}{RGB}{...}
        r'\\setCJKfamilyfont\{[^}]+\}(\[[^]]*\])?\{[^}]+\}',  # 字体设置
        r'\\setmainfont(\[[^]]*\])?\{[^}]+\}',       # 英文字体
        r'\\titleformat\{[^}]+\}\{[^}]*\}\{[^}]*\}\{[^}]*\}\{[^}]*\}\{[^}]*\}',  # 标题格式
        r'\\setlist\[[^]]+\]\{[^}]+\}',             # \setlist[enumerate]{...}
        r'\\newcommand\{[^}]+\}',                    # 自定义命令
        r'\\renewcommand\{[^}]+\}',                  # 重定义命令
    ]

    def __init__(
        self,
        project_path: Path,
        run_dir: Path = None,
        enable_security_manager: bool = True,
        config: Optional[Dict[str, Any]] = None,
    ):
        """
        Args:
            project_path: 项目根目录（被保护的项目，不写入任何文件）
            run_dir: 运行目录（备份和日志放在这里，隔离项目污染）
            enable_security_manager: 是否启用增强安全管理器
        """
        self.project_path = Path(project_path)
        self.run_dir = Path(run_dir) if run_dir else self.project_path
        self.config = config or {}

        fp_cfg = (self.config.get("format_protection") or {})
        self.protected_files = list(fp_cfg.get("protected_files") or ["extraTex/@config.tex", "main.tex"])
        self.compile_verify_cfg = (fp_cfg.get("compile_verify") or {})
        self.compile_verify_enabled = bool(self.compile_verify_cfg.get("enabled", True))
        self.compile_engine = str(self.compile_verify_cfg.get("engine", "xelatex"))
        self.compile_timeout_sec = int(self.compile_verify_cfg.get("timeout", 60))

        self.format_hashes = self._compute_format_hashes()

        # 🔒 集成安全管理器
        self.security_manager: Optional[SecurityManager] = None
        if enable_security_manager and SECURITY_MANAGER_AVAILABLE:
            self.security_manager = SecurityManager(
                project_path=self.project_path,
                hash_file=self.project_path / ".format_hashes.json",
                config=self.config,
            )
            # 初始化哈希（如果不存在）
            if not self.security_manager.hash_file.exists():
                self.security_manager.initialize_hashes()

    def _compute_format_hashes(self) -> Dict[str, str]:
        """计算关键格式文件的哈希值"""
        hashes = {}
        for file_path in self.protected_files:
            full_path = self.project_path / file_path
            if full_path.exists():
                content = full_path.read_text(encoding="utf-8")
                # 提取格式定义行
                format_lines = self._extract_format_lines(content)
                hashes[file_path] = hashlib.sha256(
                    "".join(format_lines).encode()
                ).hexdigest()
        return hashes

    def _extract_format_lines(self, content: str) -> List[str]:
        """提取格式定义行"""
        lines = content.split("\n")
        format_lines = []

        for line in lines:
            # 检查是否包含受保护的命令
            for pattern in self.PROTECTED_PATTERNS:
                if re.search(pattern, line):
                    format_lines.append(line)
                    break

        return format_lines

    def extract_protected_zones(self, content: str) -> List[ProtectedZone]:
        """
        🔧 硬编码：使用正则提取保护区域

        Args:
            content: 文件内容

        Returns:
            List[ProtectedZone]: 保护区域列表
        """
        zones = []
        lines = content.split("\n")

        for line_no, line in enumerate(lines, 1):
            for pattern in self.PROTECTED_PATTERNS:
                matches = re.finditer(pattern, line)
                for match in matches:
                    zones.append(ProtectedZone(
                        name="format_definition",
                        start=match.start(),
                        end=match.end(),
                        content=match.group(0),
                        line_number=line_no
                    ))

        return zones

    def validate_format_integrity(self) -> Dict[str, bool]:
        """
        🔧 硬编码：验证格式未被篡改

        Returns:
            Dict: {文件路径: 是否完整}
        """
        results = {}
        current_hashes = self._compute_format_hashes()

        for file_path, original_hash in self.format_hashes.items():
            current_hash = current_hashes.get(file_path)
            results[file_path] = (current_hash == original_hash)

        return results

    def safe_modify_file(
        self,
        file_path: Path,
        new_content: str,
        ai_explanation: str = None,
        auto_sanitize: bool = True,
        compile_verify: Optional[bool] = None,
    ) -> Optional[Path]:
        """
        🤝 协作点：AI 建议修改 + 硬编码安全检查
        🔒 集成安全管理器进行预检查

        Args:
            file_path: 要修改的文件路径
            new_content: 新内容
            ai_explanation: AI 对修改的解释
            auto_sanitize: 是否自动清理格式注入

        Returns:
            Optional[Path]: 备份文件路径；失败时抛异常

        Raises:
            FormatProtectionError: 格式保护失败
            CompilationError: 编译失败
            SecurityError: 安全检查失败（通过 SecurityManager）
        """
        file_path = Path(file_path)

        # 仅允许修改 project_path 内的文件，避免路径穿越/误写到仓库外。
        try:
            file_path.resolve().relative_to(self.project_path.resolve())
        except Exception:
            raise FormatProtectionError(f"拒绝修改项目目录之外的文件：{file_path}")

        # ========== 🔒 安全管理器预检查 ==========
        if self.security_manager:
            # 1. 系统文件黑名单 + 完整性校验
            self.security_manager.pre_edit_check(file_path)

            # 2. 格式注入检查 + 自动清理
            new_content = self.security_manager.pre_apply_check(
                file_path, new_content, auto_sanitize
            )

        # 检查是否为受保护文件（受 config.yaml 控制）
        try:
            relative_path = file_path.resolve().relative_to(self.project_path.resolve()).as_posix()
        except ValueError:
            relative_path = str(file_path)

        if relative_path in self.protected_files:
            raise FormatProtectionError(
                f"拒绝修改受保护文件：{relative_path}\n"
                f"AI 解释：{ai_explanation or '未提供'}"
            )

        # ========== 阶段 1：硬编码 - 备份 ==========
        # 🆕 备份到 .complete_example/<run_id>/backups/ 而非项目目录
        backup_dir = self.run_dir / "backups"
        backup_filename = f"{relative_path.replace('/', '_')}.backup"
        backup_path = backup_dir / backup_filename
        backup_path.parent.mkdir(parents=True, exist_ok=True)
        shutil.copy(file_path, backup_path)

        # ========== 阶段 2：硬编码 - 检查格式区域 ==========
        old_content = file_path.read_text(encoding="utf-8")
        protected_zones = self.extract_protected_zones(old_content)

        for zone in protected_zones:
            if zone.content not in new_content:
                # 🧠 AI：尝试诊断
                diagnosis = self._ai_diagnose_format_loss(
                    zone, old_content, new_content
                )

                # 🧠 AI：尝试修复
                fixed_content = self._ai_attempt_fix(
                    new_content, zone, diagnosis
                )

                # 如果还是失败，回滚
                if zone.content not in fixed_content:
                    shutil.copy(backup_path, file_path)
                    raise FormatProtectionError(
                        f"格式保护失败，已回滚\n"
                        f"破坏区域：{zone.name} (第 {zone.line_number} 行)\n"
                        f"原内容：{zone.content}\n"
                        f"AI 诊断：{diagnosis}\n"
                        f"AI 解释：{ai_explanation or '未提供'}"
                    )
                else:
                    new_content = fixed_content

        # ========== 阶段 3：硬编码 - 应用修改 ==========
        file_path.write_text(new_content, encoding="utf-8")

        # ========== 阶段 4：硬编码 - 编译验证（可按批次外部统一执行） ==========
        do_compile = self.compile_verify_enabled if compile_verify is None else bool(compile_verify)
        if do_compile and not self.compile_verify_project():
            shutil.copy(backup_path, file_path)
            raise CompilationError(
                "编译失败，已回滚\n"
                f"修改的文件：{file_path}\n"
                f"AI 解释：{ai_explanation or '未提供'}"
            )

        # ========== 阶段 5：成功，记录 ==========
        self._log_modification(
            file_path, backup_path, ai_explanation
        )

        return backup_path

    def _ai_diagnose_format_loss(
        self,
        zone: ProtectedZone,
        old_content: str,
        new_content: str
    ) -> str:
        """🧠 AI：诊断格式丢失的原因"""
        # 简化版本：返回硬编码的诊断
        return f"格式定义 '{zone.content[:30]}...' 在新内容中未找到"

    def _ai_attempt_fix(
        self,
        new_content: str,
        zone: ProtectedZone,
        diagnosis: str
    ) -> str:
        """🧠 AI：尝试修复格式丢失"""
        # 简化版本：直接插入原格式
        # 实际版本可以让 AI 分析上下文并智能插入
        return new_content  # 不做修改，让外部处理

    def compile_verify_project(self) -> bool:
        """
        硬编码：项目级编译验证（尽量避免污染项目根目录）。

        说明：
        - 使用 `-output-directory` 将 aux/pdf 等产物写入本次 run_dir 的构建目录；
          项目根目录仍作为 cwd，保证相对路径（extraTex/、figures/、references/）可解析。
        - 按仓库约定执行 4 步：xelatex → bibtex → xelatex → xelatex（如检测到 bibtex 需求）。
        """
        if not self.compile_verify_enabled:
            return True

        project_root = self.project_path
        main_tex = project_root / "main.tex"
        if not main_tex.exists():
            return False

        build_dir = self.run_dir / "_latex_build"
        build_dir.mkdir(parents=True, exist_ok=True)

        log_file = self.run_dir / "logs" / "compile.log"
        log_file.parent.mkdir(parents=True, exist_ok=True)

        def _append_log(title: str, result: subprocess.CompletedProcess[str]):
            with open(log_file, "a", encoding="utf-8") as f:
                f.write(f"\n\n===== {title} =====\n")
                f.write(result.stdout or "")
                f.write("\n\n=== STDERR ===\n")
                f.write(result.stderr or "")

        def _run(cmd: List[str], title: str) -> bool:
            try:
                result = subprocess.run(
                    cmd,
                    cwd=project_root,
                    capture_output=True,
                    timeout=self.compile_timeout_sec,
                    text=True,
                )
                _append_log(title, result)
                return result.returncode == 0
            except subprocess.TimeoutExpired:
                with open(log_file, "a", encoding="utf-8") as f:
                    f.write(f"\n\n===== {title} =====\n编译超时（{self.compile_timeout_sec}秒）\n")
                return False
            except Exception as e:
                with open(log_file, "a", encoding="utf-8") as f:
                    f.write(f"\n\n===== {title} =====\n编译异常：{e}\n")
                return False

        # 清空旧日志，避免混淆
        log_file.write_text("", encoding="utf-8")

        engine = self.compile_engine
        # 1) xelatex
        if not _run([engine, "-interaction=nonstopmode", f"-output-directory={build_dir}", "main.tex"], f"{engine} #1"):
            return False

        # 2) bibtex（仅在 aux 声明了 bibdata 时运行）
        aux_file = build_dir / "main.aux"
        need_bibtex = False
        if aux_file.exists():
            try:
                aux_text = aux_file.read_text(encoding="utf-8", errors="ignore")
                need_bibtex = "\\bibdata" in aux_text
            except Exception:
                need_bibtex = False

        if need_bibtex:
            # bibtex 需要从项目根目录解析 references/*.bib 的相对路径：
            # 优先使用“相对路径”参数，避免 TeX 安全策略（openout_any）阻止写入绝对路径 *.blg/*.bbl。
            try:
                bibtex_target = (build_dir / "main").resolve().relative_to(project_root.resolve()).as_posix()
            except Exception:
                bibtex_target = None

            if bibtex_target:
                if not _run(["bibtex", bibtex_target], "bibtex"):
                    return False
            else:
                with open(log_file, "a", encoding="utf-8") as f:
                    f.write("\n\n===== bibtex =====\n跳过：build_dir 不在项目目录内，无法安全运行 bibtex。\n")

        # 3) xelatex
        if not _run([engine, "-interaction=nonstopmode", f"-output-directory={build_dir}", "main.tex"], f"{engine} #2"):
            return False

        # 4) xelatex
        if not _run([engine, "-interaction=nonstopmode", f"-output-directory={build_dir}", "main.tex"], f"{engine} #3"):
            return False

        return True

    def _log_modification(
        self,
        file_path: Path,
        backup_path: Path,
        ai_explanation: str
    ):
        """🆕 记录修改日志到 .complete_example/<run_id>/logs/"""
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "file": str(file_path),
            "backup": str(backup_path),
            "ai_explanation": ai_explanation or "未提供"
        }
        # 🆕 写入 .complete_example/<run_id>/logs/execution.log 而非项目目录
        log_file = self.run_dir / "logs" / "execution.log"
        log_file.parent.mkdir(parents=True, exist_ok=True)
        with open(log_file, "a", encoding="utf-8") as f:
            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")