import {
  BadRequestException,
  ForbiddenException,
  Inject,
  Injectable,
  NotFoundException,
  OnModuleInit,
  Optional
} from '@nestjs/common';
import type {
  Character,
  Episode,
  NovelChapter,
  PlotMemory,
  PlotThread,
  Prisma,
  Project,
  StoryBible
} from '@prisma/client';
import { createHash } from 'node:crypto';
import type { AuthRequestUser } from '../auth/auth.types';
import { PrismaService } from '../prisma/prisma.service';
import { assertPromptIsCleanV1, promptRuleLinesV1 } from '../production-kernel';
import { ProvidersService } from '../providers/providers.service';
import { toSafeRenderTask } from '../queues/task.types';
import { GenerateEpisodePlanDto, UpdateEpisodeDto } from './episode.dto';
import { EPISODE_STATUSES, toSafeEpisode, type EpisodeStatus } from './episode.types';

const MIN_EPISODES = 1;
const MAX_EPISODES = 100;
const MIN_DURATION = 15;
const MAX_DURATION = 600;
const DEFAULT_EPISODE_DURATION = 60;
const MIN_QUALITY_EPISODE_DURATION = 60;
const MAX_QUALITY_EPISODE_DURATION = 180;

interface EpisodeDraft {
  episode_no: number;
  source_chapter_ids: Prisma.InputJsonValue;
  title: string;
  summary: string;
  opening_hook: string;
  middle_conflict: string;
  ending_hook: string;
  target_duration: number;
  status: EpisodeStatus;
}

interface EpisodePlanContext {
  storyBible: StoryBible;
  characters: Character[];
  chapters: NovelChapter[];
  plotMemories: PlotMemory[];
  plotThreads: PlotThread[];
}

interface EpisodeOverviewItem {
  episode_no: number;
  title_hint: string;
  one_sentence: string;
  arc_stage: string;
  source_chapter_ids: string[];
  key_hook: string;
  must_use_memory: string[];
}

interface EpisodePlanPromptOverrides {
  overview?: string;
  batch?: string;
  reconcile?: string;
}

interface EpisodePlanRequestParamsOverride {
  max_output_tokens?: number;
  temperature?: number;
  timeout_ms?: number;
}

interface EpisodePlanQualityBrief {
  score: number;
  issues: string[];
}

interface EpisodeCountRecommendation {
  episode_count: number;
  reasoning: string;
  duration_policy: string;
  split_merge_rules: string[];
  source: 'ai' | 'local' | 'fixed';
}

@Injectable()
export class EpisodesService implements OnModuleInit {
  private readonly runningEpisodePlanTasks = new Set<string>();

  constructor(
    @Inject(PrismaService) private readonly prisma: PrismaService,
    @Optional() @Inject(ProvidersService) private readonly providersService?: ProvidersService
  ) {}

  async onModuleInit() {
    const tasks = await this.prisma.renderTask.findMany({
      where: {
        task_type: 'episode_plan_generate',
        status: { in: ['pending', 'running', 'retrying'] }
      },
      orderBy: { created_at: 'asc' },
      take: 20
    });

    for (const task of tasks) {
      this.ensureEpisodePlanTaskRunning(task.id);
    }
  }

  async generatePlan(user: AuthRequestUser, projectId: string, dto: GenerateEpisodePlanDto) {
    const project = await this.findProjectForUser(projectId, user);
    this.assertLegacyWritePath(project);
    const providerCode = this.normalizeProviderCode(dto.provider_code);

    if (providerCode) {
      return this.submitEpisodePlanGeneration(user, projectId, dto, providerCode);
    }

    return this.executeGeneratePlan(user, projectId, dto);
  }

  async previewPlanRequest(user: AuthRequestUser, projectId: string, dto: GenerateEpisodePlanDto) {
    const project = await this.findProjectForUser(projectId, user);
    this.assertLegacyWritePath(project);
    const context = await this.loadPlanContext(project.id);
    const referenceCount = this.resolveEpisodeCount(project, dto.target_episode_count);
    const countMode = this.resolveEpisodeCountMode(dto.episode_count_mode);
    const countRecommendation = countMode === 'ai_recommend'
      ? this.estimateEpisodeCountRecommendation(project, context, referenceCount)
      : {
          episode_count: referenceCount,
          reasoning: '使用用户/项目参考集数，不启用 AI 集数建议。',
          duration_policy: this.episodeDurationPlanningGuide(project),
          split_merge_rules: ['按固定集数生成分集计划。'],
          source: 'fixed' as const
        };
    const count = countRecommendation.episode_count;
    const fallbackDrafts = this.buildEpisodeDrafts(project, count, context);
    const batchSize = this.resolveEpisodePlanBatchSize(count);
    const totalBatches = Math.ceil(count / batchSize);
    const minQualityScore = this.normalizeMinQualityScore(dto.min_quality_score, 96);
    const promptOverrides = this.normalizeEpisodePlanPromptOverrides(dto.prompt_overrides);
    const requestParamsOverride = this.normalizeEpisodePlanRequestParamsOverride(dto.request_params_override);
    const overviewPrompt = this.applyEpisodePlanPromptOverride(
      this.buildEpisodeOverviewPrompt(project, count, context, fallbackDrafts),
      promptOverrides.overview,
      'overview'
    );
    const fallbackOverview = this.episodeOverviewFromObject(null, count, fallbackDrafts);
    const firstBatchEnd = Math.min(count, batchSize);
    const batchPrompt = this.applyEpisodePlanPromptOverride(
      this.buildEpisodeBatchPrompt(
        project,
        context,
        fallbackOverview,
        [],
        fallbackDrafts.slice(0, firstBatchEnd),
        1,
        firstBatchEnd
      ),
      promptOverrides.batch,
      'batch'
    );
    const localScore = this.scoreEpisodePlanDrafts(fallbackDrafts, context, count, minQualityScore);
    const reconcilePrompt = this.applyEpisodePlanPromptOverride(
      this.buildEpisodeReconcilePrompt(
        project,
        context,
        fallbackOverview,
        fallbackDrafts,
        fallbackDrafts,
        minQualityScore,
        localScore
      ),
      promptOverrides.reconcile,
      'reconcile'
    );

    return {
      project_id: project.id.toString(),
      provider_code: this.normalizeProviderCode(dto.provider_code) || '智能计划',
      episode_count_mode: countMode,
      reference_episode_count: referenceCount,
      recommended_episode_count: countRecommendation.episode_count,
      episode_count_reasoning: countRecommendation.reasoning,
      episode_count_duration_policy: countRecommendation.duration_policy,
      episode_count_split_merge_rules: countRecommendation.split_merge_rules,
      target_episode_count: count,
      min_quality_score: minQualityScore,
      mode: 'overview_batch_reconcile',
      batch_size: batchSize,
      total_batches: totalBatches,
      quality_duration_range: {
        min: MIN_QUALITY_EPISODE_DURATION,
        max: MAX_QUALITY_EPISODE_DURATION
      },
      episode_duration_reference: this.resolveEpisodeReferenceDuration(project),
      request_params_override: requestParamsOverride,
      prompt_overrides: promptOverrides,
      stages: [
        this.buildEpisodePlanStagePreview(
          project,
          'episode_count_recommendation',
          'AI建议真实总集数',
          this.buildEpisodeCountRecommendationPrompt(project, context, referenceCount),
          2500,
          requestParamsOverride
        ),
        this.buildEpisodePlanStagePreview(project, 'overview', '全局分集骨架', overviewPrompt, 6500, requestParamsOverride),
        this.buildEpisodePlanStagePreview(
          project,
          'batch_1_' + firstBatchEnd,
          '详细分集批次模板（第1批示例）',
          batchPrompt,
          Math.min(7000, Math.max(3500, firstBatchEnd * 520)),
          requestParamsOverride
        ),
        this.buildEpisodePlanStagePreview(project, 'reconcile', '全局校准补丁', reconcilePrompt, 5000, requestParamsOverride)
      ]
    };
  }

  private async submitEpisodePlanGeneration(
    user: AuthRequestUser,
    projectId: string,
    dto: GenerateEpisodePlanDto,
    providerCode: string
  ) {
    const project = await this.findProjectForUser(projectId, user);
    this.assertLegacyWritePath(project);
    const referenceCount = this.resolveEpisodeCount(project, dto.target_episode_count);
    const existingConfirmed = await this.prisma.episode.count({
      where: {
        project_id: project.id,
        status: 'confirmed'
      }
    });

    if (existingConfirmed > 0 && dto.force !== true) {
      throw new BadRequestException('Confirmed episodes cannot be regenerated');
    }

    const existing = await this.findActiveEpisodePlanTask(project.id);

    if (existing) {
      this.ensureEpisodePlanTaskRunning(existing.id);

      return {
        task: toSafeRenderTask(existing),
        episodes: [],
        memory_context: null,
        next_step: 'episode_plan_generating',
        already_running: true
      };
    }

    const inputJson: Prisma.InputJsonObject = {
      project_id: project.id.toString(),
      provider_code: providerCode,
      target_episode_count: referenceCount,
      reference_episode_count: referenceCount,
      episode_count_mode: this.resolveEpisodeCountMode(dto.episode_count_mode),
      force: dto.force === true,
      min_quality_score: this.normalizeMinQualityScore(dto.min_quality_score, 96),
      prompt_overrides: this.normalizeEpisodePlanPromptOverrides(dto.prompt_overrides) as Prisma.InputJsonObject,
      request_params_override: this.normalizeEpisodePlanRequestParamsOverride(dto.request_params_override) as Prisma.InputJsonObject,
      user_id: user.id,
      user_email: user.email,
      user_role: user.role,
      submitted_at: new Date().toISOString()
    };
    const task = await this.prisma.renderTask.create({
      data: {
        project_id: project.id,
        episode_id: null,
        shot_id: null,
        task_type: 'episode_plan_generate',
        status: 'pending',
        input_json: inputJson,
        input_hash: this.hashJson(inputJson),
        retry_count: 0,
        max_retry: 1
      }
    });
    await this.prisma.project.update({
      where: { id: project.id },
      data: { status: 'episode_planning' }
    });

    this.ensureEpisodePlanTaskRunning(task.id);

    return {
      task: toSafeRenderTask(task),
      episodes: [],
      memory_context: null,
      next_step: 'episode_plan_generating',
      already_running: false
    };
  }

  private async executeGeneratePlan(
    user: AuthRequestUser,
    projectId: string,
    dto: GenerateEpisodePlanDto,
    taskId?: bigint
  ) {
    const project = await this.findProjectForUser(projectId, user);
    const context = await this.loadPlanContext(project.id);
    const referenceCount = this.resolveEpisodeCount(project, dto.target_episode_count);
    const countRecommendation = await this.resolveEpisodeCountRecommendation(
      project,
      context,
      referenceCount,
      dto,
      taskId
    );
    const count = countRecommendation.episode_count;

    if (taskId) {
      await this.updateEpisodePlanTaskMeta(taskId, {
        episode_count_recommendation: countRecommendation,
        target_episode_count: count,
        reference_episode_count: referenceCount
      });
    }

    const minQualityScore = this.normalizeMinQualityScore(dto.min_quality_score, 96);
    const promptOverrides = this.normalizeEpisodePlanPromptOverrides(dto.prompt_overrides);
    const requestParamsOverride = this.normalizeEpisodePlanRequestParamsOverride(dto.request_params_override);
    const existingConfirmed = await this.prisma.episode.count({
      where: {
        project_id: project.id,
        status: 'confirmed'
      }
    });

    if (existingConfirmed > 0 && dto.force !== true) {
      throw new BadRequestException('Confirmed episodes cannot be regenerated');
    }

    const fallbackDrafts = this.buildEpisodeDrafts(project, count, context);
    const drafts =
      (await this.tryGeneratePlanWithProvider(
        project,
        count,
        context,
        fallbackDrafts,
        minQualityScore,
        dto.provider_code,
        taskId,
        promptOverrides,
        requestParamsOverride
      )) ?? fallbackDrafts;
    const qualityReport = this.scoreEpisodePlanDrafts(drafts, context, count, minQualityScore);

    if (taskId) {
      await this.updateEpisodePlanTaskMeta(taskId, {
        episode_count_recommendation: countRecommendation,
        target_episode_count: count,
        reference_episode_count: referenceCount,
        quality_report: qualityReport,
        created_count_preview: {
          episodes: drafts.length
        }
      });
      await this.updateEpisodePlanCostSummary(taskId);
    }

    if (!qualityReport.passed) {
      throw new BadRequestException(
        `分集计划质量未达标：当前 ${qualityReport.score}/${minQualityScore}。${qualityReport.issues.join('；')}`
      );
    }

    await this.prisma.project.update({
      where: { id: project.id },
      data: { status: 'episode_planning' }
    });

    const episodes = await this.prisma.$transaction(async (tx) => {
      await this.clearEpisodePlanForRegeneration(tx, project.id, dto.force === true);
      await tx.episode.createMany({
        data: drafts.map((draft) => ({
          project_id: project.id,
          ...draft
        }))
      });
      const saved = await tx.episode.findMany({
        where: { project_id: project.id },
        orderBy: { episode_no: 'asc' }
      });
      await tx.project.update({
        where: { id: project.id },
        data: { status: 'waiting_episode_confirm' }
      });
      return saved;
    });

    return {
      episodes: episodes.map(toSafeEpisode),
      memory_context: {
        story_bible_id: context.storyBible.id.toString(),
        locked_character_count: context.characters.length,
        active_plot_memory_count: context.plotMemories.length,
        open_thread_count: context.plotThreads.length
      },
      quality_report: qualityReport,
      next_step: 'episode_confirm'
    };
  }

