#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Chapter Analyzer - 章节自动解构与模式提取

功能：
1. 章节内容解析（场景分割、人物提取）
2. 张力曲线分析（情绪压强跟踪）
3. 爽点模式识别（打脸、降维、闭环、僭越）
4. 套路结构提取（铺垫→压抑→爆发→反转）
5. 学习成果输出（可复用模式）

用法：
    python chapter_analyzer.py --chapter-file "正文/第0003章-当众打脸.md" --project-root . --learn
"""

import re
import json
import hashlib
import sqlite3
from pathlib import Path
from dataclasses import dataclass, field, asdict
from typing import List, Dict, Any, Optional, Tuple
from datetime import datetime
from enum import Enum
import asyncio

try:
    from runtime_compat import enable_windows_utf8_stdio
except ImportError:
    enable_windows_utf8_stdio = lambda: None


class PatternType(Enum):
    """模式类型"""
    HOOK = "hook"               # 钩子
    PACING = "pacing"           # 节奏
    DIALOGUE = "dialogue"       # 对话
    PAYOFF = "payoff"           # 兑现
    EMOTION = "emotion"         # 情绪
    TENSION_BUILD = "tension_build"  # 压强积累
    RELEASE = "release"         # 释放
    TWIST = "twist"            # 反转


class CatharsisModel(Enum):
    """爽感模型"""
    TABOO_TRANSGRESSION = "taboo_transgression"    # 禁忌僭越
    OVERKILL_REVERSAL = "overkill_reversal"        # 降维打击
    COGNITIVE_CLOSURE = "cognitive_closure"         # 认知闭环


@dataclass
class TensionPoint:
    """张力点"""
    position: int        # 位置（字符偏移）
    tension: float       # 张力值 0-1
    event_type: str      # 事件类型
    description: str      # 描述


@dataclass
class HotSpot:
    """爽点"""
    position: int
    span: int           # 持续长度
    catharsis_type: str # 爽感类型
    intensity: float    # 强度 0-1
    description: str


@dataclass
class ChapterStructure:
    """章节结构"""
    setup: int = 0      # 铺垫段落长度
    suppress: int = 0   # 压抑段落长度
    release: int = 0    # 释放段落长度
    twist: int = 0      # 反转段落长度


@dataclass
class LearnedPattern:
    """学习到的模式"""
    pattern_id: str
    pattern_type: str
    title: str
    description: str
    tension_curve: List[List[float]]  # [[position, tension], ...]
    catharsis_model: str
    structure: Dict[str, int]
    hot_spots: List[List[Any]]
    style_tags: List[str]
    source_project: str
    source_chapter: int
    learned_at: str
    usage_count: int = 0
    metadata: Dict[str, Any] = field(default_factory=dict)


@dataclass
class ChapterAnalysisResult:
    """章节分析结果"""
    chapter: int
    title: str
    word_count: int
    scene_count: int
    character_count: int

    # 张力分析
    tension_curve: List[List[float]]  # [[position, tension], ...]
    tension_avg: float
    tension_peak: float
    tension_peak_position: int

    # 爽点分析
    hot_spots: List[HotSpot]
    catharsis_model: str

    # 结构分析
    structure: ChapterStructure

    # 模式
    detected_patterns: List[str]

    # 风格标签
    style_tags: List[str]

    # 人物出场
    characters: List[str]

    # 建议
    suggestions: List[str]


class ChapterAnalyzer:
    """
    章节分析器

    自动解构章节，提取：
    - 张力曲线
    - 爽点位置和类型
    - 套路结构
    - 可复用模式
    """

    # 爽点关键词
    HOT_SPOT_KEYWORDS = {
        CatharsisModel.OVERKILL_REVERSAL: [
            "碾压", "秒杀", "不堪一击", "一招", "跪下", "颤抖", "惊恐",
            "脸色大变", "难以置信", "怎么可能", "废物", "蝼蚁", "打脸",
            "当众", "所有人", "目瞪口呆", "鸦雀无声", "死寂"
        ],
        CatharsisModel.TABOO_TRANSGRESSION: [
            "禁忌", "僭越", "突破底线", "危险", "禁忌", "邪魅", "诱惑",
            "堕落", "黑化", "疯狂", "失控", "暴走", "越界", "禁忌"
        ],
        CatharsisModel.COGNITIVE_CLOSURE: [
            "原来", "竟然", "真相", "伏笔", "恍然大悟", "所有一切",
            "早该", "早就在", "铺垫", "埋下", "算计", "布局"
        ]
    }

    # 情绪压强关键词
    TENSION_KEYWORDS = {
        # 压强上升
        "rise": ["紧张", "危机", "危险", "困境", "难题", "冲突", "对峙",
                 "杀意", "阴谋", "威胁", "危机", "悬念", "未知"],
        # 压强高峰
        "peak": ["爆发", "突破", "反击", "反转", "真相", "高潮", "决战",
                 "绝杀", "逆转", "翻盘", "打脸", "碾压"],
        # 压强下降
        "fall": ["松了口气", "终于", "安心", "胜利", "结束", "平息", "安然"]
    }

    def __init__(self, project_root: Optional[Path] = None):
        self.project_root = Path(project_root) if project_root else Path.cwd()

    def analyze_chapter(
        self,
        chapter_file: Path,
        chapter_num: Optional[int] = None
    ) -> ChapterAnalysisResult:
        """
        分析章节

        Args:
            chapter_file: 章节文件路径
            chapter_num: 章节号（从文件名推断或手动指定）

        Returns:
            章节分析结果
        """
        content = chapter_file.read_text(encoding="utf-8")

        # 解析章节号
        if chapter_num is None:
            chapter_num = self._extract_chapter_num(chapter_file.name)

        # 解析标题
        title = self._extract_title(chapter_file.name, content)

        # 统计字数
        word_count = len(content)

        # 场景分割
        scenes = self._split_scenes(content)
        scene_count = len(scenes)

        # 人物提取
        characters = self._extract_characters(content, scenes)

        # 张力曲线分析
        tension_curve = self._analyze_tension_curve(content, scenes)
        tension_avg = sum(p[1] for p in tension_curve) / len(tension_curve) if tension_curve else 0
        peak = max(tension_curve, key=lambda x: x[1]) if tension_curve else (0, 0)
        tension_peak = peak[1]
        tension_peak_position = peak[0]

        # 爽点分析
        hot_spots = self._detect_hot_spots(content, scenes)
        catharsis_model = self._detect_catharsis_model(hot_spots)

        # 结构分析
        structure = self._analyze_structure(content, scenes, hot_spots)

        # 模式检测
        detected_patterns = self._detect_patterns(
            content, scenes, tension_curve, hot_spots, structure
        )

        # 风格标签
        style_tags = self._extract_style_tags(content, tension_curve, hot_spots)

        # 建议
        suggestions = self._generate_suggestions(
            tension_curve, hot_spots, structure, detected_patterns
        )

        return ChapterAnalysisResult(
            chapter=chapter_num,
            title=title,
            word_count=word_count,
            scene_count=scene_count,
            character_count=len(characters),
            tension_curve=tension_curve,
            tension_avg=tension_avg,
            tension_peak=tension_peak,
            tension_peak_position=tension_peak_position,
            hot_spots=hot_spots,
            catharsis_model=catharsis_model,
            structure=structure,
            detected_patterns=detected_patterns,
            style_tags=style_tags,
            characters=characters,
            suggestions=suggestions
        )

    def _extract_chapter_num(self, filename: str) -> int:
        """从文件名提取章节号"""
        match = re.search(r'第(\d+)[章节]', filename)
        if match:
            return int(match.group(1))
        return 0

    def _extract_title(self, filename: str, content: str) -> str:
        """提取标题"""
        # 尝试从文件名提取
        match = re.search(r'第\d+章[章节]-?(.+)', filename)
        if match:
            return match.group(1).replace('.md', '').strip()

        # 尝试从内容第一行提取
        lines = content.split('\n')
        for line in lines[:5]:
            line = line.strip()
            if line.startswith('#'):
                return line.lstrip('#').strip()

        return filename.replace('.md', '')

    def _split_scenes(self, content: str) -> List[Dict[str, Any]]:
        """
        分割场景

        Returns:
            List[{"start": int, "end": int, "location": str, "characters": []}]
        """
        scenes = []
        lines = content.split('\n')

        current_scene = {
            "start": 0,
            "end": 0,
            "location": "未知",
            "characters": [],
            "lines": []
        }

        location_patterns = [
            r'^---+$',  # 分割线
            r'^【(.+?)】',  # 【场景名】
            r'^（(.+?)）',  # （场景名）
        ]

        for i, line in enumerate(lines):
            # 检测场景分隔
            is_divider = any(re.match(p, line.strip()) for p in location_patterns)

            if is_divider and current_scene["lines"]:
                # 保存当前场景
                current_scene["end"] = sum(len(l) + 1 for l in current_scene["lines"][:-1])
                scenes.append(current_scene)

                # 新场景
                location_match = re.search(r'【(.+?)】|（(.+?)）', line)
                current_scene = {
                    "start": sum(len(l) + 1 for l in lines[:i]) + 1,
                    "end": 0,
                    "location": location_match.group(1) if location_match else "未知",
                    "characters": [],
                    "lines": []
                }

            current_scene["lines"].append(line)

        # 保存最后一个场景
        if current_scene["lines"]:
            current_scene["end"] = len(content)
            scenes.append(current_scene)

        return scenes if scenes else [{"start": 0, "end": len(content), "location": "未知", "characters": [], "lines": content.split('\n')}]

    def _extract_characters(
        self,
        content: str,
        scenes: List[Dict[str, Any]]
    ) -> List[str]:
        """提取人物列表"""
        # 简单实现：提取引号内的对话人
        characters = set()

        # 匹配 "XXX说" 格式
        dialogue_pattern = re.compile(r'^"?([^"说]{2,5})"?[说问道喊叫笑骂冷哼]')
        for scene in scenes:
            for line in scene["lines"]:
                match = dialogue_pattern.match(line.strip())
                if match:
                    name = match.group(1).strip()
                    if name and len(name) <= 5:
                        characters.add(name)

        return list(characters)

    def _analyze_tension_curve(
        self,
        content: str,
        scenes: List[Dict[str, Any]]
    ) -> List[List[float]]:
        """
        分析张力曲线

        Returns:
            [[position, tension], ...] - 位置（字数）和张力值（0-1）
        """
        curve = []
        total_len = len(content)
        segment_size = 200  # 每200字一个采样点

        content_lower = content  # 网文不区分大小写

        for pos in range(0, total_len, segment_size):
            segment = content_lower[pos:pos + segment_size]
            tension = 0.0

            # 检查压强上升关键词
            for kw in self.TENSION_KEYWORDS["rise"]:
                if kw in segment:
                    tension += 0.2

            # 检查压强高峰关键词
            for kw in self.TENSION_KEYWORDS["peak"]:
                if kw in segment:
                    tension += 0.4

            # 检查压强下降关键词
            for kw in self.TENSION_KEYWORDS["fall"]:
                if kw in segment:
                    tension -= 0.15

            # 限制范围
            tension = max(0.0, min(1.0, tension))

            curve.append([pos, tension])

        # 平滑曲线
        curve = self._smooth_curve(curve)

        return curve

    def _smooth_curve(self, curve: List[List[float]]) -> List[List[float]]:
        """平滑张力曲线"""
        if len(curve) < 3:
            return curve

        smoothed = []
        for i, point in enumerate(curve):
            if i == 0 or i == len(curve) - 1:
                smoothed.append(point)
            else:
                # 移动平均
                avg_pos = (curve[i-1][0] + point[0] + curve[i+1][0]) / 3
                avg_tension = (curve[i-1][1] + point[1] + curve[i+1][1]) / 3
                smoothed.append([avg_pos, avg_tension])

        return smoothed

    def _detect_hot_spots(
        self,
        content: str,
        scenes: List[Dict[str, Any]]
    ) -> List[HotSpot]:
        """检测爽点"""
        hot_spots = []

        for model_type, keywords in self.HOT_SPOT_KEYWORDS.items():
            for keyword in keywords:
                # 查找所有出现位置
                start = 0
                while True:
                    pos = content.find(keyword, start)
                    if pos == -1:
                        break

                    # 计算附近区域的强度
                    context_start = max(0, pos - 100)
                    context_end = min(len(content), pos + 100)
                    context = content[context_start:context_end]

                    # 统计上下文中的情绪词数量
                    intensity = 0.5  # 基础强度
                    for kw_set in self.HOT_SPOT_KEYWORDS.values():
                        for kw in kw_set:
                            if kw in context:
                                intensity += 0.1

                    intensity = min(1.0, intensity)

                    # 避免重叠
                    span = len(keyword)
                    is_overlap = any(
                        abs(pos - hs.position) < span
                        for hs in hot_spots
                    )

                    if not is_overlap:
                        hot_spots.append(HotSpot(
                            position=pos,
                            span=span,
                            catharsis_type=model_type.value,
                            intensity=intensity,
                            description=f"发现「{keyword}」"
                        ))

                    start = pos + 1

        # 按位置排序
        hot_spots.sort(key=lambda x: x.position)

        return hot_spots

    def _detect_catharsis_model(
        self,
        hot_spots: List[HotSpot]
    ) -> str:
        """检测主导爽感模型"""
        if not hot_spots:
            return "unknown"

        model_counts = {}
        model_intensity = {}

        for hs in hot_spots:
            model = hs.catharsis_type
            model_counts[model] = model_counts.get(model, 0) + 1
            model_intensity[model] = model_intensity.get(model, 0) + hs.intensity

        # 综合评分：出现次数 * 0.4 + 强度 * 0.6
        scores = {
            m: model_counts[m] * 0.4 + model_intensity[m] * 0.6
            for m in model_counts
        }

        return max(scores, key=scores.get) if scores else "unknown"

    def _analyze_structure(
        self,
        content: str,
        scenes: List[Dict[str, Any]],
        hot_spots: List[HotSpot]
    ) -> ChapterStructure:
        """分析章节结构"""
        total_len = len(content)

        if not hot_spots:
            # 无爽点：均匀分布
            segment = total_len // 4
            return ChapterStructure(
                setup=segment,
                suppress=segment,
                release=segment,
                twist=segment
            )

        # 找第一个爽点位置作为分界
        first_hot = hot_spots[0].position
        last_hot = hot_spots[-1].position

        # 铺垫：第一个爽点之前
        setup = first_hot

        # 压抑+释放：根据爽点密集程度判断
        # 简化：中间区域前40%压抑，后40%释放
        middle_start = first_hot
        middle_end = last_hot + 100
        middle_len = middle_end - middle_start

        suppress = int(middle_len * 0.4)
        release = int(middle_len * 0.4)
        twist = total_len - middle_end

        return ChapterStructure(
            setup=max(0, setup),
            suppress=max(0, suppress),
            release=max(0, release),
            twist=max(0, twist)
        )

    def _detect_patterns(
        self,
        content: str,
        scenes: List[Dict[str, Any]],
        tension_curve: List[List[float]],
        hot_spots: List[HotSpot],
        structure: ChapterStructure
    ) -> List[str]:
        """检测章节中的模式"""
        patterns = []

        # 检测钩子模式
        if tension_curve and tension_curve[0][1] > 0.3:
            patterns.append("开篇高能钩")
        elif "？" in content[:200] or "！" in content[:200]:
            patterns.append("悬念钩子")

        # 检测打脸模式
        if any(hs.catharsis_type == "overkill_reversal" for hs in hot_spots):
            patterns.append("打脸反转")

        # 检测升级模式
        if any(kw in content for kw in ["突破", "晋升", "升级", "进阶"]):
            patterns.append("境界突破")

        # 检测装逼模式
        if any(kw in content for kw in ["冷笑", "不屑", "蝼蚁", "可笑"]):
            patterns.append("装逼打脸")

        # 张力曲线形状检测
        if tension_curve:
            # 持续上升 = 压抑型
            tensions = [p[1] for p in tension_curve]
            if tensions == sorted(tensions) and tensions[-1] - tensions[0] > 0.5:
                patterns.append("单线压抑")
            # 波动大 = 节奏快
            elif max(tensions) - min(tensions) > 0.6:
                patterns.append("爽点密集")

        return patterns

    def _extract_style_tags(
        self,
        content: str,
        tension_curve: List[List[float]],
        hot_spots: List[HotSpot]
    ) -> List[str]:
        """提取风格标签"""
        tags = []

        # 基于字数
        word_count = len(content)
        if word_count < 2000:
            tags.append("短小精悍")
        elif word_count > 5000:
            tags.append("长篇巨制")

        # 基于爽点密度
        if tension_curve:
            avg_tension = sum(p[1] for p in tension_curve) / len(tension_curve)
            if avg_tension > 0.5:
                tags.append("情绪压强高")
            elif avg_tension < 0.2:
                tags.append("节奏舒缓")

        # 基于爽点类型
        if hot_spots:
            model = self._detect_catharsis_model(hot_spots)
            if model == "overkill_reversal":
                tags.append("爽点密集")
            elif model == "taboo_transgression":
                tags.append("边缘拉扯")
            elif model == "cognitive_closure":
                tags.append("多线收束")

        # 基于对话比例
        dialogue_count = content.count('"') + content.count('"')
        dialogue_ratio = dialogue_count / max(word_count, 1)
        if dialogue_ratio > 0.3:
            tags.append("对话驱动")
        elif dialogue_ratio < 0.1:
            tags.append("叙事为主")

        return tags

    def _generate_suggestions(
        self,
        tension_curve: List[List[float]],
        hot_spots: List[HotSpot],
        structure: ChapterStructure,
        patterns: List[str]
    ) -> List[str]:
        """生成改进建议"""
        suggestions = []

        # 张力曲线建议
        if tension_curve:
            avg = sum(p[1] for p in tension_curve) / len(tension_curve)
            if avg < 0.2:
                suggestions.append("张力整体偏低，建议增加危机感或悬念")
            elif avg > 0.7:
                suggestions.append("张力持续偏高，建议适当释放避免读者疲劳")

        # 爽点建议
        if not hot_spots:
            suggestions.append("未检测到明显爽点，建议增加打脸/反转情节")

        # 结构建议
        if structure.setup < 500:
            suggestions.append("铺垫不足，建议增加背景/动机描写")

        # 节奏建议
        if "单线压抑" in patterns:
            suggestions.append("压抑较长，建议穿插小高潮保持节奏")

        return suggestions

    def learn_pattern(
        self,
        analysis: ChapterAnalysisResult,
        layer: str = "project"
    ) -> LearnedPattern:
        """
        从分析结果提取可学习模式

        Args:
            analysis: 章节分析结果
            layer: 存储层级 ("project" 或 "system")

        Returns:
            学习到的模式
        """
        pattern_id = hashlib.md5(
            f"{self.project_root.name}_{analysis.chapter}_{datetime.now().isoformat()}".encode()
        ).hexdigest()[:16]

        return LearnedPattern(
            pattern_id=pattern_id,
            pattern_type=self._infer_pattern_type(analysis),
            title=f"第{analysis.chapter}章模式: {analysis.title}",
            description=self._generate_description(analysis),
            tension_curve=analysis.tension_curve,
            catharsis_model=analysis.catharsis_model,
            structure=asdict(analysis.structure),
            hot_spots=[[hs.position, hs.description] for hs in analysis.hot_spots],
            style_tags=analysis.style_tags,
            source_project=self.project_root.name,
            source_chapter=analysis.chapter,
            learned_at=datetime.now().isoformat(),
            metadata={
                "word_count": analysis.word_count,
                "scene_count": analysis.scene_count,
                "character_count": analysis.character_count,
                "detected_patterns": analysis.detected_patterns,
                "suggestions": analysis.suggestions
            }
        )

    def _infer_pattern_type(self, analysis: ChapterAnalysisResult) -> str:
        """推断模式类型"""
        if "打脸反转" in analysis.detected_patterns:
            return PatternType.HOOK.value
        elif "境界突破" in analysis.detected_patterns:
            return PatternType.PAYOFF.value
        elif analysis.tension_avg > 0.5:
            return PatternType.TENSION_BUILD.value
        else:
            return PatternType.PACING.value

    def _generate_description(self, analysis: ChapterAnalysisResult) -> str:
        """生成模式描述"""
        parts = []

        if analysis.detected_patterns:
            parts.append(f"包含模式: {', '.join(analysis.detected_patterns[:3])}")

        if analysis.style_tags:
            parts.append(f"风格标签: {', '.join(analysis.style_tags[:3])}")

        parts.append(f"字数: {analysis.word_count}，场景: {analysis.scene_count}")

        if analysis.hot_spots:
            parts.append(f"检测到 {len(analysis.hot_spots)} 个爽点")

        return "; ".join(parts)

    def save_learned_pattern(
        self,
        pattern: LearnedPattern,
        layer: str = "project"
    ) -> bool:
        """保存学习到的模式"""
        try:
            if layer == "project":
                return self._save_to_project_db(pattern)
            else:
                return self._save_to_system(pattern)
        except Exception as e:
            print(f"Error saving pattern: {e}")
            return False

    def _init_project_learned_db(self) -> Path:
        """初始化项目学习库"""
        db_dir = self.project_root / ".noma" / "rag"
        db_dir.mkdir(parents=True, exist_ok=True)
        db_path = db_dir / "learned.db"

        conn = sqlite3.connect(str(db_path))
        cursor = conn.cursor()

        cursor.execute("""
            CREATE TABLE IF NOT EXISTS learned_patterns (
                pattern_id TEXT PRIMARY KEY,
                pattern_type TEXT NOT NULL,
                title TEXT NOT NULL,
                description TEXT,
                tension_curve TEXT,
                catharsis_model TEXT,
                structure TEXT,
                hot_spots TEXT,
                style_tags TEXT,
                source_project TEXT,
                source_chapter INTEGER,
                learned_at TEXT,
                usage_count INTEGER DEFAULT 0,
                metadata TEXT
            )
        """)

        conn.commit()
        conn.close()

        return db_path

    def _save_to_project_db(self, pattern: LearnedPattern) -> bool:
        """保存到项目数据库"""
        db_path = self._init_project_learned_db()

        conn = sqlite3.connect(str(db_path))
        cursor = conn.cursor()

        cursor.execute("""
            INSERT OR REPLACE INTO learned_patterns
            (pattern_id, pattern_type, title, description, tension_curve,
             catharsis_model, structure, hot_spots, style_tags,
             source_project, source_chapter, learned_at, usage_count, metadata)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            pattern.pattern_id,
            pattern.pattern_type,
            pattern.title,
            pattern.description,
            json.dumps(pattern.tension_curve),
            pattern.catharsis_model,
            json.dumps(pattern.structure),
            json.dumps(pattern.hot_spots),
            json.dumps(pattern.style_tags),
            pattern.source_project,
            pattern.source_chapter,
            pattern.learned_at,
            pattern.usage_count,
            json.dumps(pattern.metadata)
        ))

        conn.commit()
        conn.close()

        return True

    def _save_to_system(self, pattern: LearnedPattern) -> bool:
        """保存到系统共享库"""
        # 需要系统根目录
        system_root = self._resolve_system_root()
        learned_dir = system_root / "rag" / "learned"
        learned_dir.mkdir(parents=True, exist_ok=True)

        pattern_file = learned_dir / f"{pattern.pattern_id}.json"

        pattern_data = asdict(pattern)
        pattern_file.write_text(
            json.dumps(pattern_data, ensure_ascii=False, indent=2),
            encoding="utf-8"
        )

        return True

    def _resolve_system_root(self) -> Path:
        """解析系统根目录"""
        # 与 project_root 同级的 .noma
        sibling = self.project_root.parent / ".noma"
        if sibling.exists():
            return sibling

        return self.project_root / ".noma"


