/**
 * AI 写作前端 hook —— LangGraph Server 路径（阶段 3）。
 *
 * 对外 API 与老 hook ``useAIWriting`` 完全一致：返回
 * ``{ state, startWriting, submitIntervention, pauseWriting, resumeWriting, reset }``，
 * 所以 ``AIWritingPanel`` 只需要按 env 开关切 import，不用改任何组件。
 *
 * 底层差别（参见 ai-writing-优化.md §阶段 3）：
 *   - 老 hook 走 ``POST /start`` + ``GET /{id}/stream`` + ``POST /{id}/resume`` 自写 SSE
 *   - 本 hook 用 ``@langchain/langgraph-sdk/react`` 的 ``useStream``，assistant=``ai_writing``，
 *     thread 和 SSE 协议都交给 LangGraph Server 管。``resume`` 改成 ``Command(resume=...)``。
 *
 * 事件翻译层：
 *   - LangGraph ``custom`` 通道（节点 ``get_stream_writer`` 推） →
 *     ``ProgressEvent`` { type=draft_chunk/outline_chunk/research_progress/review_chunk/review_item_done }
 *   - LangGraph ``updates`` 通道（节点 return 的 state delta） → 合成
 *     ``materials_ready`` / ``outline_ready`` / ``draft_ready`` / ``review_ready`` /
 *     ``notice`` / ``step_*`` （后端节点把这些塞进 ``progress_events`` 数组里 return）
 *   - ``stream.interrupt`` → ``await_user`` 事件
 *
 * 这样 reducer 逻辑（INITIAL_STATE + switch 各分支）与老 hook 共享同一份代码，
 * 只换"事件源"。阶段 7 删冗余时把老 hook 整个删掉就行。
 */
import { countArticleWords } from '../utils/wordCount';
import type {
  AIWritingRequest,
  AIWritingState,
  AIMaterial,
  AIOutline,
  BlockedSection,
  CompletedIntervention,
  ParsedIntent,
  ProgressEvent,
  ProgressEventType,
  ReviewIssue,
  ReviewResult,
  SkillSearchStep,
  StreamingReviewItem,
  UserInterventionPayload,
  WritingStatus,
} from '../types/ai-writing';

const INITIAL_STATE: AIWritingState = {
  sessionId: null,
  status: 'idle',
  request: null,
  isPaused: false,
  progressEvents: [],
  materials: [],
  outline: null,
  currentDraftMarkdown: '',
  currentDraftTitle: '',
  reviewResult: null,
  sampleStyleProfile: null,
  revisionCount: 0,
  currentPause: null,
  completedInterventions: [],
  error: null,
  streamingDraftTitle: '',
  streamingDraftSections: [],
  outlineStreamingText: '',
  outlineThinkingText: '',
  sampleAnalysisStreamingText: '',
  sampleAnalysisThinkingText: '',
  intentStreamingText: '',
  intentThinkingText: '',
  parsedIntent: null,
  researchProgress: '',
  keywordStreamingText: '',
  keywordThinkingText: '',
  skillSearchSteps: [],
  skillSelectStreamingText: '',
  skillSelectThinkingText: '',
  skillSearchPending: false,
  streamingReviewItems: [],
  revisionSummary: null,
  pendingRevisionContext: null,
  isRevising: false,
};

export { INITIAL_STATE };

// reducer action：HANDLE 直接复用老 hook 的 handleEvent switch；剩下的 action 处理
// 启动 / 干预提交 / 暂停 / 恢复 / 重置 这些"指令式"状态变更。
export type Action =
  | { type: 'handle'; event: ProgressEvent }
  | { type: 'handle_batch'; events: ProgressEvent[] }
  | { type: 'start'; request: AIWritingRequest }
  | { type: 'set_session'; sessionId: string }
  | { type: 'intervention_submitted'; record: CompletedIntervention; nextStatus: WritingStatus; pendingRevisionContext: AIWritingState['pendingRevisionContext']; materialSource?: AIWritingRequest['materialSource'] }
  | { type: 'pause' }
  | { type: 'resume_ui' }
  // Restore history: rebuild state from the graph checkpoint values snapshot.
  | { type: 'rehydrate'; snapshot: Partial<AIWritingState> }
  // 手动「继续」从检查点重跑当前阶段前，清空该阶段的流式缓冲（避免与重跑的新输出粘连）。
  | { type: 'clear_streaming' }
  | { type: 'reset' }
  | { type: 'set_error'; message: string };