  private async runEpisodePlanTask(taskId: bigint) {
    const key = taskId.toString();

    if (this.runningEpisodePlanTasks.has(key)) {
      return;
    }

    this.runningEpisodePlanTasks.add(key);

    try {
      const task = await this.prisma.renderTask.findUnique({ where: { id: taskId } });

      if (!task || !['pending', 'running', 'retrying'].includes(task.status)) {
        return;
      }

      const input = this.readObject(task.input_json);
      const userId = this.readString(input.user_id);

      if (!userId) {
        throw new Error('EPISODE_PLAN_TASK_USER_MISSING');
      }

      await this.prisma.renderTask.update({
        where: { id: task.id },
        data: {
          status: 'running',
          started_at: task.started_at ?? new Date(),
          finished_at: null,
          error_code: null,
          error_message: null
        }
      });

      const user: AuthRequestUser = {
        id: userId,
        email: this.readString(input.user_email) ?? null,
        role: this.readString(input.user_role) ?? 'user'
      };
      await this.executeGeneratePlan(
        user,
        this.readString(input.project_id) ?? task.project_id.toString(),
        {
          provider_code: this.readString(input.provider_code) ?? undefined,
          target_episode_count: this.readNumber(input.target_episode_count) ?? undefined,
          episode_count_mode: this.readString(input.episode_count_mode) === 'fixed' ? 'fixed' : 'ai_recommend',
          force: input.force === true,
          min_quality_score: this.readNumber(input.min_quality_score) ?? undefined,
          prompt_overrides: this.normalizeEpisodePlanPromptOverrides(input.prompt_overrides),
          request_params_override: this.normalizeEpisodePlanRequestParamsOverride(input.request_params_override) as Record<string, unknown>
        },
        task.id
      );
      const latest = await this.prisma.renderTask.findUnique({ where: { id: task.id } });

      if (latest?.status === 'cancelled') {
        return;
      }

      await this.prisma.renderTask.update({
        where: { id: task.id },
        data: {
          status: 'success',
          error_code: null,
          error_message: null,
          finished_at: new Date()
        }
      });
    } catch (error) {
      await this.markEpisodePlanTaskFailed(taskId, error);
    } finally {
      this.runningEpisodePlanTasks.delete(key);
    }
  }

  async listEpisodes(user: AuthRequestUser, projectId: string) {
    const project = await this.findProjectForUser(projectId, user);
    const episodes = await this.prisma.episode.findMany({
      where: { project_id: project.id },
      orderBy: { episode_no: 'asc' }
    });

    return episodes.map(toSafeEpisode);
  }

  private async clearEpisodePlanForRegeneration(
    tx: Prisma.TransactionClient,
    projectId: bigint,
    force: boolean
  ) {
    const episodes = await tx.episode.findMany({
      where: { project_id: projectId },
      select: { id: true, status: true }
    });

    if (episodes.length === 0) return;

    const confirmedCount = episodes.filter((episode) => episode.status === 'confirmed').length;

    if (confirmedCount > 0 && !force) {
      throw new BadRequestException('Confirmed episodes cannot be regenerated');
    }

    const episodeIds = episodes.map((episode) => episode.id);
    const shots = await tx.storyboardShot.findMany({
      where: {
        project_id: projectId,
        episode_id: { in: episodeIds }
      },
      select: { id: true }
    });
    const shotIds = shots.map((shot) => shot.id);

    await tx.renderTask.updateMany({
      where: {
        project_id: projectId,
        episode_id: { in: episodeIds },
        status: { in: ['pending', 'running', 'retrying'] }
      },
      data: {
        status: 'cancelled',
        error_code: 'EPISODE_PLAN_REGENERATED',
        error_message: '分集计划已重做，旧任务自动取消。',
        finished_at: new Date()
      }
    });
    await tx.shotImage.deleteMany({
      where: {
        project_id: projectId,
        OR: [
          { episode_id: { in: episodeIds } },
          ...(shotIds.length ? [{ shot_id: { in: shotIds } }] : [])
        ]
      }
    });
    await tx.videoClip.deleteMany({
      where: {
        project_id: projectId,
        OR: [
          { episode_id: { in: episodeIds } },
          ...(shotIds.length ? [{ shot_id: { in: shotIds } }] : [])
        ]
      }
    });
    await tx.storyboardShot.deleteMany({
      where: {
        project_id: projectId,
        episode_id: { in: episodeIds }
      }
    });
    await tx.episodeScript.deleteMany({
      where: {
        project_id: projectId,
        episode_id: { in: episodeIds }
      }
    });
    await tx.continuityCheck.deleteMany({
      where: {
        project_id: projectId,
        episode_id: { in: episodeIds }
      }
    });
    await tx.asset.updateMany({
      where: {
        project_id: projectId,
        asset_type: { in: ['storyboard_image', 'shot_image', 'keyframe', 'video_clip', 'rendered_episode', 'audio', 'subtitle'] }
      },
      data: { status: 'archived' }
    });
    await tx.episode.deleteMany({
      where: { project_id: projectId }
    });
  }

  async updateEpisode(user: AuthRequestUser, episodeId: string, dto: UpdateEpisodeDto) {
    const episode = await this.findEpisodeForUser(episodeId, user);
    const project = await this.findProjectForUser(episode.project_id.toString(), user);
    this.assertLegacyWritePath(project);

    if (episode.status === 'confirmed') {
      throw new BadRequestException('Confirmed episodes cannot be edited');
    }

    const data = await this.createUpdateData(episode, dto);

    if (Object.keys(data).length === 0) {
      throw new BadRequestException('No episode fields to update');
    }

    const updated = await this.prisma.episode.update({
      where: { id: episode.id },
      data
    });

    await this.prisma.project.update({
      where: { id: episode.project_id },
      data: { status: 'waiting_episode_confirm' }
    });

    return toSafeEpisode(updated);
  }

  async confirmEpisodes(user: AuthRequestUser, projectId: string) {
    const project = await this.findProjectForUser(projectId, user);
    this.assertLegacyWritePath(project);
    const episodes = await this.prisma.episode.findMany({
      where: { project_id: project.id },
      orderBy: { episode_no: 'asc' }
    });

    this.assertEpisodesReadyForConfirmation(episodes);

    const confirmed = await this.prisma.$transaction(async (tx) => {
      await tx.episode.updateMany({
        where: {
          project_id: project.id,
          status: { in: ['draft', 'generated', 'edited'] }
        },
        data: { status: 'confirmed' }
      });
      const saved = await tx.episode.findMany({
        where: { project_id: project.id },
        orderBy: { episode_no: 'asc' }
      });
      await tx.project.update({
        where: { id: project.id },
        data: { status: 'episode_confirmed' }
      });
      return saved;
    });

    return {
      episodes: confirmed.map(toSafeEpisode),
      next_step: 'script_generate'
    };
  }

  private async loadPlanContext(projectId: bigint): Promise<EpisodePlanContext> {
    const [storyBible, characters, chapters, plotMemories, plotThreads] = await Promise.all([
      this.prisma.storyBible.findFirst({
        where: {
          project_id: projectId,
          status: 'confirmed'
        },
        orderBy: { version: 'desc' }
      }),
      this.prisma.character.findMany({
        where: {
          project_id: projectId,
          status: 'locked'
        },
        orderBy: [{ importance_level: 'desc' }, { id: 'asc' }]
      }),
      this.prisma.novelChapter.findMany({
        where: { project_id: projectId },
        orderBy: { chapter_no: 'asc' }
      }),
      this.prisma.plotMemory.findMany({
        where: {
          project_id: projectId,
          status: 'active'
        },
        orderBy: [{ importance_level: 'desc' }, { id: 'asc' }]
      }),
      this.prisma.plotThread.findMany({
        where: {
          project_id: projectId,
          status: { in: ['open', 'progressing', 'paused'] }
        },
        orderBy: [{ status: 'asc' }, { id: 'asc' }]
      })
    ]);

    if (!storyBible) {
      throw new BadRequestException('Confirmed story bible is required before episode planning');
    }
    if (characters.length === 0) {
      throw new BadRequestException('Locked characters are required before episode planning');
    }
    if (chapters.length === 0) {
      throw new BadRequestException('Novel chapters are required before episode planning');
    }
    if (plotMemories.length === 0) {
      throw new BadRequestException('Long-form plot memories are required before episode planning');
    }

    return {
      storyBible,
      characters,
      chapters,
      plotMemories,
      plotThreads
    };
  }

  private buildEpisodeDrafts(
    project: Project,
    count: number,
    context: EpisodePlanContext
  ): EpisodeDraft[] {
    const protagonist =
      context.characters.find((character) => ['protagonist', 'lead'].includes(character.role_type)) ??
      context.characters[0];
    const antagonist = context.characters.find((character) => character.role_type === 'antagonist');
    const importantForeshadowing = context.plotMemories.find(
      (memory) => memory.memory_type === 'foreshadowing'
    );
    const unresolvedConflict = context.plotMemories.find(
      (memory) => memory.memory_type === 'unresolved_conflict'
    );
    const mainThread =
      context.plotThreads.find((thread) => thread.thread_type === 'main_plot') ??
      context.plotThreads[0];
    const referenceDuration = this.resolveEpisodeReferenceDuration(project);

    return Array.from({ length: count }, (_, index) => {
      const episodeNo = index + 1;
      const chapterGroup = this.pickChapterGroup(context.chapters, index, count);
      const firstChapter = chapterGroup[0] ?? context.chapters[0];
      const lastChapter = chapterGroup.at(-1) ?? firstChapter;
      const chapterSummary = chapterGroup
        .map((chapter) => chapter.summary || this.compact(chapter.content).slice(0, 70))
        .join('；');
      const sourceChapterIds = chapterGroup.map((chapter) => chapter.id.toString());
      const threadText = mainThread?.description || context.storyBible.main_plot || '主线目标持续推进';

      return {
        episode_no: episodeNo,
        source_chapter_ids: sourceChapterIds,
        title: this.buildEpisodeTitle(episodeNo, firstChapter, count),
        summary: [
          `${protagonist.name}围绕${this.compact(threadText).slice(0, 80)}推进第${episodeNo}集。`,
          chapterSummary,
          episodeNo === count
            ? context.storyBible.ending_direction || '阶段性回收关键伏笔，并保留下一阶段入口。'
            : '本集保留短视频节奏，结尾留下可承接悬念。'
        ].filter(Boolean).join(' '),
        opening_hook:
          episodeNo === 1
            ? `${protagonist.name}在高压场景中发现关键转机，观众第一秒进入冲突。`
            : `承接上一集悬念，${protagonist.name}立刻面对新的选择和压力。`,
        middle_conflict:
          unresolvedConflict?.content ||
          `${antagonist?.name ?? '主要对手'}围绕核心利益继续施压，${protagonist.name}必须用证据或行动反击。`,
        ending_hook: this.buildEndingHook(
          episodeNo,
          count,
          protagonist.name,
          lastChapter,
          importantForeshadowing,
          context.storyBible
        ),
        target_duration: this.estimateEpisodeTargetDuration({
          project,
          referenceDuration,
          episodeNo,
          count,
          text: [
            chapterSummary,
            threadText,
            unresolvedConflict?.content,
            importantForeshadowing?.content,
            episodeNo === count ? context.storyBible.ending_direction : ''
          ].filter(Boolean).join('\n')
        }),
        status: 'generated'
      };
    });
  }

