math_cms/app/Services/DiagnosticChapterService.php

<?php

namespace App\Services;

use Illuminate\Support\Facades\Log;
use App\Models\KnowledgePoint;
use App\Models\StudentKnowledgeMastery;
use App\Models\TextbookCatalog;
use App\Models\TextbookChapterKnowledgeRelation;

class DiagnosticChapterService
{
    public function getTextbookKnowledgePointsInOrder(int $textbookId): array
    {
        $chapters = TextbookCatalog::query()
            ->where('textbook_id', $textbookId)
            ->where('node_type', 'chapter')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->get();

        if ($chapters->isEmpty()) {
            Log::warning('DiagnosticChapterService: 未找到章节节点', [
                'textbook_id' => $textbookId,
            ]);
            return [];
        }

        $orderedCodes = [];
        $seen = [];

        foreach ($chapters as $chapter) {
            $sectionIds = TextbookCatalog::query()
                ->where('parent_id', $chapter->id)
                ->where('node_type', 'section')
                ->orderBy('sort_order')
                ->orderBy('display_no')
                ->orderBy('id')
                ->pluck('id')
                ->toArray();

            if (empty($sectionIds)) {
                continue;
            }

            $kpCodes = TextbookChapterKnowledgeRelation::query()
                ->whereIn('catalog_chapter_id', $sectionIds)
                ->where(function ($q) {
                    $q->where('is_deleted', 0)->orWhereNull('is_deleted');
                })
                ->pluck('kp_code')
                ->filter()
                ->unique()
                ->values()
                ->toArray();

            $kpCodes = $this->expandWithChildKnowledgePoints($kpCodes);

            foreach ($kpCodes as $kpCode) {
                if (isset($seen[$kpCode])) {
                    continue;
                }
                $seen[$kpCode] = true;
                $orderedCodes[] = $kpCode;
            }
        }

        Log::info('DiagnosticChapterService: 获取教材知识点顺序列表', [
            'textbook_id' => $textbookId,
            'kp_count' => count($orderedCodes),
        ]);

        return $orderedCodes;
    }

    public function getInitialChapterKnowledgePoints(int $textbookId): array
    {
        $chapter = TextbookCatalog::query()
            ->where('textbook_id', $textbookId)
            ->where('node_type', 'chapter')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->first();

        if (!$chapter) {
            Log::warning('DiagnosticChapterService: 未找到章节节点', [
                'textbook_id' => $textbookId,
            ]);
            return [];
        }

        $sectionIds = TextbookCatalog::query()
            ->where('parent_id', $chapter->id)
            ->where('node_type', 'section')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->pluck('id')
            ->toArray();

        if (empty($sectionIds)) {
            Log::warning('DiagnosticChapterService: 章节下未找到section节点', [
                'textbook_id' => $textbookId,
                'chapter_id' => $chapter->id,
            ]);
            return [];
        }

        $kpCodes = TextbookChapterKnowledgeRelation::query()
            ->whereIn('catalog_chapter_id', $sectionIds)
            ->where(function ($q) {
                $q->where('is_deleted', 0)->orWhereNull('is_deleted');
            })
            ->pluck('kp_code')
            ->filter()
            ->unique()
            ->values()
            ->toArray();

        $kpCodes = $this->expandWithChildKnowledgePoints($kpCodes);

        Log::info('DiagnosticChapterService: 获取首章知识点', [
            'textbook_id' => $textbookId,
            'chapter_id' => $chapter->id,
            'section_count' => count($sectionIds),
            'kp_count' => count($kpCodes),
        ]);

        return [
            'chapter_id' => $chapter->id,
            'section_ids' => $sectionIds,
            'kp_codes' => $kpCodes,
        ];
    }