export function reducer(prev: AIWritingState, action: Action): AIWritingState {
  switch (action.type) {
    case 'handle':
      return handleEvent(prev, action.event);

    case 'handle_batch':
      return action.events.reduce(handleEvent, prev);

    case 'start':
      return {
        ...INITIAL_STATE,
        status: action.request.writingModeType === 'imitate' ? 'analyzing_sample' : 'researching',
        request: action.request,
      };

    case 'set_session':
      return { ...prev, sessionId: action.sessionId };

    case 'intervention_submitted': {
      const ns = action.nextStatus;
      // 点击瞬间标记技能检索 pending，让 SkillStepsCard 占位卡立即挂载。
      // 通用检索现在统一走技能编排：素材确认卡上任何回到 researching 的动作
      // （重新搜索 / 按输入追加检索）都会产生 skill_search_step 流。
      const enablingSkillSearch =
        action.record.action === 'enable_skill_search' ||
        (ns === 'researching' && action.record.pausePoint === 'material_confirm');
      return {
        ...prev,
        currentPause: null,
        status: ns,
        skillSearchPending: enablingSkillSearch ? true : prev.skillSearchPending,
        ...(ns === 'researching' ? {
          researchProgress: '',
          keywordStreamingText: '',
          keywordThinkingText: '',
          skillSearchSteps: [],
          skillSelectStreamingText: '',
          skillSelectThinkingText: '',
        } : {}),
        ...(ns === 'writing_outline' ? { outlineStreamingText: '', outlineThinkingText: '' } : {}),
        ...(ns === 'writing_draft' ? { streamingDraftSections: [], streamingDraftTitle: '' } : {}),
        ...(ns === 'reviewing' ? { streamingReviewItems: [] } : {}),
        // 进入「修改」：右侧画布恢复初始空占位（isRevising），不再显示旧稿/流式重写
        ...(ns === 'revising' ? { streamingDraftSections: [], streamingDraftTitle: '', isRevising: true } : {}),
        ...(action.materialSource && prev.request
          ? { request: { ...prev.request, materialSource: action.materialSource } }
          : {}),
        completedInterventions: [...prev.completedInterventions, action.record],
        pendingRevisionContext: action.pendingRevisionContext,
      };
    }

    case 'pause':
      return { ...prev, isPaused: true };

    case 'resume_ui':
      return { ...prev, isPaused: false };

    case 'rehydrate':
      // Restore history: layer checkpoint snapshot over INITIAL_STATE.
      return { ...INITIAL_STATE, ...action.snapshot, isPaused: false };

    case 'clear_streaming':
      // 「继续」重跑当前阶段：清掉各阶段流式缓冲，重跑的输出从干净状态累积。
      return {
        ...prev,
        isPaused: false,
        sampleAnalysisStreamingText: '', sampleAnalysisThinkingText: '',
        intentStreamingText: '', intentThinkingText: '',
        outlineStreamingText: '', outlineThinkingText: '',
        streamingDraftSections: [], streamingDraftTitle: '',
        streamingReviewItems: [],
        keywordStreamingText: '', keywordThinkingText: '',
        skillSelectStreamingText: '', skillSelectThinkingText: '',
      };

    case 'reset':
      return INITIAL_STATE;

    case 'set_error':
      return { ...prev, status: 'error', error: action.message };

    default:
      return prev;
  }
}

// 把"正在流式生成"的草稿章节拼成 Markdown，用于边写边推送到右侧画布。
// 拼接格式与后端 writer_draft.py 的 _assemble() 对齐（# 文章标题 / ## 章节标题），
// 但这里是流式预览版：最终的 draft_ready 仍会用后端规范化后的完整 markdown 覆盖。
export function assembleStreamingDraftMarkdown(
  sections: AIWritingState['streamingDraftSections'],
  title: string,
): string {
  const ordered = [...sections].sort((a, b) => a.sectionIndex - b.sectionIndex);
  const body = ordered
    .map((s) => {
      const heading = s.sectionTitle ? `## ${s.sectionTitle}` : '';
      const text = s.text ?? '';
      return heading ? `${heading}\n\n${text}` : text;
    })
    .filter((part) => part.trim().length > 0)
    .join('\n\n');
  const head = title ? `# ${title}\n\n` : '';
  return `${head}${body}`;
}