  private async tryGeneratePlanWithProvider(
    project: Project,
    count: number,
    context: EpisodePlanContext,
    fallbackDrafts: EpisodeDraft[],
    minQualityScore: number,
    providerCode?: string,
    taskId?: bigint,
    promptOverrides: EpisodePlanPromptOverrides = {},
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ): Promise<EpisodeDraft[] | null> {
    if (!this.providersService) return null;
    const selectedProvider = this.normalizeProviderCode(providerCode);
    if (!selectedProvider) return null;
    const batchSize = this.resolveEpisodePlanBatchSize(count);
    const totalBatches = Math.ceil(count / batchSize);

    if (taskId) {
      await this.updateEpisodePlanCostSummary(taskId, {
        pipeline_status: {
          mode: 'overview_batch_reconcile',
          phase: 'overview',
          completed_batches: 0,
          total_batches: totalBatches,
          batch_size: batchSize,
          target_episode_count: count,
          started_at: new Date().toISOString()
        }
      });
    }

    try {
      const overview = await this.generateEpisodeOverviewWithProvider(
        project,
        count,
        context,
        fallbackDrafts,
        selectedProvider,
        taskId,
        promptOverrides.overview,
        requestParamsOverride
      );
      const drafts: EpisodeDraft[] = [];

      for (let batchIndex = 0; batchIndex < totalBatches; batchIndex += 1) {
        const startNo = batchIndex * batchSize + 1;
        const endNo = Math.min(count, startNo + batchSize - 1);
        const fallbackBatch = fallbackDrafts.slice(startNo - 1, endNo);

        if (taskId) {
          await this.updateEpisodePlanCostSummary(taskId, {
            pipeline_status: {
              mode: 'overview_batch_reconcile',
              phase: 'batch',
              current_batch: batchIndex + 1,
              current_range: `${startNo}-${endNo}`,
              completed_batches: batchIndex,
              total_batches: totalBatches,
              batch_size: batchSize,
              target_episode_count: count,
              updated_at: new Date().toISOString()
            }
          });
        }

        const batchDrafts = await this.generateEpisodeBatchWithProvider(
          project,
          context,
          overview,
          drafts,
          fallbackBatch,
          selectedProvider,
          startNo,
          endNo,
          taskId,
          promptOverrides.batch,
          requestParamsOverride
        );
        drafts.push(...batchDrafts);

        if (taskId) {
          await this.updateEpisodePlanCostSummary(taskId, {
            pipeline_status: {
              mode: 'overview_batch_reconcile',
              phase: 'batch',
              current_batch: batchIndex + 1,
              current_range: `${startNo}-${endNo}`,
              completed_batches: batchIndex + 1,
              total_batches: totalBatches,
              batch_size: batchSize,
              target_episode_count: count,
              generated_episodes: drafts.length,
              updated_at: new Date().toISOString()
            },
            created_count_preview: {
              episodes: drafts.length
            }
          });
        }
      }

      const normalizedDrafts = this.normalizeEpisodeDrafts(drafts, fallbackDrafts, count, project);

      if (taskId) {
        await this.updateEpisodePlanCostSummary(taskId, {
          pipeline_status: {
            mode: 'overview_batch_reconcile',
            phase: 'reconcile',
            completed_batches: totalBatches,
            total_batches: totalBatches,
            batch_size: batchSize,
            target_episode_count: count,
            generated_episodes: normalizedDrafts.length,
            updated_at: new Date().toISOString()
          }
        });
      }

      const reconciledDrafts = await this.reconcileEpisodePlanWithProvider(
        project,
        context,
        overview,
        normalizedDrafts,
        fallbackDrafts,
        minQualityScore,
        selectedProvider,
        taskId,
        promptOverrides.reconcile,
        requestParamsOverride
      );

      if (taskId) {
        await this.updateEpisodePlanCostSummary(taskId, {
          pipeline_status: {
            mode: 'overview_batch_reconcile',
            phase: 'complete',
            completed_batches: totalBatches,
            total_batches: totalBatches,
            batch_size: batchSize,
            target_episode_count: count,
            generated_episodes: reconciledDrafts.length,
            finished_at: new Date().toISOString()
          },
          created_count_preview: {
            episodes: reconciledDrafts.length
          }
        });
      }

      return reconciledDrafts;
    } catch (error) {
      if (taskId) {
        await this.updateEpisodePlanCostSummary(taskId, {
          pipeline_status: {
            mode: 'overview_batch_reconcile',
            phase: 'failed',
            total_batches: totalBatches,
            batch_size: batchSize,
            target_episode_count: count,
            error_message: this.errorMessage(error),
            failed_at: new Date().toISOString()
          }
        }).catch(() => undefined);
      }
      throw new BadRequestException(`选定文本模型生成分集计划失败：${this.errorMessage(error)}`);
    }
  }

  private async generateEpisodeOverviewWithProvider(
    project: Project,
    count: number,
    context: EpisodePlanContext,
    fallbackDrafts: EpisodeDraft[],
    selectedProvider: string,
    taskId?: bigint,
    promptOverride?: string,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ) {
    const prompt = this.applyEpisodePlanPromptOverride(
      this.buildEpisodeOverviewPrompt(project, count, context, fallbackDrafts),
      promptOverride,
      'overview'
    );

    const parsed = await this.executeEpisodePlanJsonProvider(
      project,
      selectedProvider,
      'overview',
      prompt,
      14000,
      taskId,
      requestParamsOverride
    );

    return this.episodeOverviewFromObject(parsed, count, fallbackDrafts);
  }

  private buildEpisodeOverviewPrompt(
    project: Project,
    count: number,
    context: EpisodePlanContext,
    fallbackDrafts: EpisodeDraft[]
  ) {
    const sharedPromptRules = promptRuleLinesV1({
      stage: 'episode',
      genre_tags: [project.genre ?? '', project.style_code ?? ''].filter(Boolean)
    });
    assertPromptIsCleanV1(sharedPromptRules.join('\n'));
    const productionContext = this.storyBibleProductionContext(context.storyBible, [
      'episode_structure',
      'episode_rhythm_formula',
      'reversal_system',
      'emotional_curve',
      'core_memory_points',
      'adaptation_taboo'
    ]);

    return [
      '你是短剧总编剧。请先做全局分集骨架，只输出 JSON，不要 Markdown。',
      'JSON 格式：{"overview":[{"episode_no":1,"title_hint":"","one_sentence":"","arc_stage":"","source_chapter_ids":[""],"key_hook":"","must_use_memory":[""]}]}',
      ...sharedPromptRules,
      `系统当前参考生成 ${count} 条 overview，但这是生产批次参考，不是为了删减剧情的硬性创作目标。每条只写一句话骨架，不写详细分集。目标是给后续分批生成提供全局连续性。`,
      '要求：1）覆盖所有集数且 episode_no 连续；2）每集必须有 source_chapter_ids；3）arc_stage 表示阶段，例如开局压迫、反击、追证、翻盘、终局；4）key_hook 必须是短剧钩子；5）必须吸收长篇记忆里的伏笔、证据、道具、场景和未解决剧情线；6）不要逐章流水账；7）不要为了贴合固定集数删掉关键剧情，如果剧情密度过高，必须在 one_sentence 或 key_hook 中保留该集核心信息，并在后续 detailed episode 的 target_duration 拉长到 120-180 秒。',
      '输出长度控制：overview 是全局地图，不是详细剧本。每集 title_hint 不超过12字，one_sentence 不超过42字，key_hook 不超过32字，must_use_memory 最多2条且每条不超过18字。不要把详细事件、对白和制作蓝图写进 overview，详细内容留给 batch 阶段。',
      `故事圣经：${JSON.stringify({
        title: context.storyBible.title,
        main_plot: context.storyBible.main_plot,
        core_conflict: context.storyBible.core_conflict,
        ending_direction: context.storyBible.ending_direction
      })}`,
      productionContext ? `制作级分集/节奏规则：${productionContext}` : null,
      this.createEpisodePlanContextBrief(context),
      `章节压缩表：${this.createChapterBriefs(context.chapters, 90).join('\n')}`,
      `本地参考骨架：${JSON.stringify(fallbackDrafts.map((draft) => ({
        episode_no: draft.episode_no,
        title: draft.title,
        summary: this.compact(draft.summary, 120),
        source_chapter_ids: draft.source_chapter_ids
      })))}`
    ].filter(Boolean).join('\n\n');
  }

  private async resolveEpisodeCountRecommendation(
    project: Project,
    context: EpisodePlanContext,
    referenceCount: number,
    dto: GenerateEpisodePlanDto,
    taskId?: bigint
  ): Promise<EpisodeCountRecommendation> {
    const mode = this.resolveEpisodeCountMode(dto.episode_count_mode);

    if (mode === 'fixed') {
      return {
        episode_count: referenceCount,
        reasoning: '使用用户/项目参考集数，不启用 AI 集数建议。',
        duration_policy: this.episodeDurationPlanningGuide(project),
        split_merge_rules: ['按固定集数生成分集计划。'],
        source: 'fixed'
      };
    }

    const providerCode = this.normalizeProviderCode(dto.provider_code);

    if (!providerCode || !this.providersService) {
      return this.estimateEpisodeCountRecommendation(project, context, referenceCount);
    }

    const requestParamsOverride = this.normalizeEpisodePlanRequestParamsOverride(dto.request_params_override);
    const prompt = this.buildEpisodeCountRecommendationPrompt(project, context, referenceCount);

    if (taskId) {
      await this.updateEpisodePlanCostSummary(taskId, {
        pipeline_status: {
          mode: 'episode_count_overview_batch_reconcile',
          phase: 'episode_count_recommendation',
          reference_episode_count: referenceCount,
          updated_at: new Date().toISOString()
        }
      });
    }

    try {
      const text = await this.executeEpisodePlanTextProvider(
        project,
        providerCode,
        'episode_count_recommendation',
        prompt,
        6000,
        taskId,
        requestParamsOverride
      );
      const parsed = this.parseProviderJson(text) ?? this.parsePartialEpisodeCountRecommendationJson(text);

      if (!parsed) {
        throw new BadRequestException('AI 集数推荐 JSON 不完整，已停止生成，避免回退到本地估算。');
      }

      return this.episodeCountRecommendationFromObject(parsed, project, context, referenceCount);
    } catch (error) {
      throw new BadRequestException(`AI 集数推荐失败：${this.errorMessage(error)}`);
    }
  }

  private buildEpisodeCountRecommendationPrompt(
    project: Project,
    context: EpisodePlanContext,
    referenceCount: number
  ) {
    return [
      '你是精品16:9横屏影视短剧总制片和总编剧。请先根据完整故事资料判断真实适合的总集数，只输出 JSON，不要 Markdown。',
      'JSON 格式：{"recommended_episode_count":60,"reasoning":"","duration_policy":"","split_merge_rules":[""],"risk_notes":[""]}',
      `项目当前参考集数：${referenceCount}。这是运营/成本参考，不是硬限制。你的任务是按剧情完整度、章节密度、主线证据链、人物弧光和短剧节奏，给出更合理的 recommended_episode_count。`,
      `单集精品时长原则：常规 60-180 秒；过渡/铺垫 60-75 秒；常规冲突 75-100 秒；强反转/多证据/情绪爆发 100-140 秒；终局复杂爆点可到 140-180 秒。不要为了固定1分钟或固定总集数删剧情。`,
      '判断规则：1）不能按“一章一集”机械切；2）不能默认“两章一集”；3）如果章节事件密度低，可以多章合一集；4）如果一章内有多个强爆点/证据反转，可以拆成多集；5）必须保证每集有承接式开场钩子、中段冲突和结尾追看问题；6）如果推荐集数与参考集数差异很大，必须说明原因。',
      '输出长度控制：reasoning 不超过180字；duration_policy 不超过160字；split_merge_rules 只写6条，每条不超过45字；risk_notes 最多4条，每条不超过40字。必须输出完整闭合 JSON。',
      `故事圣经：${JSON.stringify({
        title: context.storyBible.title,
        main_plot: context.storyBible.main_plot,
        core_conflict: context.storyBible.core_conflict,
        ending_direction: context.storyBible.ending_direction
      })}`,
      this.createEpisodePlanContextBrief(context),
      `章节压缩表：${this.createChapterBriefs(context.chapters, 120).join('\n')}`
    ].filter(Boolean).join('\n\n');
  }