    public function getFirstUnmasteredChapterKnowledgePoints(int $textbookId, int $studentId, float $threshold = 0.9): array
    {
        $chapters = TextbookCatalog::query()
            ->where('textbook_id', $textbookId)
            ->where('node_type', 'chapter')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->get();

        if ($chapters->isEmpty()) {
            Log::warning('DiagnosticChapterService: 未找到章节节点', [
                'textbook_id' => $textbookId,
            ]);
            return [];
        }

        foreach ($chapters as $chapter) {
            $sectionIds = TextbookCatalog::query()
                ->where('parent_id', $chapter->id)
                ->where('node_type', 'section')
                ->orderBy('sort_order')
                ->orderBy('display_no')
                ->orderBy('id')
                ->pluck('id')
                ->toArray();

            if (empty($sectionIds)) {
                continue;
            }

            $kpCodes = TextbookChapterKnowledgeRelation::query()
                ->whereIn('catalog_chapter_id', $sectionIds)
                ->where(function ($q) {
                    $q->where('is_deleted', 0)->orWhereNull('is_deleted');
                })
                ->pluck('kp_code')
                ->filter()
                ->unique()
                ->values()
                ->toArray();

            $kpCodes = $this->expandWithChildKnowledgePoints($kpCodes);

            if (empty($kpCodes)) {
                continue;
            }

            $allMastered = StudentKnowledgeMastery::allAtLeast($studentId, $kpCodes, $threshold);

            Log::info('DiagnosticChapterService: 章节掌握度评估', [
                'student_id' => $studentId,
                'textbook_id' => $textbookId,
                'chapter_id' => $chapter->id,
                'section_count' => count($sectionIds),
                'kp_count' => count($kpCodes),
                'all_mastered' => $allMastered,
                'threshold' => $threshold,
            ]);

            if (!$allMastered) {
                return [
                    'chapter_id' => $chapter->id,
                    'section_ids' => $sectionIds,
                    'kp_codes' => $kpCodes,
                    'all_mastered' => $allMastered,
                ];
            }
        }

        Log::info('DiagnosticChapterService: 所有章节均达到掌握度阈值', [
            'student_id' => $studentId,
            'textbook_id' => $textbookId,
            'threshold' => $threshold,
        ]);

        return [];
    }

    private function expandWithChildKnowledgePoints(array $kpCodes): array
    {
        if (empty($kpCodes)) {
            return [];
        }

        $baseCodes = collect($kpCodes)->filter()->values()->all();
        $children = KnowledgePoint::query()
            ->whereIn('parent_kp_code', $baseCodes)
            ->orderBy('kp_code')
            ->get(['parent_kp_code', 'kp_code']);

        $childrenMap = [];
        foreach ($children as $child) {
            $childrenMap[$child->parent_kp_code][] = $child->kp_code;
        }

        $ordered = [];
        $seen = [];

        foreach ($baseCodes as $kpCode) {
            if (!isset($seen[$kpCode])) {
                $seen[$kpCode] = true;
                $ordered[] = $kpCode;
            }

            foreach ($childrenMap[$kpCode] ?? [] as $childCode) {
                if (isset($seen[$childCode])) {
                    continue;
                }
                $seen[$childCode] = true;
                $ordered[] = $childCode;
            }
        }

        return $ordered;
    }

    // ========== 以下是新增的方法（不扩展子知识点）==========

    /**
     * 获取章节的知识点（不扩展子知识点）
     * 直接返回 section 绑定的知识点
     */
    public function getChapterKnowledgePointsSimple(int $chapterId): array
    {
        $sectionIds = TextbookCatalog::query()
            ->where('parent_id', $chapterId)
            ->where('node_type', 'section')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->pluck('id')
            ->toArray();

        if (empty($sectionIds)) {
            return [
                'section_ids' => [],
                'kp_codes' => [],
            ];
        }

        $kpCodes = TextbookChapterKnowledgeRelation::query()
            ->whereIn('catalog_chapter_id', $sectionIds)
            ->where(function ($q) {
                $q->where('is_deleted', 0)->orWhereNull('is_deleted');
            })
            ->pluck('kp_code')
            ->filter()
            ->unique()
            ->values()
            ->toArray();

        // 不扩展子知识点，直接返回
        return [
            'section_ids' => $sectionIds,
            'kp_codes' => $kpCodes,
        ];
    }