// 与老 hook 行为对齐的事件 reducer —— 直接从 useAIWriting.ts 移植，删掉 setArtifact 副作用
// （副作用单独提到 hook 顶层 useEffect 里处理）。
function handleEvent(prev: AIWritingState, event: ProgressEvent): AIWritingState {
  const base: AIWritingState = {
    ...prev,
    progressEvents: [...prev.progressEvents, event],
  };

  switch (event.type) {
    case 'step_start':
      if (event.agentName === '编辑' && prev.status !== 'reviewing') {
        return { ...base, status: 'reviewing' };
      }
      return base;

    case 'step_done':
      return base;

    case 'sample_chunk': {
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      return {
        ...prev,
        sampleAnalysisStreamingText: isThinking ? prev.sampleAnalysisStreamingText : prev.sampleAnalysisStreamingText + text,
        sampleAnalysisThinkingText: isThinking ? prev.sampleAnalysisThinkingText + text : prev.sampleAnalysisThinkingText,
      };
    }

    case 'intent_chunk': {
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      return {
        ...prev,
        intentStreamingText: isThinking ? prev.intentStreamingText : prev.intentStreamingText + text,
        intentThinkingText: isThinking ? prev.intentThinkingText + text : prev.intentThinkingText,
      };
    }

    case 'intent_ready': {
      const ev = event as unknown as {
        articleType?: string;
        article_type?: string;
        targetAudience?: string;
        target_audience?: string;
        wordCountTarget?: number;
        word_count_target?: number;
        refinedIntent?: string;
        refined_intent?: string;
      };
      const parsed: ParsedIntent = {
        articleType: ev.articleType ?? ev.article_type ?? '',
        targetAudience: ev.targetAudience ?? ev.target_audience ?? '',
        wordCountTarget: Number(ev.wordCountTarget ?? ev.word_count_target ?? 800),
        refinedIntent: ev.refinedIntent ?? ev.refined_intent ?? '',
      };
      return {
        ...base,
        parsedIntent: parsed,
        intentStreamingText: '',
        intentThinkingText: '',
      };
    }

    case 'research_progress':
      return { ...base, researchProgress: event.message ?? '' };

    case 'keyword_chunk': {
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      const visibleText = text || (prev.keywordStreamingText ? '' : ' ');
      return {
        ...prev,
        status: 'researching',
        keywordStreamingText: isThinking ? prev.keywordStreamingText : prev.keywordStreamingText + visibleText,
        keywordThinkingText: isThinking ? prev.keywordThinkingText + text : prev.keywordThinkingText,
      };
    }

    case 'sample_profile_ready':
      return {
        ...base,
        sampleStyleProfile: event.sampleStyleProfile ?? null,
        sampleAnalysisStreamingText: '',
        sampleAnalysisThinkingText: '',
        status: 'researching',
      };

    case 'resumed':
      return { ...base, currentPause: null };

    case 'skill_search_step': {
      const step = event.skillStep;
      if (!step) return base;
      // select_skills 步骤到达 = LLM 选择完成，清空流式打字缓冲
      const clearStreaming = step.type === 'select_skills'
        ? { skillSelectStreamingText: '', skillSelectThinkingText: '' }
        : {};
      return { ...base, skillSearchSteps: [...prev.skillSearchSteps, step], ...clearStreaming };
    }

    case 'skill_select_chunk': {
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      return {
        ...prev,
        skillSelectStreamingText: isThinking ? prev.skillSelectStreamingText : prev.skillSelectStreamingText + text,
        skillSelectThinkingText: isThinking ? prev.skillSelectThinkingText + text : prev.skillSelectThinkingText,
      };
    }

    case 'materials_ready': {
      // 后端把 pkg.skill_search_steps 一并塞回来时，覆盖前端累积（保证刷新页面回放也对）
      const incomingSteps = (event as unknown as { skillSearchSteps?: SkillSearchStep[] }).skillSearchSteps;
      return {
        ...base,
        materials: (event.materials ?? []) as AIMaterial[],
        researchProgress: '',
        keywordStreamingText: '',
        keywordThinkingText: '',
        ...(incomingSteps ? { skillSearchSteps: incomingSteps } : {}),
      };
    }

    case 'outline_chunk': {
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      return {
        ...prev,
        status: 'writing_outline',
        outlineStreamingText: isThinking ? prev.outlineStreamingText : prev.outlineStreamingText + text,
        outlineThinkingText: isThinking ? prev.outlineThinkingText + text : prev.outlineThinkingText,
      };
    }

    case 'outline_ready':
      return {
        ...base,
        outline: (event.outline ?? null) as AIOutline | null,
        outlineStreamingText: '',
        outlineThinkingText: '',
      };

    case 'draft_chunk': {
      const idx = (event as unknown as { sectionIndex: number }).sectionIndex ?? 0;
      const title = (event as unknown as { sectionTitle: string }).sectionTitle ?? '';
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      const done = (event as unknown as { isSectionDone: boolean }).isSectionDone ?? false;
      const sections = prev.streamingDraftSections.map((s) => ({ ...s }));
      const existing = sections.find((s) => s.sectionIndex === idx);
      if (existing) {
        if (isThinking) existing.thinkingText += text;
        else existing.text += text;
        existing.isDone = done;
      } else {
        sections.push({
          sectionIndex: idx,
          sectionTitle: title,
          text: isThinking ? '' : text,
          thinkingText: isThinking ? text : '',
          isDone: done,
        });
      }
      const streamingTitle = prev.streamingDraftTitle || prev.outline?.title || '';
      // 流式阶段只累积章节片段；右侧 Markdown 由面板按需拼装，避免每 chunk 改 currentDraftMarkdown
      // 触发 DraftSync / 全树重渲染导致更新风暴。
      return {
        ...prev,
        status: 'writing_draft',
        streamingDraftSections: sections,
        streamingDraftTitle: streamingTitle,
        currentDraftTitle: streamingTitle || prev.currentDraftTitle,
      };
    }

    case 'review_chunk': {
      const category = (event as unknown as { category: StreamingReviewItem['category'] }).category;
      const text = (event as unknown as { text: string }).text ?? '';
      const isThinking = (event as unknown as { is_thinking: boolean }).is_thinking ?? false;
      const isNewCycle = prev.status !== 'reviewing';
      const items = (isNewCycle ? [] : prev.streamingReviewItems).map((it) => ({ ...it }));
      let item = items.find((it) => it.category === category);
      if (!item) {
        item = { category, isDone: false, streamingText: '', thinkingText: '', score: 0, issues: [] };
        items.push(item);
      }
      if (isThinking) item.thinkingText += text;
      else item.streamingText += text;
      return { ...prev, status: 'reviewing', streamingReviewItems: items };
    }

    case 'review_item_done': {
      const category = event.reviewItemCategory ?? 'fact';
      const items = prev.streamingReviewItems.map((it) => ({ ...it }));
      const item = items.find((it) => it.category === category);
      if (item) {
        item.isDone = true;
        item.score = event.reviewItemScore ?? 80;
        item.issues = event.reviewItemIssues ?? [];
      } else {
        items.push({
          category, isDone: true, streamingText: '', thinkingText: '',
          score: event.reviewItemScore ?? 80,
          issues: event.reviewItemIssues ?? [],
        });
      }
      return { ...prev, status: 'reviewing', streamingReviewItems: items };
    }

    case 'draft_ready': {
      const newMarkdown = event.draftMarkdown ?? '';
      const newWordCount = countArticleWords(newMarkdown);
      const summary = prev.pendingRevisionContext
        ? {
            revisedIssues: prev.pendingRevisionContext.submittedIssues,
            skippedIssues: prev.pendingRevisionContext.skippedIssues,
            oldWordCount: prev.pendingRevisionContext.oldWordCount,
            newWordCount,
          }
        : null;
      return {
        ...base,
        currentDraftMarkdown: newMarkdown,
        currentDraftTitle: event.draftTitle ?? '',
        revisionCount: event.revisionCount ?? 0,
        streamingDraftSections: [],
        streamingDraftTitle: '',
        revisionSummary: summary,
        pendingRevisionContext: null,
        // 修改完成：解除右侧空占位，展示新成稿
        isRevising: false,
      };
    }

    case 'review_ready':
      return { ...base, reviewResult: (event.reviewResult ?? null) as ReviewResult | null };

    case 'await_user': {
      const pp = event.pausePoint;
      if (prev.currentPause?.pausePoint === pp) return prev;
      const pauseStatus = pp ? (`awaiting_${pp}` as AIWritingState['status']) : prev.status;
      const extra: Partial<AIWritingState> = {};
      if (pp === 'material_confirm' && event.materials?.length) extra.materials = event.materials;
      if (pp === 'outline_confirm' && event.outline) extra.outline = event.outline;
      // 进入素材确认（material_confirm）= 技能检索（如果在进行）已经完成，清掉 pending 占位
      const clearPending = pp === 'material_confirm' ? { skillSearchPending: false } : {};
      return { ...base, ...extra, ...clearPending, status: pauseStatus, currentPause: event };
    }

    case 'done':
      return { ...base, status: 'done', currentPause: null };

    case 'error': {
      const msg = event.detail
        ? `${event.title ?? '出错了'}：${event.detail}`
        : (event.message ?? '未知错误');
      return { ...base, status: 'error', error: msg };
    }

    case 'notice':
      return base;

    case 'model_switch': {
      // 模型自动容错：丢弃当前阶段已累积的流式缓冲，避免上一个失败模型的半截输出
      // 与下一个模型的输出粘在一起；时间线展示侧由 TimelineStep 按 amber 渲染（同 notice）。
      const stage = event.modelSwitch?.stage;
      const sectionIndex = event.modelSwitch?.sectionIndex;
      const resetByStage: Partial<AIWritingState> = (() => {
        switch (stage) {
          case 'intent':
            return { intentStreamingText: '', intentThinkingText: '' };
          case 'outline':
            return { outlineStreamingText: '', outlineThinkingText: '' };
          case 'draft': {
            // 只清掉失败那一节的流式片段，已写好的章节保持不动
            if (typeof sectionIndex === 'number') {
              return {
                streamingDraftSections: prev.streamingDraftSections.filter(
                  (s) => s.sectionIndex !== sectionIndex,
                ),
              };
            }
            return { streamingDraftSections: [], streamingDraftTitle: '' };
          }
          case 'review':
            return { streamingReviewItems: [] };
          default:
            return {};
        }
      })();
      return { ...base, ...resetByStage };
    }

    default:
      return base;
  }
}