  private episodeCountRecommendationFromObject(
    value: Record<string, unknown> | null,
    project: Project,
    context: EpisodePlanContext,
    referenceCount: number
  ): EpisodeCountRecommendation {
    const local = this.estimateEpisodeCountRecommendation(project, context, referenceCount);
    const recommended = this.readNumber(value?.recommended_episode_count);
    const episodeCount = recommended
      ? this.validatePositiveInt(Math.round(recommended), 'recommended_episode_count', MIN_EPISODES, MAX_EPISODES)
      : local.episode_count;

    return {
      episode_count: episodeCount,
      reasoning: this.readString(value?.reasoning) ?? local.reasoning,
      duration_policy: this.readString(value?.duration_policy) ?? local.duration_policy,
      split_merge_rules: this.readStringArray(value?.split_merge_rules).length
        ? this.readStringArray(value?.split_merge_rules)
        : local.split_merge_rules,
      source: 'ai'
    };
  }

  private estimateEpisodeCountRecommendation(
    project: Project,
    context: EpisodePlanContext,
    referenceCount: number
  ): EpisodeCountRecommendation {
    const chapterCount = context.chapters.length;
    const memoryPressure = context.plotMemories.filter((memory) => memory.importance_level >= 75).length;
    const threadPressure = context.plotThreads.length;
    const avgChapterText = chapterCount > 0
      ? context.chapters.reduce((sum, chapter) => sum + (chapter.summary?.length || Math.min(chapter.content.length, 1200)), 0) / chapterCount
      : 0;
    const chapterRatio = avgChapterText >= 650 ? 1.35 : avgChapterText >= 360 ? 1.8 : 2.4;
    const pressureBonus = memoryPressure >= 40 || threadPressure >= 15 ? 1.15 : memoryPressure >= 20 ? 1.05 : 1;
    const estimated = chapterCount > 0
      ? Math.round((chapterCount / chapterRatio) * pressureBonus)
      : referenceCount;
    const episodeCount = this.validatePositiveInt(
      Math.round(Math.max(1, Math.min(MAX_EPISODES, estimated || referenceCount))),
      'recommended_episode_count',
      MIN_EPISODES,
      MAX_EPISODES
    );

    return {
      episode_count: episodeCount,
      reasoning: `本地估算：共 ${chapterCount} 章，重要记忆 ${memoryPressure} 条，开放剧情线 ${threadPressure} 条，参考集数 ${referenceCount}；按章节密度和剧情压力估算为 ${episodeCount} 集。`,
      duration_policy: this.episodeDurationPlanningGuide(project),
      split_merge_rules: [
        '低密度过场可多章合一集。',
        '单章内如果包含强反转、证据爆点或关系翻盘，可以拆成多集。',
        '每集必须保留承接式开场钩子、中段冲突和结尾追看问题。'
      ],
      source: 'local'
    };
  }

  private resolveEpisodeCountMode(value: string | undefined) {
    return value === 'fixed' ? 'fixed' : 'ai_recommend';
  }

  private buildEpisodeBatchPrompt(
    project: Project,
    context: EpisodePlanContext,
    overview: EpisodeOverviewItem[],
    previousDrafts: EpisodeDraft[],
    fallbackBatch: EpisodeDraft[],
    startNo: number,
    endNo: number
  ) {
    const batchOverview = overview.filter((item) => item.episode_no >= startNo && item.episode_no <= endNo);
    const previousContext = previousDrafts.slice(-2).map((draft) => ({
      episode_no: draft.episode_no,
      title: draft.title,
      summary: this.compact(draft.summary, 180),
      ending_hook: draft.ending_hook
    }));
    const nextOverview = overview
      .filter((item) => item.episode_no > endNo && item.episode_no <= endNo + 2)
      .map((item) => ({
        episode_no: item.episode_no,
        one_sentence: item.one_sentence,
        key_hook: item.key_hook
      }));
    const chapterIds = new Set(batchOverview.flatMap((item) => item.source_chapter_ids));
    const relevantChapters = context.chapters.filter((chapter) => chapterIds.has(chapter.id.toString()));
    const sharedPromptRules = promptRuleLinesV1({
      stage: 'episode',
      genre_tags: [project.genre ?? '', project.style_code ?? ''].filter(Boolean)
    });
    assertPromptIsCleanV1(sharedPromptRules.join('\n'));

    return [
      '你是短剧分集策划。请根据全局骨架生成当前批次详细分集，只输出 JSON，不要 Markdown。',
      'JSON 格式：{"episodes":[{"episode_no":1,"title":"","summary":"","opening_hook":"","middle_conflict":"","ending_hook":"","source_chapter_ids":[""],"target_duration":75,"must_keep_events":[""],"must_keep_dialogues":["角色：短句"],"key_props":[""],"key_scenes":[""],"emotional_turn":"","evidence_turn":"","opening_payoff":"","ending_question":"","script_beats":["0-3秒承接式开场钩子：..."]}]}',
      ...sharedPromptRules,
      `当前批次：第 ${startNo}-${endNo} 集。只能输出这个范围内的 episodes，episode_no 必须连续。`,
      this.episodeDurationPlanningGuide(project),
      '质量目标：每集 opening_hook 必须是“承接式开场钩子”：第1集用身份、危机或反常画面直接开钩子；第2集及以后必须承接上一集 ending_hook，把上集悬念在0-3秒内用强画面、狠对白、证据特写、突发动作、身份揭露、死亡威胁或背叛信号之一兑现并推进，不得另起新剧情，不得跳过上集悬念。middle_conflict 要推进证据/人物关系/权力变化；ending_hook 要自然抛给下一集继续承接。不要重复标题，不要重复钩子，不要编造脱离故事圣经的新世界观。不要为了固定集数或固定时长牺牲剧情完整度，允许单集根据剧情密度在 60-180 秒内变化。',
      '制作蓝图要求：每集不是普通摘要，必须给后续“生成单集剧本/25宫格分镜/视频镜头”提供可执行蓝图。must_keep_events 写本集绝不能删的3-6个事件；must_keep_dialogues 写必须保留或改写成短剧爆点句的关键台词2-6句；key_props/key_scenes 写后续资产选择必须用到的道具和场景；emotional_turn 写人物情绪/关系从什么变成什么；evidence_turn 写证据链/信息差如何变化；opening_payoff 写本集开头如何兑现上一集悬念；ending_question 写观众追下一集的问题；script_beats 按目标时长写5-12个可拍 beat，每个 beat 都要能拆成后续分镜。',
      '生产约束：这里是分集蓝图，不是完整单集剧本。summary 控制在120-180字，opening_hook/ending_hook 各控制在35字内，middle_conflict 控制在80-130字，script_beats 每条控制在28字内。不要用长段解释换取信息量，必须用短剧事件、动作、证据和爆点句表达。',
      this.createEpisodePlanContextBrief(context),
      `全局骨架：${JSON.stringify(overview.map((item) => ({
        episode_no: item.episode_no,
        title_hint: item.title_hint,
        one_sentence: item.one_sentence,
        arc_stage: item.arc_stage,
        key_hook: item.key_hook
      })))}`,
      `当前批次骨架：${JSON.stringify(batchOverview)}`,
      previousContext.length ? `上一批结尾承接：${JSON.stringify(previousContext)}` : null,
      nextOverview.length ? `下一批方向预告：${JSON.stringify(nextOverview)}` : null,
      `当前批次相关章节：${this.createChapterBriefs(relevantChapters.length ? relevantChapters : context.chapters, 140).join('\n')}`,
      `本地兜底草稿：${JSON.stringify(fallbackBatch)}`
    ].filter(Boolean).join('\n\n');
  }

  private buildEpisodeReconcilePrompt(
    project: Project,
    context: EpisodePlanContext,
    overview: EpisodeOverviewItem[],
    drafts: EpisodeDraft[],
    fallbackDrafts: EpisodeDraft[],
    minQualityScore: number,
    localScore: EpisodePlanQualityBrief
  ) {
    void fallbackDrafts;

    return [
      '你是短剧分集总审稿。请做全局校准补丁，只输出 JSON，不要 Markdown。',
      'JSON 格式：{"patches":[{"episode_no":1,"title":"","summary":"","opening_hook":"","middle_conflict":"","ending_hook":"","source_chapter_ids":[""],"target_duration":75,"must_keep_events":[""],"must_keep_dialogues":["角色：短句"],"key_props":[""],"key_scenes":[""],"emotional_turn":"","evidence_turn":"","opening_payoff":"","ending_question":"","script_beats":["0-3秒承接式开场钩子：..."]}],"global_notes":[""]}',
      `当前本地评分 ${localScore.score}/${minQualityScore}。请只修改确实有问题的集，不要重写全部。重点修：重复钩子、断裂剧情线、opening_hook 没有承接上一集 ending_hook、没有推进长篇记忆、集长与剧情密度不匹配、缺少 must_keep_events/must_keep_dialogues/key_props/key_scenes/script_beats 制作蓝图。`,
      '制作蓝图补丁规则：patch 里如果补充 must_keep_events、must_keep_dialogues、key_props、key_scenes、emotional_turn、evidence_turn、opening_payoff、ending_question、script_beats，系统会写入分集文本供后续脚本和分镜读取。不要写空泛词，必须具体到人物、事件、道具、场景、证据和台词。',
      this.episodeDurationPlanningGuide(project),
      this.createEpisodePlanContextBrief(context),
      `全局骨架：${JSON.stringify(overview.map((item) => ({
        episode_no: item.episode_no,
        one_sentence: item.one_sentence,
        arc_stage: item.arc_stage,
        key_hook: item.key_hook
      })))}`,
      `当前分集：${JSON.stringify(drafts.map((draft) => ({
        episode_no: draft.episode_no,
        title: draft.title,
        summary: this.compact(draft.summary, 220),
        opening_hook: draft.opening_hook,
        middle_conflict: this.compact(draft.middle_conflict, 180),
        ending_hook: draft.ending_hook,
        source_chapter_ids: draft.source_chapter_ids,
        target_duration: draft.target_duration
      })))}`,
      `本地质检问题：${JSON.stringify(localScore.issues)}`
    ].filter(Boolean).join('\n\n');
  }

  private applyEpisodePlanPromptOverride(basePrompt: string, override: string | undefined, stage: string) {
    const normalized = override?.trim();

    if (!normalized) return basePrompt;
    if (normalized === basePrompt.trim()) return basePrompt;

    return [
      `【用户保存的分集计划 ${stage} 阶段 Prompt 覆盖/补充】`,
      '以下内容来自前端预审编辑。必须吸收这些要求，但仍然严格输出本阶段要求的 JSON。',
      normalized,
      '【系统自动注入的本阶段上下文】',
      '下面包含故事圣经、长篇记忆、章节压缩表、本地兜底草稿和 JSON 格式约束，不得忽略。',
      basePrompt
    ].join('\n\n');
  }

  private buildEpisodePlanProviderInputJson(
    pipelineStage: string,
    prompt: string,
    maxOutputTokens: number,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ): Prisma.InputJsonObject {
    const maxTokens = requestParamsOverride.max_output_tokens ?? maxOutputTokens;
    const temperature = requestParamsOverride.temperature ?? (pipelineStage === 'overview' ? 0.2 : 0.24);
    const timeoutMs = requestParamsOverride.timeout_ms ?? 120000;

    return {
      prompt,
      pipeline_stage: pipelineStage,
      max_output_tokens: maxTokens,
      max_tokens: maxTokens,
      temperature,
      timeout_ms: timeoutMs
    };
  }

  private buildEpisodePlanStagePreview(
    project: Project,
    pipelineStage: string,
    title: string,
    prompt: string,
    maxOutputTokens: number,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ) {
    void project;

    return {
      key: pipelineStage.startsWith('batch_') ? 'batch' : pipelineStage,
      pipeline_stage: pipelineStage,
      title,
      prompt,
      input_json: this.buildEpisodePlanProviderInputJson(
        pipelineStage,
        prompt,
        maxOutputTokens,
        requestParamsOverride
      )
    };
  }