    /**
     * 判断章节是否已经摸底过
     */
    public function hasChapterDiagnostic(int $studentId, int $chapterId): bool
    {
        return \App\Models\Paper::query()
            ->where('student_id', $studentId)
            ->where('paper_type', 0) // 摸底类型
            ->where('diagnostic_chapter_id', $chapterId)
            ->exists();
    }

    /**
     * 获取章节摸底目标章节
     * - 传入 targetChapterIds: 先在指定章节内按顺序找第一个未摸底章节；
     *   若指定章节都已摸底，则在该章节所属教材内继续按顺序找未摸底章节。
     * - 未传 targetChapterIds: 保持原逻辑，找教材内第一个未摸底章节。
     */
    public function getFirstUndiagnosedChapter(int $textbookId, int $studentId, ?array $targetChapterIds = null): ?array
    {
        $targetChapterIds = is_array($targetChapterIds)
            ? array_values(array_unique(array_filter(array_map('intval', $targetChapterIds), fn ($id) => $id > 0)))
            : [];

        // 指定章节摸底流程：先在传入列表找未摸底章节，若都摸底则扩展到同教材继续找。
        if (!empty($targetChapterIds)) {
            // 兜底：允许传入 section/subsection，自动向上映射到 chapter
            $targetChapterIds = $this->normalizeToChapterIds($targetChapterIds);
            if (empty($targetChapterIds)) {
                Log::warning('DiagnosticChapterService: 指定章节参数无可解析chapter，终止指定章节摸底', [
                    'textbook_id' => $textbookId,
                    'student_id' => $studentId,
                ]);

                return null;
            }

            // 保持传入顺序遍历，不使用教材排序字段重排
            $chapterMap = TextbookCatalog::query()
                ->whereIn('id', $targetChapterIds)
                ->where('node_type', 'chapter')
                ->get(['id', 'textbook_id', 'title', 'parent_id', 'node_type', 'sort_order', 'display_no'])
                ->keyBy('id');

            $orderedChapters = [];
            foreach ($targetChapterIds as $chapterId) {
                $chapter = $chapterMap->get($chapterId);
                if (!$chapter) {
                    continue;
                }
                $orderedChapters[] = $chapter;

                // 指定列表优先找“未摸底”章节
                if ($this->hasChapterDiagnostic($studentId, (int) $chapter->id)) {
                    continue;
                }

                $chapterData = $this->getChapterKnowledgePointsSimple($chapter->id);
                $kpCodesWithQuestions = $this->filterKpCodesWithQuestions($chapterData['kp_codes']);

                if (empty($kpCodesWithQuestions)) {
                    continue;
                }

                Log::info('DiagnosticChapterService: 指定章节摸底命中未摸底章节', [
                    'textbook_id' => $chapter->textbook_id,
                    'student_id' => $studentId,
                    'target_chapter_ids' => $targetChapterIds,
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? $chapter->title ?? '',
                    'kp_count' => count($kpCodesWithQuestions),
                ]);

                return [
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? $chapter->title ?? '',
                    'section_ids' => $chapterData['section_ids'],
                    'kp_codes' => $kpCodesWithQuestions,
                ];
            }

            if (empty($orderedChapters)) {
                Log::warning('DiagnosticChapterService: 指定章节未找到有效chapter节点', [
                    'student_id' => $studentId,
                    'target_chapter_ids' => $targetChapterIds,
                ]);
                return null;
            }

            // 指定章节都已摸底：在同教材内继续按顺序找未摸底章节
            $anchorTextbookId = (int) ($orderedChapters[0]->textbook_id ?? $textbookId);
            $chaptersInTextbook = TextbookCatalog::query()
                ->where('textbook_id', $anchorTextbookId)
                ->where('node_type', 'chapter')
                ->orderBy('sort_order')
                ->orderBy('display_no')
                ->orderBy('id')
                ->get();

            foreach ($chaptersInTextbook as $chapter) {
                if ($this->hasChapterDiagnostic($studentId, (int) $chapter->id)) {
                    continue;
                }

                $chapterData = $this->getChapterKnowledgePointsSimple($chapter->id);
                $kpCodesWithQuestions = $this->filterKpCodesWithQuestions($chapterData['kp_codes']);
                if (empty($kpCodesWithQuestions)) {
                    continue;
                }

                Log::info('DiagnosticChapterService: 指定章节已摸底完，切换同教材后续未摸底章节', [
                    'anchor_textbook_id' => $anchorTextbookId,
                    'student_id' => $studentId,
                    'target_chapter_ids' => $targetChapterIds,
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? $chapter->title ?? '',
                    'kp_count' => count($kpCodesWithQuestions),
                ]);

                return [
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? $chapter->title ?? '',
                    'section_ids' => $chapterData['section_ids'],
                    'kp_codes' => $kpCodesWithQuestions,
                ];
            }

            Log::warning('DiagnosticChapterService: 指定章节及同教材章节均无可用未摸底章节', [
                'textbook_id' => $anchorTextbookId,
                'student_id' => $studentId,
                'target_chapter_ids' => $targetChapterIds,
            ]);

            return null;
        }

        $chapters = TextbookCatalog::query()
            ->where('textbook_id', $textbookId)
            ->where('node_type', 'chapter')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->get();

        if ($chapters->isEmpty()) {
            return null;
        }

        foreach ($chapters as $chapter) {
            // 检查是否已摸底
            if (!$this->hasChapterDiagnostic($studentId, $chapter->id)) {
                $chapterData = $this->getChapterKnowledgePointsSimple($chapter->id);

                // 过滤掉没有题目的知识点
                $kpCodesWithQuestions = $this->filterKpCodesWithQuestions($chapterData['kp_codes']);

                if (empty($kpCodesWithQuestions)) {
                    // 这个章节没有题目，跳过
                    continue;
                }

                Log::info('DiagnosticChapterService: 找到第一个未摸底的章节', [
                    'textbook_id' => $textbookId,
                    'student_id' => $studentId,
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? '',
                    'kp_count' => count($kpCodesWithQuestions),
                ]);

                return [
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? '',
                    'section_ids' => $chapterData['section_ids'],
                    'kp_codes' => $kpCodesWithQuestions,
                ];
            }
        }

        // 所有章节都已摸底，返回第一章（重新开始）
        $firstChapter = $chapters->first();
        $chapterData = $this->getChapterKnowledgePointsSimple($firstChapter->id);
        $kpCodesWithQuestions = $this->filterKpCodesWithQuestions($chapterData['kp_codes']);

        Log::info('DiagnosticChapterService: 所有章节都已摸底，返回第一章', [
            'textbook_id' => $textbookId,
            'student_id' => $studentId,
            'chapter_id' => $firstChapter->id,
        ]);

        return [
            'chapter_id' => $firstChapter->id,
            'chapter_name' => $firstChapter->name ?? '',
            'section_ids' => $chapterData['section_ids'],
            'kp_codes' => $kpCodesWithQuestions,
            'is_restart' => true, // 标记是重新开始
        ];
    }