// ── snake_case ↔ camelCase 归一化（custom 通道事件 + interrupt payload） ──────

export function normalizeMaterial(m: Record<string, unknown>): AIMaterial {
  const extra = (m.extra_metadata ?? m.extraMetadata) as Record<string, unknown> | undefined;
  return {
    id: String(m.id ?? ''),
    title: String(m.title ?? ''),
    content: String(m.content ?? ''),
    source: String(m.source ?? ''),
    publishedAt: String(m.published_at ?? m.publishedAt ?? ''),
    relevanceScore: Number(m.relevance_score ?? m.relevanceScore ?? 0),
    sourceType: (m.source_type ?? m.sourceType ?? 'internet') as AIMaterial['sourceType'],
    url: m.url as string | undefined,
    recUuid: (m.recUuid ?? m.rec_uuid) as string | undefined,
    extraMetadata: extra,
  };
}

function normalizeSkillStep(s: Record<string, unknown>): SkillSearchStep {
  return {
    type: (s.type as SkillSearchStep['type']) ?? 'invoke_skill',
    message: String(s.message ?? ''),
    skillNames: (s.skill_names ?? s.skillNames) as string[] | undefined,
    skillName: (s.skill_name ?? s.skillName) as string | undefined,
    reason: s.reason as string | undefined,
    matchedCount: (s.matched_count ?? s.matchedCount) as number | undefined,
  };
}

function normalizeOutlineSection(s: Record<string, unknown>) {
  return {
    sectionTitle: String(s.section_title ?? s.sectionTitle ?? ''),
    keyPoints: (s.key_points ?? s.keyPoints ?? []) as string[],
    materialIds: (s.material_ids ?? s.materialIds ?? []) as string[],
  };
}

export function normalizeOutline(o: unknown): AIOutline | null {
  if (!o || typeof o !== 'object') return null;
  const obj = o as Record<string, unknown>;
  return {
    title: String(obj.title ?? ''),
    sections: Array.isArray(obj.sections) ? obj.sections.map((s) => normalizeOutlineSection(s as Record<string, unknown>)) : [],
  };
}

function normalizeReviewIssue(i: Record<string, unknown>): ReviewIssue {
  return {
    category: (i.category as ReviewIssue['category']) ?? 'fact',
    severity: (i.severity as ReviewIssue['severity']) ?? 'minor',
    location: String(i.location ?? ''),
    issue: String(i.issue ?? ''),
    suggestion: String(i.suggestion ?? ''),
  };
}

export function normalizeReviewResult(r: unknown): ReviewResult | null {
  if (!r || typeof r !== 'object') return null;
  const o = r as Record<string, unknown>;
  return {
    verdict: (o.verdict as 'pass' | 'reject') ?? 'pass',
    factScore: Number(o.fact_score ?? o.factScore ?? 0),
    logicScore: Number(o.logic_score ?? o.logicScore ?? 0),
    languageScore: Number(o.language_score ?? o.languageScore ?? 0),
    overallScore: Number(o.overall_score ?? o.overallScore ?? 0),
    passThreshold: Number(o.pass_threshold ?? o.passThreshold ?? 75),
    revisionNotes: Array.isArray(o.revision_notes ?? o.revisionNotes)
      ? ((o.revision_notes ?? o.revisionNotes) as Array<Record<string, unknown>>).map(normalizeReviewIssue)
      : [],
  };
}

const REHYDRATE_PAUSE_MESSAGES: Record<CompletedIntervention['pausePoint'], string> = {
  material_confirm: '素材收集专家已完成素材搜集，请确认素材后继续。',
  outline_confirm: '作家已完成大纲规划，请确认或编辑大纲后继续。',
  draft_confirm: '草稿已完成，请确认或给出修改意见。',
  review_confirm: '编辑认为文章需要修改，请决定下一步操作。',
  section_help: '部分章节缺少足够素材支撑写作，请决定如何处理。',
};