  private async generateEpisodeBatchWithProvider(
    project: Project,
    context: EpisodePlanContext,
    overview: EpisodeOverviewItem[],
    previousDrafts: EpisodeDraft[],
    fallbackBatch: EpisodeDraft[],
    selectedProvider: string,
    startNo: number,
    endNo: number,
    taskId?: bigint,
    promptOverride?: string,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ): Promise<EpisodeDraft[]> {
    const prompt = this.applyEpisodePlanPromptOverride(
      this.buildEpisodeBatchPrompt(project, context, overview, previousDrafts, fallbackBatch, startNo, endNo),
      promptOverride,
      'batch'
    );

    const parsed = await this.executeEpisodePlanJsonProvider(
      project,
      selectedProvider,
      `batch_${startNo}_${endNo}`,
      prompt,
      Math.min(12000, Math.max(7000, (endNo - startNo + 1) * 2200)),
      taskId,
      requestParamsOverride
    );
    const drafts = this.episodeDraftsFromObject(parsed, fallbackBatch.length, project, fallbackBatch);

    if (!drafts) {
      if (startNo < endNo) {
        return this.generateEpisodeBatchSplitWithProvider(
          project,
          context,
          overview,
          previousDrafts,
          fallbackBatch,
          selectedProvider,
          startNo,
          endNo,
          taskId,
          promptOverride,
          requestParamsOverride
        );
      }
      return this.throwInvalidProviderJson(`第 ${startNo}-${endNo} 集分集计划`);
    }

    return drafts.map((draft, index) => ({
      ...draft,
      episode_no: startNo + index
    }));
  }

  private async generateEpisodeBatchSplitWithProvider(
    project: Project,
    context: EpisodePlanContext,
    overview: EpisodeOverviewItem[],
    previousDrafts: EpisodeDraft[],
    fallbackBatch: EpisodeDraft[],
    selectedProvider: string,
    startNo: number,
    endNo: number,
    taskId?: bigint,
    promptOverride?: string,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ): Promise<EpisodeDraft[]> {
    const midNo = Math.floor((startNo + endNo) / 2);
    const leftFallback = fallbackBatch.slice(0, midNo - startNo + 1);
    const rightFallback = fallbackBatch.slice(midNo - startNo + 1);
    const leftDrafts: EpisodeDraft[] = await this.generateEpisodeBatchWithProvider(
      project,
      context,
      overview,
      previousDrafts,
      leftFallback,
      selectedProvider,
      startNo,
      midNo,
      taskId,
      promptOverride,
      requestParamsOverride
    );
    const rightDrafts: EpisodeDraft[] = await this.generateEpisodeBatchWithProvider(
      project,
      context,
      overview,
      [...previousDrafts, ...leftDrafts],
      rightFallback,
      selectedProvider,
      midNo + 1,
      endNo,
      taskId,
      promptOverride,
      requestParamsOverride
    );

    return [...leftDrafts, ...rightDrafts];
  }

  private async reconcileEpisodePlanWithProvider(
    project: Project,
    context: EpisodePlanContext,
    overview: EpisodeOverviewItem[],
    drafts: EpisodeDraft[],
    fallbackDrafts: EpisodeDraft[],
    minQualityScore: number,
    selectedProvider: string,
    taskId?: bigint,
    promptOverride?: string,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ) {
    const localScore = this.scoreEpisodePlanDrafts(drafts, context, fallbackDrafts.length, minQualityScore);

    if (localScore.score >= minQualityScore) {
      return drafts;
    }

    const prompt = this.applyEpisodePlanPromptOverride(
      this.buildEpisodeReconcilePrompt(
        project,
        context,
        overview,
        drafts,
        fallbackDrafts,
        minQualityScore,
        localScore
      ),
      promptOverride,
      'reconcile'
    );

    try {
      const parsed = await this.executeEpisodePlanJsonProvider(
        project,
        selectedProvider,
        'reconcile',
        prompt,
        5000,
        taskId,
        requestParamsOverride
      );

      return this.applyEpisodePlanPatches(parsed, drafts, project);
    } catch {
      return drafts;
    }
  }

  private async executeEpisodePlanJsonProvider(
    project: Project,
    selectedProvider: string,
    pipelineStage: string,
    prompt: string,
    maxOutputTokens: number,
    taskId?: bigint,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ) {
    const text = await this.executeEpisodePlanTextProvider(
      project,
      selectedProvider,
      pipelineStage,
      prompt,
      maxOutputTokens,
      taskId,
      requestParamsOverride
    );

    return this.parseProviderJson(text);
  }

  private async executeEpisodePlanTextProvider(
    project: Project,
    selectedProvider: string,
    pipelineStage: string,
    prompt: string,
    maxOutputTokens: number,
    taskId?: bigint,
    requestParamsOverride: EpisodePlanRequestParamsOverride = {}
  ) {
    if (!this.providersService) {
      return '';
    }
    const inputJson = this.buildEpisodePlanProviderInputJson(pipelineStage, prompt, maxOutputTokens, requestParamsOverride);

    const output = await this.providersService.executeProvider({
      provider_type: 'TextProvider',
      preferred_provider_code: selectedProvider,
      purpose: 'episode_plan_generate',
      project_id: project.id.toString(),
      task_id: taskId?.toString(),
      input_json: inputJson,
      allow_fallback: false,
      return_binary: false
    });

    if (taskId) {
      await this.updateEpisodePlanCostSummary(taskId, {
        last_provider_stage: pipelineStage
      });
    }

    return this.extractProviderText(output.result);
  }

  private episodeOverviewFromObject(
    value: Record<string, unknown> | null,
    count: number,
    fallbackDrafts: EpisodeDraft[]
  ): EpisodeOverviewItem[] {
    const items = Array.isArray(value?.overview) ? value.overview : [];
    const overview = items.slice(0, count).map((item, index) => {
      const object = this.readObject(item);
      const fallback = fallbackDrafts[index];
      return {
        episode_no: index + 1,
        title_hint: this.readString(object.title_hint) ?? fallback.title,
        one_sentence: this.readString(object.one_sentence) ?? this.compact(fallback.summary, 120),
        arc_stage: this.readString(object.arc_stage) ?? (index < count * 0.25 ? '开局压迫' : index < count * 0.75 ? '追证反击' : '终局收束'),
        source_chapter_ids: this.readStringArray(object.source_chapter_ids).length
          ? this.readStringArray(object.source_chapter_ids)
          : this.readStringArray(fallback.source_chapter_ids),
        key_hook: this.readString(object.key_hook) ?? fallback.ending_hook,
        must_use_memory: this.readStringArray(object.must_use_memory).slice(0, 5)
      };
    });

    if (overview.length === count) {
      return overview;
    }

    return fallbackDrafts.map((draft, index) => ({
      episode_no: index + 1,
      title_hint: draft.title,
      one_sentence: this.compact(draft.summary, 120),
      arc_stage: index < count * 0.25 ? '开局压迫' : index < count * 0.75 ? '追证反击' : '终局收束',
      source_chapter_ids: this.readStringArray(draft.source_chapter_ids),
      key_hook: draft.ending_hook,
      must_use_memory: []
    }));
  }

  private normalizeEpisodeDrafts(
    drafts: EpisodeDraft[],
    fallbackDrafts: EpisodeDraft[],
    count: number,
    project: Project
  ) {
    const byEpisodeNo = new Map(drafts.map((draft) => [draft.episode_no, draft]));

    return Array.from({ length: count }, (_, index) => {
      const episodeNo = index + 1;
      const draft = byEpisodeNo.get(episodeNo);
      const fallback = fallbackDrafts[index];

      return {
        episode_no: episodeNo,
        source_chapter_ids: this.readStringArray(draft?.source_chapter_ids).length
          ? this.readStringArray(draft?.source_chapter_ids)
          : fallback.source_chapter_ids,
        title: draft?.title || fallback.title,
        summary: draft?.summary || fallback.summary,
        opening_hook: draft?.opening_hook || fallback.opening_hook,
        middle_conflict: draft?.middle_conflict || fallback.middle_conflict,
        ending_hook: draft?.ending_hook || fallback.ending_hook,
        target_duration: this.normalizeEpisodeTargetDuration(draft?.target_duration, project, fallback.target_duration),
        status: 'generated' as EpisodeStatus
      };
    });
  }

  private applyEpisodePlanPatches(
    value: Record<string, unknown> | null,
    drafts: EpisodeDraft[],
    project: Project
  ) {
    const patches = Array.isArray(value?.patches) ? value.patches : [];
    const byEpisodeNo = new Map(drafts.map((draft) => [draft.episode_no, draft]));

    for (const item of patches) {
      const object = this.readObject(item);
      const episodeNo = this.readNumber(object.episode_no);

      if (!episodeNo || !byEpisodeNo.has(episodeNo)) {
        continue;
      }

      const current = byEpisodeNo.get(episodeNo)!;
      const patched = {
        ...current,
        title: this.readString(object.title) ?? current.title,
        summary: this.readString(object.summary) ?? current.summary,
        opening_hook: this.readString(object.opening_hook) ?? current.opening_hook,
        middle_conflict: this.readString(object.middle_conflict) ?? current.middle_conflict,
        ending_hook: this.readString(object.ending_hook) ?? current.ending_hook,
        source_chapter_ids: this.readStringArray(object.source_chapter_ids).length
          ? this.readStringArray(object.source_chapter_ids)
          : current.source_chapter_ids,
        target_duration: this.normalizeEpisodeTargetDuration(
          this.readNumber(object.target_duration),
          project,
          current.target_duration
        )
      };
      byEpisodeNo.set(episodeNo, this.mergeEpisodeProductionBlueprint(patched, object));
    }

    return [...byEpisodeNo.values()].sort((left, right) => left.episode_no - right.episode_no);
  }

  private mergeEpisodeProductionBlueprint(draft: EpisodeDraft, source: Record<string, unknown>): EpisodeDraft {
    const blueprint = this.readObject(source.production_blueprint);
    const readValue = (key: string) => source[key] ?? blueprint[key];
    const mustKeepEvents = this.readEpisodePlanList(readValue('must_keep_events'));
    const mustKeepDialogues = this.readEpisodePlanList(readValue('must_keep_dialogues'));
    const keyProps = this.readEpisodePlanList(readValue('key_props'));
    const keyScenes = this.readEpisodePlanList(readValue('key_scenes'));
    const scriptBeats = this.readEpisodePlanList(readValue('script_beats'));
    const emotionalTurn = this.readString(readValue('emotional_turn'));
    const evidenceTurn = this.readString(readValue('evidence_turn'));
    const openingPayoff = this.readString(readValue('opening_payoff'));
    const endingQuestion = this.readString(readValue('ending_question'));

    const blueprintLines = [
      mustKeepEvents.length ? `必保事件：${mustKeepEvents.join('；')}` : null,
      mustKeepDialogues.length ? `必保对白：${mustKeepDialogues.join('；')}` : null,
      keyProps.length ? `关键道具：${keyProps.join('；')}` : null,
      keyScenes.length ? `关键场景：${keyScenes.join('；')}` : null,
      emotionalTurn ? `情绪转折：${emotionalTurn}` : null,
      evidenceTurn ? `证据转折：${evidenceTurn}` : null,
      openingPayoff ? `开场兑现：${openingPayoff}` : null,
      endingQuestion ? `追看问题：${endingQuestion}` : null,
      scriptBeats.length ? `脚本Beat：${scriptBeats.join(' / ')}` : null
    ].filter((line): line is string => Boolean(line));

    if (blueprintLines.length === 0) {
      return draft;
    }

    const middleLines = [
      draft.middle_conflict,
      mustKeepEvents.length ? `必保事件：${mustKeepEvents.join('；')}` : null,
      mustKeepDialogues.length ? `必保对白：${mustKeepDialogues.join('；')}` : null,
      scriptBeats.length ? `脚本Beat：${scriptBeats.join(' / ')}` : null
    ].filter(Boolean).join('\n');

    return {
      ...draft,
      summary: this.appendEpisodePlanSection(draft.summary, '制作蓝图', blueprintLines),
      opening_hook: openingPayoff ? `${draft.opening_hook}\n开场兑现：${openingPayoff}` : draft.opening_hook,
      middle_conflict: middleLines,
      ending_hook: endingQuestion ? `${draft.ending_hook}\n追看问题：${endingQuestion}` : draft.ending_hook
    };
  }