    /**
     * 将传入节点ID（chapter/section/subsection）统一映射为所属 chapter ID 列表。
     * 保持传入顺序去重，忽略不属于当前教材的节点。
     *
     * @param array<int> $nodeIds
     * @return array<int>
     */
    private function normalizeToChapterIds(array $nodeIds): array
    {
        if (empty($nodeIds)) {
            return [];
        }

        $chapterIds = [];
        $seen = [];

        foreach ($nodeIds as $nodeId) {
            $currentId = (int) $nodeId;
            if ($currentId <= 0) {
                continue;
            }

            $guard = 0;
            while ($currentId > 0 && $guard++ < 10) {
                $node = TextbookCatalog::query()
                    ->where('id', $currentId)
                    ->first(['id', 'parent_id', 'node_type']);

                if (!$node) {
                    break;
                }

                if ($node->node_type === 'chapter') {
                    if (!isset($seen[$node->id])) {
                        $seen[$node->id] = true;
                        $chapterIds[] = (int) $node->id;
                    }
                    break;
                }

                $currentId = (int) ($node->parent_id ?? 0);
            }
        }

        if (count($chapterIds) !== count($nodeIds)) {
            Log::info('DiagnosticChapterService: 章节参数已自动映射到chapter节点', [
                'input_ids' => $nodeIds,
                'resolved_chapter_ids' => $chapterIds,
            ]);
        }

        return $chapterIds;
    }