function normalizePausePoint(value: unknown): CompletedIntervention['pausePoint'] | null {
  const pausePoint = String(value ?? '');
  switch (pausePoint) {
    case 'material_confirm':
    case 'outline_confirm':
    case 'draft_confirm':
    case 'review_confirm':
    case 'section_help':
      return pausePoint;
    default:
      return null;
  }
}

function classifyResumedMessage(message: string): Pick<CompletedIntervention, 'pausePoint' | 'action'> | null {
  const m = message || '';
  if (m.includes('确认素材')) return { pausePoint: 'material_confirm', action: 'confirm' };
  if (m.includes('匹配技能检索') || m.includes('重新检索') || m.includes('重新搜索')) {
    return { pausePoint: 'material_confirm', action: 're_search' };
  }
  if (m.includes('采用你提供的大纲')) return { pausePoint: 'material_confirm', action: 'confirm' };
  if (m.includes('确认大纲')) return { pausePoint: 'outline_confirm', action: 'confirm' };
  if (m.includes('重新规划大纲')) return { pausePoint: 'outline_confirm', action: 're_outline' };
  if (m.includes('提交编辑审核')) return { pausePoint: 'draft_confirm', action: 'to_editor' };
  if (m.includes('强制定稿')) return { pausePoint: 'review_confirm', action: 'force_finalize' };
  if (m.includes('确认定稿')) return { pausePoint: 'draft_confirm', action: 'finalize' };
  if (m.includes('按用户意见重写')) return { pausePoint: 'draft_confirm', action: 'user_revise' };
  if (m.includes('按编辑意见重写')) return { pausePoint: 'review_confirm', action: 'accept_review' };
  if (m.includes('补充检索素材')) return { pausePoint: 'section_help', action: 'supplement' };
  if (m.includes('继续写作') || m.includes('按你的选择继续写作')) {
    return { pausePoint: 'section_help', action: 'loose' };
  }
  return null;
}

function materialsFromValues(values: AIWritingValues): AIMaterial[] {
  const pkg = values.material_package && typeof values.material_package === 'object'
    ? values.material_package as Record<string, unknown>
    : null;
  return pkg && Array.isArray(pkg.materials)
    ? (pkg.materials as Record<string, unknown>[]).map(normalizeMaterial)
    : [];
}

function draftFromValues(values: AIWritingValues): Record<string, unknown> | null {
  return values.current_draft && typeof values.current_draft === 'object'
    ? values.current_draft as Record<string, unknown>
    : null;
}

export function buildCompletedInterventionFromCheckpointPause(
  values: AIWritingValues,
  pausePointValue: unknown,
  actionValue: unknown,
): CompletedIntervention | null {
  const pausePoint = normalizePausePoint(pausePointValue);
  if (!pausePoint) return null;

  const action = String(actionValue || 'confirm');
  const record: CompletedIntervention = { pausePoint, action };

  if (pausePoint === 'material_confirm') {
    record.materials = materialsFromValues(values);
  } else if (pausePoint === 'outline_confirm') {
    record.outline = normalizeOutline(values.current_outline) ?? undefined;
  } else if (pausePoint === 'draft_confirm') {
    const draft = draftFromValues(values);
    record.draftTitle = String(draft?.title ?? '');
    const wordCount = Number(draft?.word_count ?? draft?.wordCount ?? 0);
    record.draftWordCount = wordCount > 0
      ? wordCount
      : countArticleWords(String(draft?.full_markdown ?? draft?.fullMarkdown ?? ''));
    record.reviewResult = normalizeReviewResult(values.review_result) ?? undefined;
  } else if (pausePoint === 'review_confirm') {
    record.reviewResult = normalizeReviewResult(values.review_result) ?? undefined;
  }

  return record;
}

export function buildAwaitUserEventFromCheckpointPause(
  values: AIWritingValues,
  sessionId: string,
  pausePointValue: unknown,
  interruptValue?: unknown,
): ProgressEvent | null {
  const pausePoint = normalizePausePoint(pausePointValue);
  if (!pausePoint) return null;

  const intr = interruptValue && typeof interruptValue === 'object'
    ? interruptValue as Record<string, unknown>
    : {};
  const draft = draftFromValues(values);
  const event: ProgressEvent = {
    type: 'await_user',
    sessionId,
    message: String(intr.message ?? REHYDRATE_PAUSE_MESSAGES[pausePoint]),
    pausePoint,
  };

  if (pausePoint === 'material_confirm') {
    event.materials = Array.isArray(intr.materials)
      ? (intr.materials as Record<string, unknown>[]).map(normalizeMaterial)
      : materialsFromValues(values);
  } else if (pausePoint === 'outline_confirm') {
    event.outline = normalizeOutline(intr.outline ?? values.current_outline) ?? undefined;
  } else if (pausePoint === 'draft_confirm') {
    event.draftTitle = String(intr.draft_title ?? draft?.title ?? '');
    event.revisionCount = Number(intr.revision_count ?? draft?.revision_count ?? draft?.revisionCount ?? 0);
    event.reviewResult = normalizeReviewResult(intr.review_result ?? values.review_result) ?? undefined;
  } else if (pausePoint === 'review_confirm') {
    event.reviewResult = normalizeReviewResult(intr.review_result ?? values.review_result) ?? undefined;
  } else if (pausePoint === 'section_help' && Array.isArray(intr.blocked_sections)) {
    event.blockedSections = (intr.blocked_sections as Record<string, unknown>[]).map(normalizeBlockedSection);
  }

  return event;
}