  private appendEpisodePlanSection(text: string, title: string, lines: string[]) {
    if (!lines.length || text.includes(`【${title}】`)) return text;
    return `${text}\n【${title}】\n${lines.join('\n')}`;
  }

  private readEpisodePlanList(value: unknown) {
    if (Array.isArray(value)) {
      return value
        .map((item) => {
          if (typeof item === 'string') return item;
          const object = this.readObject(item);
          const parts = [
            this.readString(object.beat),
            this.readString(object.speaker),
            this.readString(object.line) ?? this.readString(object.text),
            this.readString(object.event),
            this.readString(object.scene),
            this.readString(object.prop),
            this.readString(object.desc) ?? this.readString(object.description)
          ].filter(Boolean);
          return parts.join('：');
        })
        .map((item) => item.trim())
        .filter(Boolean)
        .slice(0, 12);
    }

    if (typeof value === 'string' && value.trim()) {
      return value
        .split(/[;\n；]/)
        .map((item) => item.trim())
        .filter(Boolean)
        .slice(0, 12);
    }

    return [];
  }

  private createEpisodePlanContextBrief(context: EpisodePlanContext) {
    return [
      `角色：${context.characters.slice(0, 12).map((character) => `${character.name}/${character.role_type}/${this.compact(character.identity_desc ?? '', 80)}`).join('；')}`,
      `长篇记忆重点：${context.plotMemories
        .slice()
        .sort((left, right) => right.importance_level - left.importance_level)
        .slice(0, 45)
        .map((memory) => `${memory.memory_type}/${memory.importance_level}：${this.compact(memory.content, 180)}`)
        .join('\n')}`,
      `开放剧情线：${context.plotThreads
        .slice(0, 20)
        .map((thread) => `${thread.thread_type}/${thread.status}：${thread.thread_name} ${this.compact(thread.description ?? '', 160)}`)
        .join('\n')}`
    ].filter(Boolean).join('\n\n');
  }

  private createChapterBriefs(chapters: NovelChapter[], length: number) {
    return chapters.map((chapter) =>
      `${chapter.id.toString()} 第${chapter.chapter_no}章 ${chapter.title ?? ''}：${chapter.summary ?? this.compact(chapter.content, length)}`
    );
  }

  private resolveEpisodePlanBatchSize(count: number) {
    if (count <= 12) return count;
    return 3;
  }

  private ensureEpisodePlanTaskRunning(taskId: bigint) {
    void this.runEpisodePlanTask(taskId).catch(() => undefined);
  }

  private findActiveEpisodePlanTask(projectId: bigint) {
    return this.prisma.renderTask.findFirst({
      where: {
        project_id: projectId,
        task_type: 'episode_plan_generate',
        status: { in: ['pending', 'running', 'retrying'] }
      },
      orderBy: { created_at: 'desc' }
    });
  }

  private async markEpisodePlanTaskFailed(taskId: bigint, error: unknown) {
    const latest = await this.prisma.renderTask.findUnique({ where: { id: taskId } }).catch(() => null);
    const message = this.errorMessage(error);

    if (!latest) return;
    await this.updateEpisodePlanCostSummary(taskId, {
      pipeline_status: {
        mode: 'overview_batch_reconcile',
        phase: 'failed',
        error_message: message,
        failed_at: new Date().toISOString()
      }
    }).catch(() => undefined);

    if (latest.retry_count < latest.max_retry) {
      const retrying = await this.prisma.renderTask.update({
        where: { id: latest.id },
        data: {
          status: 'retrying',
          retry_count: latest.retry_count + 1,
          provider_request_id: null,
          error_code: null,
          error_message: null,
          started_at: null,
          finished_at: null
        }
      });
      setTimeout(() => this.ensureEpisodePlanTaskRunning(retrying.id), 0);
      return;
    }

    await this.prisma.renderTask.update({
      where: { id: latest.id },
      data: {
        status: 'failed',
        error_code: this.errorCodeFromMessage(message),
        error_message: message,
        finished_at: new Date()
      }
    }).catch(() => undefined);
  }

  private errorCodeFromMessage(message: string) {
    return message.replace(/[^a-zA-Z0-9_]+/g, '_').slice(0, 100) || 'EPISODE_PLAN_TASK_FAILED';
  }

  private async updateEpisodePlanTaskMeta(taskId: bigint, meta: Record<string, unknown>) {
    await this.updateEpisodePlanCostSummary(taskId, meta);
  }

  private async updateEpisodePlanCostSummary(taskId: bigint, meta: Record<string, unknown> = {}) {
    const task = await this.prisma.renderTask.findUnique({ where: { id: taskId } });

    if (!task) return;

    const input = this.readObject(task.input_json);
    const logs = await this.prisma.providerLog.findMany({
      where: { task_id: task.id },
      orderBy: { created_at: 'desc' }
    });
    const usage = this.sumProviderUsage(logs.map((log) => log.response_json));
    const costEstimate = logs.reduce((sum, log) => sum + Number(log.cost_estimate ?? 0), 0);
    const costActual = logs.reduce((sum, log) => sum + Number(log.cost_actual ?? 0), 0);
    const latestSuccessLog = logs.find((log) => log.status === 'success');

    await this.prisma.renderTask.update({
      where: { id: task.id },
      data: {
        cost_estimate: Number(costEstimate.toFixed(4)),
        cost_actual: Number(costActual.toFixed(4)),
        input_json: {
          ...input,
          ...meta,
          provider_usage: Object.keys(usage).length > 0 ? usage : input.provider_usage ?? null,
          provider_log_ids: logs.map((log) => log.id.toString()).reverse(),
          provider_log_id: latestSuccessLog?.id.toString() ?? input.provider_log_id ?? null,
          cost_summary: {
            provider_call_count: logs.length,
            success_call_count: logs.filter((log) => log.status === 'success').length,
            failed_call_count: logs.filter((log) => log.status === 'failed').length,
            cost_estimate: Number(costEstimate.toFixed(4)),
            cost_actual: Number(costActual.toFixed(4))
          }
        } as Prisma.InputJsonObject
      }
    });
  }

  private sumProviderUsage(values: (Prisma.JsonValue | null)[]) {
    const usage: Record<string, number> = {};
    let reasoningTokens = 0;

    for (const value of values) {
      const response = this.readObject(value);
      const item = this.readObject(response.usage);
      const inputTokens = this.readNumber(item.input_tokens) ?? 0;
      const outputTokens = this.readNumber(item.output_tokens) ?? 0;
      const totalTokens = this.readNumber(item.total_tokens) ?? 0;
      const outputDetails = this.readObject(item.output_tokens_details);
      const reasoning = this.readNumber(outputDetails.reasoning_tokens) ?? 0;

      usage.input_tokens = (usage.input_tokens ?? 0) + inputTokens;
      usage.output_tokens = (usage.output_tokens ?? 0) + outputTokens;
      usage.total_tokens = (usage.total_tokens ?? 0) + totalTokens;
      reasoningTokens += reasoning;
    }

    if ((usage.input_tokens ?? 0) <= 0 && (usage.output_tokens ?? 0) <= 0 && (usage.total_tokens ?? 0) <= 0) {
      return {};
    }

    if (!usage.total_tokens) {
      usage.total_tokens = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
    }

    if (reasoningTokens > 0) {
      return {
        ...usage,
        output_tokens_details: {
          reasoning_tokens: reasoningTokens
        }
      };
    }

    return usage;
  }

  private episodeDraftsFromObject(
    value: Record<string, unknown> | null,
    count: number,
    project: Project,
    fallbackDrafts: EpisodeDraft[]
  ): EpisodeDraft[] | null {
    const items = Array.isArray(value?.episodes) ? value.episodes : [];
    if (items.length === 0) return null;
    const drafts = items.slice(0, count).map((item, index) => {
      const object = this.readObject(item);
      const fallback = fallbackDrafts[index];
      const draft = {
        episode_no: index + 1,
        source_chapter_ids: this.readStringArray(object.source_chapter_ids).length
          ? this.readStringArray(object.source_chapter_ids)
          : fallback.source_chapter_ids,
        title: this.readString(object.title) ?? fallback.title,
        summary: this.readString(object.summary) ?? fallback.summary,
        opening_hook: this.readString(object.opening_hook) ?? fallback.opening_hook,
        middle_conflict: this.readString(object.middle_conflict) ?? fallback.middle_conflict,
        ending_hook: this.readString(object.ending_hook) ?? fallback.ending_hook,
        target_duration: this.normalizeEpisodeTargetDuration(
          this.readNumber(object.target_duration),
          project,
          fallback.target_duration
        ),
        status: 'generated' as EpisodeStatus
      };

      return this.mergeEpisodeProductionBlueprint(draft, object);
    });

    return drafts.length === count && drafts.every((draft) => draft.title && draft.summary) ? drafts : null;
  }