    /**
     * 获取当前应该学习的章节（第一个有未达标知识点的章节）
     * 用于智能组卷流程
     */
    public function getCurrentLearningChapter(int $textbookId, int $studentId, float $threshold = 0.9): ?array
    {
        $chapters = TextbookCatalog::query()
            ->where('textbook_id', $textbookId)
            ->where('node_type', 'chapter')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->get();

        if ($chapters->isEmpty()) {
            return null;
        }

        foreach ($chapters as $chapter) {
            $chapterData = $this->getChapterKnowledgePointsSimple($chapter->id);
            $kpCodes = $chapterData['kp_codes'];

            if (empty($kpCodes)) {
                continue;
            }

            // 使用新方法判断是否达标（跳过无题知识点）
            $allMastered = StudentKnowledgeMastery::allAtLeastSkipNoQuestions($studentId, $kpCodes, $threshold);

            if (!$allMastered) {
                // 检查是否已摸底
                $hasDiagnostic = $this->hasChapterDiagnostic($studentId, $chapter->id);

                Log::info('DiagnosticChapterService: 找到当前学习章节', [
                    'textbook_id' => $textbookId,
                    'student_id' => $studentId,
                    'student_id_type' => gettype($studentId),
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? '',
                    'has_diagnostic' => $hasDiagnostic,
                    'kp_codes' => $kpCodes, // 显示实际的知识点列表
                    'kp_count' => count($kpCodes),
                ]);

                return [
                    'chapter_id' => $chapter->id,
                    'chapter_name' => $chapter->name ?? '',
                    'section_ids' => $chapterData['section_ids'],
                    'kp_codes' => $kpCodes,
                    'has_diagnostic' => $hasDiagnostic,
                ];
            }
        }

        // 所有章节都达标
        Log::info('DiagnosticChapterService: 所有章节都达标', [
            'textbook_id' => $textbookId,
            'student_id' => $studentId,
        ]);

        return null;
    }

    /**
     * 获取下一个章节
     */
    public function getNextChapter(int $textbookId, int $currentChapterId): ?array
    {
        $chapters = TextbookCatalog::query()
            ->where('textbook_id', $textbookId)
            ->where('node_type', 'chapter')
            ->orderBy('sort_order')
            ->orderBy('display_no')
            ->orderBy('id')
            ->get();

        $foundCurrent = false;
        foreach ($chapters as $chapter) {
            if ($foundCurrent) {
                $chapterData = $this->getChapterKnowledgePointsSimple($chapter->id);
                $kpCodesWithQuestions = $this->filterKpCodesWithQuestions($chapterData['kp_codes']);

                if (!empty($kpCodesWithQuestions)) {
                    return [
                        'chapter_id' => $chapter->id,
                        'chapter_name' => $chapter->name ?? '',
                        'section_ids' => $chapterData['section_ids'],
                        'kp_codes' => $kpCodesWithQuestions,
                    ];
                }
            }

            if ($chapter->id === $currentChapterId) {
                $foundCurrent = true;
            }
        }

        return null; // 没有下一章
    }

    /**
     * 过滤出有题目的知识点
     */
    public function filterKpCodesWithQuestions(array $kpCodes): array
    {
        if (empty($kpCodes)) {
            return [];
        }

        $kpCodesWithQuestions = \App\Models\Question::query()
            ->where('audit_status', 0) // 只获取审核通过的题目
            ->whereIn('kp_code', $kpCodes)
            ->distinct()
            ->pluck('kp_code')
            ->toArray();

        // 保持原有顺序
        return array_values(array_intersect($kpCodes, $kpCodesWithQuestions));
    }