function buildRehydrateTimeline(values: AIWritingValues, sessionId: string): {
  progressEvents: ProgressEvent[];
  completedInterventions: CompletedIntervention[];
} {
  const rawEvents = Array.isArray(values.progress_events)
    ? (values.progress_events as Record<string, unknown>[]).map((e) => normalizeProgressDict(e, sessionId))
    : [];
  const progressEvents: ProgressEvent[] = [];
  const completedInterventions: CompletedIntervention[] = [];

  for (const event of rawEvents) {
    if (event.type === 'resumed') {
      const classified = classifyResumedMessage(event.message);
      if (classified) {
        const pauseEvent = buildAwaitUserEventFromCheckpointPause(values, sessionId, classified.pausePoint);
        const record = buildCompletedInterventionFromCheckpointPause(
          values,
          classified.pausePoint,
          classified.action,
        );
        if (pauseEvent) progressEvents.push(pauseEvent);
        if (record) completedInterventions.push(record);
      }
    }
    progressEvents.push(event);
  }

  return { progressEvents, completedInterventions };
}

function normalizeBlockedSection(b: Record<string, unknown>): BlockedSection {
  return {
    sectionTitle: String(b.section_title ?? b.sectionTitle ?? ''),
    reason: String(b.reason ?? ''),
  };
}

/** 把后端节点 ``progress_events`` 数组里的一条 dict 翻译成前端 ProgressEvent。
 *
 * 幂等：对已是 camelCase 的前端事件再跑一遍基本不变（snake_case 键不存在即跳过），
 * 所以历史回显时可无脑对**整条** transcript 跑一遍——既归一后台存的 raw 事件，又
 * 不破坏前端实时存的事件。 */
export function normalizeProgressDict(parsed: Record<string, unknown>, sessionId: string): ProgressEvent {
  const out: Record<string, unknown> = { ...parsed, sessionId };

  if ('agent_name' in out) out.agentName = out.agent_name;
  if ('pause_point' in out) out.pausePoint = out.pause_point;

  if (Array.isArray(out.materials)) out.materials = (out.materials as Record<string, unknown>[]).map(normalizeMaterial);
  if (out.outline) out.outline = normalizeOutline(out.outline);

  if (Array.isArray(out.blocked_sections)) {
    out.blockedSections = (out.blocked_sections as Record<string, unknown>[]).map(normalizeBlockedSection);
  }

  // draft_ready: 节点 emit 的字段是 draft_markdown / draft_title
  if ('draft_markdown' in out && !out.draftMarkdown) out.draftMarkdown = out.draft_markdown;
  if ('draft_title' in out && !out.draftTitle) out.draftTitle = out.draft_title;
  if ('markdown' in out && !out.draftMarkdown) out.draftMarkdown = out.markdown;
  if ('title' in out && !out.draftTitle) out.draftTitle = out.title;
  if ('revision_count' in out) out.revisionCount = out.revision_count;

  if (out.review_result) out.reviewResult = normalizeReviewResult(out.review_result);
  if (out.reviewResult && !out.review_result) out.reviewResult = normalizeReviewResult(out.reviewResult);

  if (out.sample_style_profile && !out.sampleStyleProfile) {
    const p = out.sample_style_profile as Record<string, unknown>;
    out.sampleStyleProfile = {
      summary: p.summary as string | undefined,
      articleTypeGuess: (p.article_type_guess ?? p.articleTypeGuess) as string | undefined,
      tone: p.tone as string | undefined,
      structure: (p.structure as string[] | undefined) ?? [],
      languageFeatures: (p.language_features ?? p.languageFeatures ?? []) as string[],
      sentenceStyle: (p.sentence_style ?? p.sentenceStyle) as string | undefined,
      openingStyle: (p.opening_style ?? p.openingStyle) as string | undefined,
      endingStyle: (p.ending_style ?? p.endingStyle) as string | undefined,
      imitationGuidance: (p.imitation_guidance ?? p.imitationGuidance ?? []) as string[],
      avoidCopying: (p.avoid_copying ?? p.avoidCopying ?? []) as string[],
      sampleOutline: (p.sample_outline ?? p.sampleOutline ?? []) as string[],
    };
  }

  if ('category' in out) out.reviewItemCategory = out.category;
  if ('score' in out) out.reviewItemScore = out.score;
  if ('issues' in out && Array.isArray(out.issues)) {
    out.reviewItemIssues = (out.issues as Record<string, unknown>[]).map(normalizeReviewIssue);
  }

  // model_switch（updates 通道里的 progress_events 也可能带）：折成 modelSwitch 子对象
  if (out.type === 'model_switch' && !out.modelSwitch) {
    out.modelSwitch = {
      stage: (out.stage as 'intent' | 'outline' | 'draft' | 'review') ?? 'intent',
      failedModel: String(out.failed_model ?? out.failedModel ?? ''),
      nextModel: String(out.next_model ?? out.nextModel ?? ''),
      reason: String(out.reason ?? ''),
      sectionIndex: typeof out.section_index === 'number'
        ? (out.section_index as number)
        : (typeof out.sectionIndex === 'number' ? (out.sectionIndex as number) : undefined),
      sectionTitle: typeof out.section_title === 'string'
        ? (out.section_title as string)
        : (typeof out.sectionTitle === 'string' ? (out.sectionTitle as string) : undefined),
    };
  }

  if (!out.message) out.message = '';
  return out as unknown as ProgressEvent;
}

/** Restore history: rebuild a frontend state snapshot from graph checkpoint values.
 *
 * ``status`` 后端与前端共用同一套字面量（state.py WritingStatus ↔ types/ai-writing.ts），可直接
 * 透传；timeline 由累积的 ``progress_events``（operator.add 全量）重放，素材/大纲/草稿/审核读各自
 * 快照字段。pause 点（currentPause）由 ``stream.interrupt`` 的既有 effect / host 另行设置。 */