  private scoreEpisodePlanDrafts(
    drafts: EpisodeDraft[],
    context: EpisodePlanContext,
    expectedCount: number,
    targetScore: number
  ) {
    const draftTexts = drafts.map((draft) =>
      [
        draft.title,
        draft.summary,
        draft.opening_hook,
        draft.middle_conflict,
        draft.ending_hook
      ].join('\n')
    );
    const fullText = draftTexts.join('\n');
    const completeFieldCount = drafts.filter((draft) =>
      draft.title &&
      draft.summary &&
      draft.opening_hook &&
      draft.middle_conflict &&
      draft.ending_hook &&
      draft.target_duration
    ).length;
    const hookCount = drafts.filter((draft) =>
      this.hasEpisodeHook(draft.opening_hook) && this.hasEpisodeHook(draft.ending_hook)
    ).length;
    const conflictCount = drafts.filter((draft) =>
      /冲突|对峙|证据|反击|施压|逼迫|调查|揭露|真相|反转|翻车|失控|崩盘/u.test(
        `${draft.middle_conflict}\n${draft.summary}`
      )
    ).length;
    const sourceChapterIds = new Set(
      drafts.flatMap((draft) => this.readStringArray(draft.source_chapter_ids))
    );
    const expectedSourceCount = Math.min(context.chapters.length, Math.max(expectedCount, 1));
    const sourceCoverage = expectedSourceCount > 0
      ? this.ratioScore(Math.min(sourceChapterIds.size, expectedSourceCount), expectedSourceCount)
      : 100;
    const characterNames = context.characters
      .filter((character) => ['protagonist', 'lead', 'antagonist', 'supporting'].includes(character.role_type))
      .slice(0, 8)
      .map((character) => character.name)
      .filter(Boolean);
    const characterCoverage = characterNames.length === 0
      ? 100
      : this.ratioScore(characterNames.filter((name) => fullText.includes(name)).length, Math.min(characterNames.length, 6));
    const memoryKeywords = context.plotMemories
      .filter((memory) => memory.importance_level >= 75)
      .flatMap((memory) => this.extractKeywords(memory.content))
      .filter(Boolean);
    const uniqueMemoryKeywords = [...new Set(memoryKeywords)].slice(0, 30);
    const memoryAbsorption = uniqueMemoryKeywords.length === 0
      ? 100
      : this.ratioScore(uniqueMemoryKeywords.filter((keyword) => fullText.includes(keyword)).length, Math.min(uniqueMemoryKeywords.length, 12));
    const threadKeywords = context.plotThreads
      .flatMap((thread) => this.extractKeywords(`${thread.thread_name} ${thread.description ?? ''}`))
      .filter(Boolean);
    const uniqueThreadKeywords = [...new Set(threadKeywords)].slice(0, 20);
    const threadProgress = uniqueThreadKeywords.length === 0
      ? 100
      : this.ratioScore(uniqueThreadKeywords.filter((keyword) => fullText.includes(keyword)).length, Math.min(uniqueThreadKeywords.length, 8));
    const shortDramaTerms = ['下一集', '真相', '证据', '反转', '出现', '揭露', '电话', '监控', '文件', '证人', '崩盘', '翻车'];
    const rhythmScore = this.ratioScore(shortDramaTerms.filter((term) => fullText.includes(term)).length, 6);
    const durationValues = drafts
      .map((draft) => draft.target_duration)
      .filter((value) => Number.isFinite(value));
    const uniqueDurations = new Set(durationValues);
    const durationAdaptationScore = expectedCount <= 1
      ? 100
      : durationValues.length !== expectedCount
        ? 60
        : uniqueDurations.size >= Math.min(3, expectedCount)
          ? 100
          : uniqueDurations.size >= 2
            ? 88
            : 76;
    const blueprintCount = drafts.filter((draft) =>
      /制作蓝图|必保事件|必保对白|关键道具|关键场景|情绪转折|证据转折|脚本Beat/u.test(
        `${draft.summary}\n${draft.middle_conflict}\n${draft.opening_hook}\n${draft.ending_hook}`
      )
    ).length;
    const blueprintScore = this.ratioScore(blueprintCount, expectedCount);
    const terminalClosure = this.scoreEpisodeTerminalClosure(drafts);
    const countScore = drafts.length === expectedCount ? 100 : this.ratioScore(drafts.length, expectedCount);
    const fieldScore = this.ratioScore(completeFieldCount, expectedCount);
    const hookScore = this.ratioScore(hookCount, expectedCount);
    const conflictScore = this.ratioScore(conflictCount, expectedCount);
    const duplicatePenalty = this.duplicateContentPenalty([
      ...drafts.map((draft) => draft.title),
      ...drafts.map((draft) => draft.summary.slice(0, 120)),
      ...drafts.map((draft) => draft.ending_hook)
    ]);
    const metrics = {
      episode_count: drafts.length,
      expected_count: expectedCount,
      count_score: countScore,
      field_score: fieldScore,
      hook_score: hookScore,
      conflict_score: conflictScore,
      source_coverage: sourceCoverage,
      character_coverage: characterCoverage,
      memory_absorption: memoryAbsorption,
      thread_progress: threadProgress,
      short_drama_rhythm: rhythmScore,
      duration_adaptation: durationAdaptationScore,
      production_blueprint: blueprintScore,
      terminal_closure: terminalClosure.score,
      terminal_closure_missing: terminalClosure.missing,
      duration_values: durationValues,
      duplicate_penalty: duplicatePenalty
    };
    const score = Math.max(0, Math.min(100, Math.round(
      countScore * 0.07 +
      fieldScore * 0.08 +
      hookScore * 0.10 +
      conflictScore * 0.10 +
      sourceCoverage * 0.08 +
      characterCoverage * 0.06 +
      memoryAbsorption * 0.11 +
      threadProgress * 0.07 +
      rhythmScore * 0.05 +
      durationAdaptationScore * 0.03 +
      blueprintScore * 0.11 +
      terminalClosure.score * 0.14 -
      duplicatePenalty
    )));
    const strengths: string[] = [];
    const issues: string[] = [];
    const suggestions: string[] = [];

    if (score >= targetScore) {
      strengths.push(`分集计划通过当前 ${targetScore} 分质量门，可进入脚本生成。`);
    }
    if (hookScore >= 95) strengths.push('每集开头和结尾都有可承接钩子。');
    if (memoryAbsorption >= 85) strengths.push('已吸收长篇记忆中的伏笔、证据和未解决冲突。');
    if (sourceCoverage >= 90) strengths.push('章节来源覆盖较完整，适合长篇压缩改编。');
    if (durationAdaptationScore >= 90) strengths.push('集长已按剧情密度动态规划，不再机械固定 60 秒。');
    if (blueprintScore >= 90) strengths.push('每集已包含制作蓝图，可直接服务脚本、25宫格分镜和视频镜头。');
    if (terminalClosure.score >= 75) strengths.push('终局已交代核心冲突结果、主角选择、状态变化与后续余波。');

    if (drafts.length !== expectedCount) {
      issues.push(`集数不匹配：需要 ${expectedCount} 集，实际 ${drafts.length} 集。`);
    }
    if (fieldScore < 100) {
      issues.push('部分分集缺少标题、摘要、开场钩子、中段冲突、结尾钩子或时长。');
      suggestions.push('补齐每集 6 个基础字段后再确认。');
    }
    if (hookScore < 90) {
      issues.push('部分分集钩子不够强，短剧承接感不足。');
      suggestions.push('每集开场写即时冲突，结尾写下一集必须追看的新线索或反转。');
    }
    if (memoryAbsorption < 75) {
      issues.push('长篇记忆吸收不足，可能漏掉伏笔、证据、道具或人物状态。');
      suggestions.push('重新生成时强调使用 plot_memories 和 plot_threads。');
    }
    if (threadProgress < 75) {
      issues.push('开放剧情线推进不足，后续脚本可能散。');
      suggestions.push('每集至少推进一条主线、悬疑线或反派计划。');
    }
    if (durationAdaptationScore < 85 && expectedCount > 1) {
      issues.push('集长变化不足，可能仍然按固定秒数机械规划。');
      suggestions.push('高密度反转集可放宽到 75-90 秒，过渡/信息较少的集控制在 45-60 秒。');
    }
    if (blueprintScore < 90) {
      issues.push('部分分集缺少制作蓝图，后续脚本/分镜可能继续脑补导致删减或不连贯。');
      suggestions.push('为每集补齐必保事件、必保对白、关键道具、关键场景、证据转折和脚本Beat。');
    }
    if (terminalClosure.score < 75) {
      issues.push(`终局闭环不足，缺少：${terminalClosure.missing.join('、')}。`);
      suggestions.push('在末段补齐核心冲突结果、主角主动选择、关键人物状态变化和事件余波；具体内容必须来自本项目剧本与设定。');
    }
    if (duplicatePenalty > 0) {
      issues.push('存在重复标题、摘要或结尾钩子。');
    }

    return {
      score,
      target_score: targetScore,
      passed: score >= targetScore,
      level: score >= targetScore ? 'excellent' : score >= 90 ? 'ready' : 'needs_review',
      strengths,
      issues,
      suggestions,
      metrics
    };
  }

  private hasEpisodeHook(value: string) {
    return Boolean(value?.trim()) && /下一集|真相|证据|发现|出现|反转|揭露|电话|监控|敲门|追查|逼近|崩盘|翻车|直播|威胁|签署|认罪|死亡|病危|红屏|大屏|审判|法庭|秘密|身份|摔|亮起|弹出|喊/u.test(value);
  }

  private scoreEpisodeTerminalClosure(drafts: EpisodeDraft[]) {
    const terminalText = drafts
      .slice(Math.max(0, drafts.length - 10))
      .map((draft) => [
        draft.title,
        draft.summary,
        draft.opening_hook,
        draft.middle_conflict,
        draft.ending_hook
      ].join('\n'))
      .join('\n');
    const requirements = [
      {
        label: '核心冲突结果',
        pattern: /真相.{0,16}(?:公开|揭露|查明)|(?:对手|反派).{0,16}(?:失败|被捕|伏法|付出代价)|(?:危机|冲突).{0,16}(?:解除|解决)|(?:任务|目标).{0,16}(?:完成|失败)|终局|结局/u
      },
      {
        label: '主角主动选择',
        pattern: /选择|决定|拒绝|接受|承担|牺牲|放下|反击|揭露|离开|留下|回归/u
      },
      {
        label: '关键人物状态变化',
        pattern: /从此|后来|重新|成为|失去|得到|恢复|建立|重建|和解|决裂|获救|死亡/u
      },
      {
        label: '事件余波或新秩序',
        pattern: /余波|新生活|新秩序|未来|代价|传开|天下皆知|众人|再也|开始|落幕|结束/u
      }
    ];
    const missing = requirements
      .filter((requirement) => !requirement.pattern.test(terminalText))
      .map((requirement) => requirement.label);

    return {
      score: this.ratioScore(requirements.length - missing.length, requirements.length),
      missing
    };
  }

  private ratioScore(value: number, target: number) {
    if (target <= 0) return 100;
    return Math.max(0, Math.min(100, Math.round((value / target) * 100)));
  }

  private duplicateContentPenalty(values: string[]) {
    const normalized = values
      .map((value) => this.compact(value, 160).slice(0, 80))
      .filter(Boolean);
    const unique = new Set(normalized);
    const duplicateCount = Math.max(0, normalized.length - unique.size);

    return Math.min(10, duplicateCount * 2);
  }

  private extractKeywords(text: string) {
    const compacted = this.compact(text, 500);
    const matches = compacted.match(/[\u4e00-\u9fa5]{2,8}/g) ?? [];
    const stopWords = new Set([
      '本集',
      '下一集',
      '主要',
      '目标',
      '需要',
      '继续',
      '推进',
      '角色',
      '剧情',
      '故事',
      '短剧'
    ]);

    return matches
      .flatMap((match) => (match.length > 4 ? [match.slice(0, 4), match.slice(-4)] : [match]))
      .filter((match) => match.length >= 2 && !stopWords.has(match))
      .slice(0, 20);
  }

  private buildEpisodeTitle(episodeNo: number, chapter: NovelChapter, count: number) {
    const cleaned = chapter.title
      ?.replace(/^第?[0-9一二三四五六七八九十百千万]+[章节集回话、.\s-]*/u, '')
      .trim();
    const fallback = episodeNo === count ? '真相逼近' : episodeNo === 1 ? '开局反击' : '冲突升级';
    return `第${episodeNo}集 ${cleaned || fallback}`;
  }

  private buildEndingHook(
    episodeNo: number,
    count: number,
    protagonistName: string,
    chapter: NovelChapter,
    foreshadowing: PlotMemory | undefined,
    storyBible: StoryBible
  ) {
    if (episodeNo === count) {
      return storyBible.ending_direction || `${protagonistName}阶段性赢下对抗，但幕后真相仍未完全揭开。`;
    }

    const source = foreshadowing?.content || chapter.summary || chapter.title || '关键线索';
    return `${protagonistName}发现${this.compact(source).slice(0, 42)}，下一集必须继续追查。`;
  }

  private pickChapterGroup(chapters: NovelChapter[], index: number, count: number) {
    const start = Math.floor((index * chapters.length) / count);
    const end = Math.max(start + 1, Math.floor(((index + 1) * chapters.length) / count));
    return chapters.slice(start, Math.min(end, chapters.length));
  }

  private async createUpdateData(
    episode: Episode,
    dto: UpdateEpisodeDto
  ): Promise<Prisma.EpisodeUncheckedUpdateInput> {
    const data: Prisma.EpisodeUncheckedUpdateInput = {};

    if ('episode_no' in dto) {
      data.episode_no = await this.validateEpisodeNoForUpdate(episode, dto.episode_no);
    }
    if ('source_chapter_ids' in dto) {
      data.source_chapter_ids = await this.validateSourceChapterIds(
        episode.project_id,
        dto.source_chapter_ids
      );
    }
    if ('title' in dto) data.title = this.optionalText(dto.title);
    if ('summary' in dto) data.summary = this.optionalText(dto.summary);
    if ('opening_hook' in dto) data.opening_hook = this.optionalText(dto.opening_hook);
    if ('middle_conflict' in dto) data.middle_conflict = this.optionalText(dto.middle_conflict);
    if ('ending_hook' in dto) data.ending_hook = this.optionalText(dto.ending_hook);
    if ('target_duration' in dto) {
      data.target_duration = this.validateDuration(dto.target_duration);
    }
    if ('status' in dto) data.status = this.validateStatus(dto.status);

    if (Object.keys(data).length > 0 && data.status !== 'confirmed') {
      data.status = data.status ?? 'edited';
    }

    return data;
  }

  private async validateEpisodeNoForUpdate(episode: Episode, value: number | undefined) {
    const episodeNo = this.validatePositiveInt(value, 'episode_no', MIN_EPISODES, MAX_EPISODES);

    if (episodeNo === episode.episode_no) {
      return episodeNo;
    }

    const existing = await this.prisma.episode.findFirst({
      where: {
        project_id: episode.project_id,
        episode_no: episodeNo,
        id: { not: episode.id }
      }
    });

    if (existing) {
      throw new BadRequestException('episode_no already exists in this project');
    }

    return episodeNo;
  }

  private async validateSourceChapterIds(projectId: bigint, value: string[] | undefined) {
    if (!Array.isArray(value) || value.length === 0) {
      throw new BadRequestException('source_chapter_ids must be a non-empty array');
    }

    const ids = value.map((item) => this.parseId(String(item), 'Invalid source chapter id'));
    const count = await this.prisma.novelChapter.count({
      where: {
        project_id: projectId,
        id: { in: ids }
      }
    });

    if (count !== ids.length) {
      throw new BadRequestException('source_chapter_ids contain chapters outside this project');
    }

    return ids.map((id) => id.toString());
  }