# ==================== CLI 接口 ====================

def main():
    import argparse
    import sys

    if sys.platform == "win32":
        enable_windows_utf8_stdio()

    parser = argparse.ArgumentParser(
        description="Chapter Analyzer - 章节自动解构与模式提取"
    )
    parser.add_argument("--project-root", type=str, default=".",
                        help="项目根目录")
    parser.add_argument("--chapter-file", type=str, required=True,
                        help="章节文件路径")
    parser.add_argument("--chapter-num", type=int,
                        help="章节号（可选，从文件名推断）")
    parser.add_argument("--learn", action="store_true",
                        help="学习并存储模式")
    parser.add_argument("--learn-layer", choices=["project", "system"],
                        default="project",
                        help="学习成果存储层级")
    parser.add_argument("--output", type=str,
                        help="输出文件（JSON格式）")

    args = parser.parse_args()

    project_root = Path(args.project_root).resolve()
    chapter_file = project_root / args.chapter_file

    if not chapter_file.exists():
        print(f"Error: Chapter file not found: {chapter_file}")
        sys.exit(1)

    # 分析章节
    analyzer = ChapterAnalyzer(project_root)
    result = analyzer.analyze_chapter(chapter_file, args.chapter_num)

    # 输出结果
    if args.output:
        output_path = Path(args.output)
        output_path.parent.mkdir(parents=True, exist_ok=True)
        output_path.write_text(
            json.dumps(asdict(result), ensure_ascii=False, indent=2),
            encoding="utf-8"
        )
        print(f"Analysis saved to: {output_path}")
    else:
        # 打印摘要
        print(f"\n{'='*60}")
        print(f"章节分析报告: 第{result.chapter}章 - {result.title}")
        print(f"{'='*60}")
        print(f"\n基本信息:")
        print(f"  字数: {result.word_count}")
        print(f"  场景数: {result.scene_count}")
        print(f"  人物数: {result.character_count}")
        print(f"  人物列表: {', '.join(result.characters[:5]) or '无'}")

        print(f"\n张力分析:")
        print(f"  平均张力: {result.tension_avg:.2f}")
        print(f"  峰值张力: {result.tension_peak:.2f} (位置: {result.tension_peak_position})")

        print(f"\n爽点分析:")
        print(f"  爽点数量: {len(result.hot_spots)}")
        print(f"  主导模型: {result.catharsis_model}")
        if result.hot_spots:
            print(f"  主要爽点:")
            for hs in result.hot_spots[:3]:
                print(f"    - [{hs.position}] {hs.description} ({hs.intensity:.2f})")

        print(f"\n结构分析:")
        print(f"  铺垫: {result.structure.setup}字")
        print(f"  压抑: {result.structure.suppress}字")
        print(f"  释放: {result.structure.release}字")
        print(f"  反转: {result.structure.twist}字")

        print(f"\n检测到的模式:")
        for p in result.detected_patterns:
            print(f"  - {p}")

        print(f"\n风格标签:")
        for t in result.style_tags:
            print(f"  - {t}")

        if result.suggestions:
            print(f"\n改进建议:")
            for s in result.suggestions:
                print(f"  - {s}")

    # 学习模式
    if args.learn:
        pattern = analyzer.learn_pattern(result, args.learn_layer)
        success = analyzer.save_learned_pattern(pattern, args.learn_layer)

        if success:
            print(f"\n✓ 模式已学习并存储到 {args.learn_layer} 层")
            print(f"  Pattern ID: {pattern.pattern_id}")
        else:
            print(f"\n✗ 模式存储失败")
            sys.exit(1)


if __name__ == "__main__":
    main()