export function buildRehydrateSnapshot(values: AIWritingValues, sessionId: string): Partial<AIWritingState> {
  const pkg = (values.material_package && typeof values.material_package === 'object')
    ? (values.material_package as Record<string, unknown>) : null;
  const materials = pkg && Array.isArray(pkg.materials)
    ? (pkg.materials as Record<string, unknown>[]).map(normalizeMaterial) : [];
  const skillSteps = pkg && Array.isArray(pkg.skill_search_steps ?? pkg.skillSearchSteps)
    ? ((pkg.skill_search_steps ?? pkg.skillSearchSteps) as Record<string, unknown>[]).map(normalizeSkillStep) : [];
  const draft = (values.current_draft && typeof values.current_draft === 'object')
    ? (values.current_draft as Record<string, unknown>) : null;
  const { progressEvents, completedInterventions } = buildRehydrateTimeline(values, sessionId);
  const sampleProfileEvent = values.sample_style_profile
    ? normalizeProgressDict({ type: 'sample_profile_ready', sample_style_profile: values.sample_style_profile }, sessionId)
    : null;

  return {
    sessionId,
    status: (values.status as AIWritingState['status']) || 'researching',
    materials,
    skillSearchSteps: skillSteps,
    outline: normalizeOutline(values.current_outline),
    currentDraftMarkdown: String(draft?.full_markdown ?? draft?.fullMarkdown ?? ''),
    currentDraftTitle: String(draft?.title ?? ''),
    revisionCount: Number(draft?.revision_count ?? draft?.revisionCount ?? 0),
    reviewResult: normalizeReviewResult(values.review_result),
    sampleStyleProfile: sampleProfileEvent?.sampleStyleProfile ?? null,
    progressEvents,
    completedInterventions,
  };
}

/** custom 通道事件 → ProgressEvent。事件 ``type`` 字段决定是哪类。 */
export function customToProgressEvent(raw: unknown, sessionId: string): ProgressEvent | null {
  if (!raw || typeof raw !== 'object') return null;
  const o = raw as Record<string, unknown>;
  const type = String(o.type ?? '');
  // 后端 _save_draft_to_repo 等 helper 不走 custom 通道，type 必为节点 emit 的 chunk 类型
  if (!type) return null;

  // 技能检索步骤：后端 _emit_skill_step 以 `writer({"type": "skill_search_step", **step})`
  // 发出，但 **step 里也有 type（invoke_skill / list_skills / skill_result / select_skills /
  // match_skills / skill_error / fallback / stop_early），会**覆盖**掉外层的 "skill_search_step"。
  // 所以 custom 事件实际 type 是这些内层值。这里按内层 step 类型识别，**实时**归一成
  // skill_search_step 事件（与素材包快照里的 step 同格式），让技能调用过程一步步进时间线，
  // 而不是被这里的白名单丢弃、只在节点结束的快照里一次性出现。
  const SKILL_STEP_TYPES = [
    'list_skills', 'match_skills', 'select_skills', 'invoke_skill',
    'skill_result', 'skill_error', 'fallback', 'stop_early',
  ];
  if (SKILL_STEP_TYPES.includes(type)) {
    return {
      type: 'skill_search_step',
      sessionId,
      message: String(o.message ?? ''),
      agentName: (o.agent_name ?? o.agentName) as string | undefined,
      skillStep: normalizeSkillStep(o),
    } as unknown as ProgressEvent;
  }

  const allowed: ProgressEventType[] = [
    'intent_chunk', 'intent_ready',
    'sample_chunk',
    'sample_profile_ready',
    'research_progress', 'keyword_chunk', 'outline_chunk', 'draft_chunk',
    'review_chunk', 'review_item_done',
    'skill_search_step', 'skill_select_chunk',
    'model_switch',
  ];
  if (!allowed.includes(type as ProgressEventType)) return null;
  if (type === 'sample_profile_ready') return normalizeProgressDict(o, sessionId);

  // 共通：原样保留所有字段（is_thinking / text / section_index / section_title / category / score / issues）
  const merged: Record<string, unknown> = { ...o, sessionId, message: o.message ?? '' };
  // draft_chunk / outline_chunk 用 camelCase 字段名（reducer 期望）
  if ('section_index' in merged) merged.sectionIndex = merged.section_index;
  if ('section_title' in merged) merged.sectionTitle = merged.section_title;
  if ('is_section_done' in merged) merged.isSectionDone = merged.is_section_done;
  if ('category' in merged) merged.reviewItemCategory = merged.category;
  if ('score' in merged) merged.reviewItemScore = merged.score;
  if (Array.isArray(merged.issues)) {
    merged.reviewItemIssues = (merged.issues as Record<string, unknown>[]).map(normalizeReviewIssue);
  }
  if ('agent_name' in merged && !merged.agentName) merged.agentName = merged.agent_name;
  // skill_search_step：把字段折成 skillStep 子对象，方便 reducer / UI 取用
  if (type === 'skill_search_step') {
    merged.skillStep = normalizeSkillStep(o);
  }
  // model_switch：把 snake_case 字段折成 modelSwitch 子对象（reducer + TimelineStep 取用）
  if (type === 'model_switch') {
    merged.modelSwitch = {
      stage: (o.stage as 'intent' | 'outline' | 'draft' | 'review') ?? 'intent',
      failedModel: String(o.failed_model ?? (o as Record<string, unknown>).failedModel ?? ''),
      nextModel: String(o.next_model ?? (o as Record<string, unknown>).nextModel ?? ''),
      reason: String(o.reason ?? ''),
      sectionIndex: typeof o.section_index === 'number'
        ? (o.section_index as number)
        : (typeof (o as Record<string, unknown>).sectionIndex === 'number'
          ? ((o as Record<string, unknown>).sectionIndex as number)
          : undefined),
      sectionTitle: typeof o.section_title === 'string'
        ? (o.section_title as string)
        : (typeof (o as Record<string, unknown>).sectionTitle === 'string'
          ? ((o as Record<string, unknown>).sectionTitle as string)
          : undefined),
    };
  }
  return merged as unknown as ProgressEvent;
}