  private assertEpisodesReadyForConfirmation(episodes: Episode[]) {
    if (episodes.length === 0) {
      throw new BadRequestException('Episode plan is required before confirmation');
    }

    for (const [index, episode] of episodes.entries()) {
      if (episode.episode_no !== index + 1) {
        throw new BadRequestException('Episode numbers must be continuous from 1');
      }

      if (
        !episode.title ||
        !episode.summary ||
        !episode.opening_hook ||
        !episode.middle_conflict ||
        !episode.ending_hook ||
        !episode.target_duration
      ) {
        throw new BadRequestException('All episodes must include title, hooks, conflict, summary, and duration');
      }
    }
  }

  private async findProjectForUser(projectId: string, user: AuthRequestUser) {
    const project = await this.prisma.project.findUnique({
      where: { id: this.parseId(projectId, 'Invalid project id') }
    });

    if (!project) {
      throw new NotFoundException('Project not found');
    }

    if (project.user_id.toString() !== user.id && user.role !== 'admin') {
      throw new ForbiddenException('Project is private');
    }

    return project;
  }

  private assertLegacyWritePath(project: Project) {
    if (project.engine_version === 'splus_v1') {
      throw new BadRequestException('splus_v1 项目必须使用结构化 EpisodePlan 合同，旧分集写接口只读');
    }
  }

  private async findEpisodeForUser(episodeId: string, user: AuthRequestUser) {
    const episode = await this.prisma.episode.findUnique({
      where: { id: this.parseId(episodeId, 'Invalid episode id') }
    });

    if (!episode) {
      throw new NotFoundException('Episode not found');
    }

    await this.findProjectForUser(episode.project_id.toString(), user);
    return episode;
  }

  private resolveEpisodeCount(project: Project, value: number | undefined) {
    return this.validatePositiveInt(
      value ?? project.target_episode_count ?? (project.input_mode === 'ai_original' ? 3 : 1),
      'target_episode_count',
      MIN_EPISODES,
      MAX_EPISODES
    );
  }

  private validateDuration(value: number | undefined) {
    return this.validatePositiveInt(value, 'target_duration', MIN_DURATION, MAX_DURATION);
  }

  private resolveEpisodeReferenceDuration(project: Project) {
    return this.validateDuration(project.episode_duration ?? DEFAULT_EPISODE_DURATION);
  }

  private episodeDurationPlanningGuide(project: Project) {
    const referenceDuration = this.resolveEpisodeReferenceDuration(project);

    return [
      `集长规则：项目参考单集 ${referenceDuration} 秒，但这不是硬限制。`,
      `请按剧情密度为每集单独选择 target_duration，常规精品区间 ${MIN_QUALITY_EPISODE_DURATION}-${MAX_QUALITY_EPISODE_DURATION} 秒。`,
      '建议：过渡/铺垫集 60-75 秒；常规冲突集 75-100 秒；强反转/多证据/情绪爆发集 100-140 秒；终局或复杂爆点集可到 140-180 秒。',
      '不要为了凑固定 60 秒删掉关键冲突，也不要无意义拉长；target_duration 必须服务剧情节奏。'
    ].join(' ');
  }

  private normalizeEpisodeTargetDuration(
    value: number | null | undefined,
    project: Project,
    fallbackDuration?: number
  ) {
    const fallback = fallbackDuration ?? this.resolveEpisodeReferenceDuration(project);
    const numeric = Number(value);

    if (!Number.isFinite(numeric)) {
      return this.validateDuration(fallback);
    }

    return this.validateDuration(Math.round(numeric));
  }

  private estimateEpisodeTargetDuration(input: {
    project: Project;
    referenceDuration: number;
    episodeNo: number;
    count: number;
    text: string;
  }) {
    const text = input.text || '';
    const keywordScore = [
      /反转|翻车|真相|证据|揭露|曝光|审判|死亡|车祸|崩盘|灭口/u,
      /亲情|亲子|身份|血缘|旧案|秘密地点|关键载体|账本|录音/u,
      /对峙|逼迫|威胁|追查|逃离|失控|反击|钩子/u
    ].reduce((score, pattern) => score + (pattern.test(text) ? 1 : 0), 0);
    let duration = input.referenceDuration;

    if (input.referenceDuration === DEFAULT_EPISODE_DURATION) {
      duration = text.length > 700 || keywordScore >= 3 ? 75 : text.length < 260 && keywordScore <= 1 ? 45 : 60;
    } else if (keywordScore >= 3 || text.length > 900) {
      duration += 15;
    } else if (keywordScore <= 1 && text.length < 260) {
      duration -= 15;
    }

    if (input.episodeNo === 1 || input.episodeNo === input.count) {
      duration = Math.max(duration, Math.min(MAX_QUALITY_EPISODE_DURATION, input.referenceDuration + 15));
    }

    return this.validateDuration(Math.max(
      MIN_QUALITY_EPISODE_DURATION,
      Math.min(MAX_QUALITY_EPISODE_DURATION, duration)
    ));
  }

  private validateStatus(value: string | undefined): EpisodeStatus {
    if (!value || !EPISODE_STATUSES.includes(value as never)) {
      throw new BadRequestException('episode status is invalid');
    }

    return value as EpisodeStatus;
  }

  private validatePositiveInt(value: unknown, field: string, min: number, max: number) {
    const numberValue = Number(value);

    if (!Number.isInteger(numberValue) || numberValue < min || numberValue > max) {
      throw new BadRequestException(`${field} must be an integer between ${min} and ${max}`);
    }

    return numberValue;
  }

  private optionalText(value: string | undefined) {
    const normalized = value?.trim();
    return normalized || null;
  }

  private compact(value: string, length = 600) {
    return value.replace(/\s+/g, ' ').trim().slice(0, length);
  }

  private readObject(value: unknown): Record<string, unknown> {
    return value && typeof value === 'object' && !Array.isArray(value)
      ? (value as Record<string, unknown>)
      : {};
  }

  private storyBibleProductionContext(storyBible: StoryBible, keys: string[]) {
    const bible = this.readObject(storyBible.production_bible_json);

    if (Object.keys(bible).length === 0) {
      return '';
    }

    const selected: Record<string, unknown> = {};

    for (const key of keys) {
      if (bible[key] !== undefined) {
        selected[key] = bible[key];
      }
    }

    return this.compact(JSON.stringify(Object.keys(selected).length > 0 ? selected : bible), 7000);
  }

  private readString(value: unknown) {
    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
  }

  private readNumber(value: unknown) {
    const numberValue = Number(value);
    return Number.isFinite(numberValue) ? numberValue : null;
  }

  private readStringArray(value: unknown) {
    return Array.isArray(value)
      ? value.map((item) => String(item).trim()).filter(Boolean)
      : [];
  }

  private normalizeEpisodePlanPromptOverrides(value: unknown): EpisodePlanPromptOverrides {
    const object = this.readObject(value);
    const normalizePrompt = (child: unknown) => this.compact(this.readString(child) ?? '', 20000);
    const normalized: EpisodePlanPromptOverrides = {};
    const overview = normalizePrompt(object.overview);
    const batch = normalizePrompt(object.batch);
    const reconcile = normalizePrompt(object.reconcile);

    if (overview) normalized.overview = overview;
    if (batch) normalized.batch = batch;
    if (reconcile) normalized.reconcile = reconcile;

    return normalized;
  }

  private normalizeEpisodePlanRequestParamsOverride(value: unknown): EpisodePlanRequestParamsOverride {
    const object = this.readObject(value);
    const maxOutputTokens = this.readNumber(object.max_output_tokens);
    const temperature = this.readNumber(object.temperature);
    const timeoutMs = this.readNumber(object.timeout_ms);
    const normalized: EpisodePlanRequestParamsOverride = {};

    if (maxOutputTokens !== null) {
      normalized.max_output_tokens = Math.max(2000, Math.min(20000, Math.round(maxOutputTokens)));
    }
    if (temperature !== null) {
      normalized.temperature = Number(Math.max(0, Math.min(1, temperature)).toFixed(2));
    }
    if (timeoutMs !== null) {
      normalized.timeout_ms = Math.max(30000, Math.min(300000, Math.round(timeoutMs)));
    }

    return normalized;
  }

  private extractProviderText(result: unknown) {
    const object = this.readObject(result);
    return this.readString(object.text) ?? this.readString(object.chapter_text) ?? '';
  }

  private parseProviderJson(text: string): Record<string, unknown> | null {
    const cleaned = text.replace(/^```(?:json)?/i, '').replace(/```$/i, '').trim();
    const jsonText = cleaned.startsWith('{') ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? '';

    if (!jsonText) return null;

    try {
      const parsed = JSON.parse(jsonText) as unknown;
      return this.readObject(parsed);
    } catch {
      return null;
    }
  }

  private parsePartialEpisodeCountRecommendationJson(text: string): Record<string, unknown> | null {
    const count = this.readNumberFromText(text, /"recommended_episode_count"\s*:\s*(\d+)/u);

    if (!count) return null;

    return {
      recommended_episode_count: count,
      reasoning: this.readJsonStringFromText(text, 'reasoning') ?? 'AI 已返回推荐集数，但说明字段不完整。',
      duration_policy: this.readJsonStringFromText(text, 'duration_policy') ?? '',
      split_merge_rules: this.readJsonArrayStringsFromText(text, 'split_merge_rules'),
      risk_notes: this.readJsonArrayStringsFromText(text, 'risk_notes')
    };
  }

  private readNumberFromText(text: string, pattern: RegExp) {
    const match = text.match(pattern);
    if (!match?.[1]) return null;
    const value = Number(match[1]);
    return Number.isFinite(value) ? value : null;
  }

  private readJsonStringFromText(text: string, key: string) {
    const pattern = new RegExp(`"${key}"\\s*:\\s*"((?:\\\\\\\\.|[^"\\\\\\\\])*)`, 'u');
    const match = text.match(pattern);
    if (!match?.[1]) return null;

    try {
      return JSON.parse(`"${match[1]}"`) as string;
    } catch {
      return match[1].replace(/\\"/g, '"').replace(/\\n/g, '\n');
    }
  }

  private readJsonArrayStringsFromText(text: string, key: string) {
    const pattern = new RegExp(`"${key}"\\s*:\\s*\\[([\\s\\S]*?)(?:\\]|$)`, 'u');
    const body = text.match(pattern)?.[1];
    if (!body) return [];
    const values: string[] = [];
    const itemPattern = /"((?:\\.|[^"\\])*)"/gu;
    let match: RegExpExecArray | null;

    while ((match = itemPattern.exec(body)) && values.length < 8) {
      try {
        values.push(JSON.parse(`"${match[1]}"`) as string);
      } catch {
        values.push(match[1].replace(/\\"/g, '"').replace(/\\n/g, '\n'));
      }
    }

    return values;
  }

  private normalizeProviderCode(value: string | undefined) {
    const normalized = value?.trim();
    return normalized || undefined;
  }

  private normalizeMinQualityScore(value: unknown, fallback: number) {
    const numberValue = Number(value ?? fallback);

    if (!Number.isFinite(numberValue)) return fallback;

    return Math.max(70, Math.min(100, Math.round(numberValue)));
  }

  private throwInvalidProviderJson(stage: string): never {
    throw new BadRequestException(`选定文本模型没有返回可用的${stage} JSON`);
  }

  private errorMessage(error: unknown) {
    return error instanceof Error ? error.message : String(error);
  }

  private parseId(id: string, message: string) {
    try {
      return BigInt(id);
    } catch {
      throw new BadRequestException(message);
    }
  }

  private hashJson(value: Prisma.InputJsonValue | Prisma.JsonValue | null) {
    return createHash('sha256').update(this.stableStringify(value)).digest('hex');
  }

  private stableStringify(value: Prisma.InputJsonValue | Prisma.JsonValue | null): string {
    if (value === null || typeof value !== 'object') {
      return JSON.stringify(value);
    }
    if (Array.isArray(value)) {
      return `[${value.map((item) => this.stableStringify(item as Prisma.JsonValue)).join(',')}]`;
    }

    const entries = Object.entries(value)
      .sort(([left], [right]) => left.localeCompare(right))
      .map(([key, child]) => `${JSON.stringify(key)}:${this.stableStringify(child as Prisma.JsonValue)}`);

    return `{${entries.join(',')}}`;
  }
}