    /**
     * 按顺序获取未达标的知识点（用于智能组卷）
     *
     * @param int $studentId 学生ID
     * @param array $kpCodes 知识点列表（按顺序）
     * @param float $threshold 达标阈值
     * @param int $maxCount 最多返回几个知识点
     * @param int $minQuestions 每个知识点最少需要的题目数
     * @return array 未达标的知识点列表
     */
    public function getUnmasteredKpCodesInOrder(
        int $studentId,
        array $kpCodes,
        float $threshold = 0.9,
        int $maxCount = 2,
        int $minQuestions = 20
    ): array {
        if (empty($kpCodes)) {
            return [];
        }

        // 获取掌握度（使用 DB::table 避免 Eloquent accessor 把数字转成文字标签）
        // 【新增】同时获取 direct_mastery_level 和 mastery_level，判断时优先使用 direct_mastery_level
        $masteryRecords = \Illuminate\Support\Facades\DB::table('student_knowledge_mastery')
            ->where('student_id', $studentId)
            ->whereIn('kp_code', $kpCodes)
            ->get(['kp_code', 'mastery_level', 'direct_mastery_level'])
            ->keyBy('kp_code');

        // 构建有效掌握度映射：取 direct_mastery_level 和 mastery_level 的最大值
        // 避免"学了之后反而从达标变成未达标"的问题
        $levels = [];
        foreach ($masteryRecords as $kpCode => $record) {
            $direct = $record->direct_mastery_level;
            $mastery = (float) $record->mastery_level;

            if ($direct !== null) {
                // 取两者最大值：直接学习达标或聚合值达标，都算达标
                $levels[$kpCode] = max((float) $direct, $mastery);
            } else {
                $levels[$kpCode] = $mastery;
            }
        }

        // 【调试】记录查询到的掌握度
        Log::info('DiagnosticChapterService: 查询掌握度结果', [
            'student_id' => $studentId,
            'student_id_type' => gettype($studentId),
            'input_kp_codes' => $kpCodes,
            'found_levels' => $levels,
            'raw_records' => $masteryRecords->toArray(),
        ]);

        // 获取每个知识点的题目数量（只统计审核通过的题目）
        $questionCounts = \App\Models\Question::query()
            ->where('audit_status', 0) // 只获取审核通过的题目
            ->whereIn('kp_code', $kpCodes)
            ->selectRaw('kp_code, COUNT(*) as count')
            ->groupBy('kp_code')
            ->pluck('count', 'kp_code')
            ->toArray();

        $result = [];
        $totalQuestions = 0;

        foreach ($kpCodes as $kpCode) {
            // 跳过没有题目的知识点
            $count = $questionCounts[$kpCode] ?? 0;
            if ($count === 0) {
                continue;
            }

            // 检查是否达标
            $level = isset($levels[$kpCode]) ? (float) $levels[$kpCode] : 0.0;
            $isMastered = $level >= $threshold;
            Log::info("DiagnosticChapterService: 检查知识点", [
                'kp_code' => $kpCode,
                'level' => $level,
                'threshold' => $threshold,
                'is_mastered' => $isMastered,
                'level_found_in_db' => isset($levels[$kpCode]),
            ]);
            if ($level >= $threshold) {
                continue;
            }

            // 添加到结果
            $result[] = $kpCode;
            $totalQuestions += $count;

            // 检查是否达到最大数量
            if (count($result) >= $maxCount) {
                break;
            }

            // 检查题目数量是否足够
            if ($totalQuestions >= $minQuestions) {
                break;
            }
        }

        Log::info('DiagnosticChapterService: 获取未达标知识点', [
            'student_id' => $studentId,
            'input_kp_codes' => $kpCodes,
            'result_kp_codes' => $result,
            'levels_found' => $levels,
            'total_questions' => $totalQuestions,
            'threshold' => $threshold,
        ]);

        return $result;
    }
}