/** updates 通道里的节点输出 → 一组 ProgressEvent（progress_events + *_ready 合成）。 */
export function nodeUpdatesToEvents(nodeOutput: unknown, sessionId: string): ProgressEvent[] {
  if (!nodeOutput || typeof nodeOutput !== 'object') return [];
  const out = nodeOutput as Record<string, unknown>;
  const events: ProgressEvent[] = [];

  // 节点 return 的 progress_events 数组（step_start / step_done / notice / draft_ready / outline_ready / review_ready / resumed / error）
  if (Array.isArray(out.progress_events)) {
    for (const e of out.progress_events as Record<string, unknown>[]) {
      events.push(normalizeProgressDict(e, sessionId));
    }
  }

  // ``material_package`` 出现 → materials_ready（节点 progress_events 里不带）
  if (out.material_package && typeof out.material_package === 'object') {
    const pkg = out.material_package as Record<string, unknown>;
    const skillSteps = Array.isArray(pkg.skill_search_steps ?? pkg.skillSearchSteps)
      ? ((pkg.skill_search_steps ?? pkg.skillSearchSteps) as Record<string, unknown>[]).map(normalizeSkillStep)
      : undefined;
    events.push({
      type: 'materials_ready',
      sessionId,
      message: '',
      materials: Array.isArray(pkg.materials) ? (pkg.materials as Record<string, unknown>[]).map(normalizeMaterial) : [],
      keywords: (pkg.keywords ?? []) as string[],
      materialSummary: (pkg.summary as string) ?? '',
      ...(skillSteps ? { skillSearchSteps: skillSteps } as unknown as Partial<ProgressEvent> : {}),
    } as ProgressEvent);
  }

  // ``current_outline`` 出现且 progress_events 里没 outline_ready → 合成一条
  if (out.current_outline && !events.some((e) => e.type === 'outline_ready')) {
    const outline = normalizeOutline(out.current_outline);
    if (outline) events.push({ type: 'outline_ready', sessionId, message: '', outline });
  }

  // ``review_result`` 出现且 progress_events 里没 review_ready → 合成一条（带 reviewResult 字段）
  if (out.review_result) {
    const reviewResult = normalizeReviewResult(out.review_result);
    if (reviewResult) {
      // 如果 progress_events 里已有 review_ready（节点 emit 的）但字段不全，补上 reviewResult
      const existing = events.find((e) => e.type === 'review_ready');
      if (existing) {
        existing.reviewResult = reviewResult;
      } else {
        events.push({ type: 'review_ready', sessionId, message: '', reviewResult });
      }
    }
  }

  // ``current_draft`` 出现 → 补全 draft_ready 的 draftMarkdown / draftTitle / revisionCount
  if (out.current_draft && typeof out.current_draft === 'object') {
    const d = out.current_draft as Record<string, unknown>;
    const draftReady = events.find((e) => e.type === 'draft_ready');
    const ev: ProgressEvent = draftReady ?? { type: 'draft_ready', sessionId, message: '' };
    if (!ev.draftMarkdown) ev.draftMarkdown = (d.full_markdown ?? d.fullMarkdown ?? '') as string;
    if (!ev.draftTitle) ev.draftTitle = (d.title ?? '') as string;
    if (ev.revisionCount == null) ev.revisionCount = (d.revision_count ?? d.revisionCount ?? 0) as number;
    if (!draftReady) events.push(ev);
  }

  return events;
}

/** ``stream.interrupt.value`` → await_user ProgressEvent。 */
export function interruptToEvent(value: unknown, sessionId: string): ProgressEvent | null {
  if (!value || typeof value !== 'object') return null;
  const v = value as Record<string, unknown>;
  return {
    type: 'await_user',
    sessionId,
    message: String(v.message ?? ''),
    pausePoint: v.pause_point as ProgressEvent['pausePoint'],
    materials: Array.isArray(v.materials) ? (v.materials as Record<string, unknown>[]).map(normalizeMaterial) : undefined,
    keywords: v.keywords as string[] | undefined,
    materialSummary: v.summary as string | undefined,
    outline: v.outline ? (normalizeOutline(v.outline) as AIOutline) : undefined,
    reviewResult: v.review_result ? (normalizeReviewResult(v.review_result) as ReviewResult) : undefined,
    draftTitle: v.draft_title as string | undefined,
    revisionCount: v.revision_count as number | undefined,
    blockedSections: Array.isArray(v.blocked_sections)
      ? (v.blocked_sections as Record<string, unknown>[]).map(normalizeBlockedSection)
      : undefined,
  };
}

export type AIWritingValues = {
  user_intent?: string;
  user_outline_raw?: string;
  writing_mode_type?: string;
  sample_text?: string;
  sample_filename?: string;
  sample_style_profile?: unknown;
  imitate_strength?: string;
  preserve_sample_structure?: boolean;
  article_type?: string;
  /** 新（列表外）文章类型的一句话特征，仅本次写作临时使用。 */
  article_type_detail?: string;
  /** 是否加参考文献（正文 [n] 角标 + 文末「参考文献」列表）。 */
  add_references?: boolean;
  /** 不收集素材，直接用通用知识写作（researcher 节点据此短路跳过检索）。 */
  skip_research?: boolean;
  model_name?: string;
  status?: string;
  revision_count?: number;
  max_revisions?: number;
  blocked_sections?: unknown[];
  material_package?: unknown;
  current_outline?: unknown;
  current_draft?: unknown;
  review_result?: unknown;
  progress_events?: unknown[];
};