<?php

namespace App\Services\Analytics;

use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Schema;

/**
 * 题目动态难度校准服务（分层基线残差 + 贝叶斯收缩 + 时间衰减）
 *
 * 目标：
 * 1) 判卷后实时吸收对错结果；
 * 2) 产出可直接用于组卷的校准难度（0~1）；
 * 3) 通过先验约束与限幅，避免短期噪声导致难度抖动。
 */
class QuestionDifficultyCalibrationService
{
    private const TABLE = 'question_difficulty_calibrations';
    private const ALGO = 'stratified_residual_eb_v2';
    private const HALF_LIFE_DAYS = 45;
    private const BETA_PRIOR_A = 2.0;
    private const BETA_PRIOR_B = 2.0;
    private const SHRINKAGE_M0_MIN = 8.0;
    private const SHRINKAGE_M0_MAX = 24.0;
    private const RESIDUAL_GAIN_MIN = 1.0;
    private const RESIDUAL_GAIN_MAX = 2.2;
    private const RESIDUAL_SCALE_DENOM_MIN = 0.08;
    private const RESIDUAL_SCALE_DENOM_MAX = 0.20;
    private const RECENT_EVENTS_LIMIT = 30;
    private const MIN_DIFF = 0.01;
    private const MAX_DIFF = 0.99;

    private ?bool $tableReady = null;
    /** @var array<string, array{by_cat:array<string,float>,fallback:float,all_by_cat:array<string,float},> */
    private array $baselineCache = [];

    /**
     * 按一张试卷内已判分题目触发重估。
     *
     * @return int 参与更新的题目数
     */
    public function recalibrateByPaperId(string $paperId): int
    {
        $paperId = trim($paperId);
        if ($paperId === '' || ! $this->isReady()) {
            return 0;
        }

        $questionIds = DB::table('paper_questions')
            ->where('paper_id', $paperId)
            ->whereNotNull('question_bank_id')
            ->whereNotNull('is_correct')
            ->pluck('question_bank_id')
            ->map(fn ($id) => (int) $id)
            ->filter(fn ($id) => $id > 0)
            ->unique()
            ->values()
            ->all();

        return $this->recalibrateQuestionIds($questionIds);
    }

    /**
     * 在线逐题更新（无批量重算）：仅更新本次判卷触达的题目。
     *
     * @param  list<array<string,mixed>>  $questions
     */
    public function updateOnlineFromPaper(string $paperId, array $questions): int
    {
        $paperId = trim($paperId);
        if ($paperId === '' || $questions === [] || ! $this->isReady()) {
            return 0;
        }

        $paper = DB::table('papers')->where('paper_id', $paperId)->first(['difficulty_category']);
        $paperDifficultyCategory = (string) ($paper->difficulty_category ?? 'unknown');

        $qidToOutcome = [];
        foreach ($questions as $question) {
            $qid = (int) ($question['question_id'] ?? $question['question_bank_id'] ?? 0);
            if ($qid <= 0) {
                continue;
            }

            $isCorrectArray = $question['is_correct'] ?? [];
            if (! is_array($isCorrectArray)) {
                $isCorrectArray = [$isCorrectArray ? 1 : 0];
            }
            $totalSteps = count($isCorrectArray);
            if ($totalSteps <= 0) {
                continue;
            }
            $correctSteps = array_sum(array_map(fn ($v) => (int) $v === 1 ? 1 : 0, $isCorrectArray));
            $correctRatio = $correctSteps / max(1, $totalSteps);
            $outcomeError = 1.0 - $correctRatio;
            $qidToOutcome[$qid] = [
                'outcome_error' => $this->clamp((float) $outcomeError, 0.0, 1.0),
                'is_fully_correct' => $correctSteps === $totalSteps ? 1 : 0,
            ];
        }
        if ($qidToOutcome === []) {
            return 0;
        }

        $questionIds = array_keys($qidToOutcome);
        $questionTypeRows = DB::table('paper_questions')
            ->where('paper_id', $paperId)
            ->where(function ($q) use ($questionIds) {
                $q->whereIn('question_bank_id', $questionIds)
                    ->orWhereIn('question_id', $questionIds);
            })
            ->select(['question_bank_id', 'question_id', 'question_type'])
            ->get();
        $questionTypeByQid = [];
        $canonicalQidByInput = [];
        foreach ($questionTypeRows as $row) {
            $qt = trim((string) ($row->question_type ?? '')) !== '' ? (string) $row->question_type : 'unknown';
            $bankId = (int) ($row->question_bank_id ?? 0);
            $questionId = (int) ($row->question_id ?? 0);
            if ($bankId > 0 && ! isset($questionTypeByQid[$bankId])) {
                $questionTypeByQid[$bankId] = $qt;
                $canonicalQidByInput[$bankId] = $bankId;
            }
            if ($questionId > 0 && ! isset($questionTypeByQid[$questionId])) {
                $questionTypeByQid[$questionId] = $qt;
            }
            if ($questionId > 0 && $bankId > 0) {
                $canonicalQidByInput[$questionId] = $bankId;
            }
        }
        $baseDifficultyByQid = DB::table('questions')
            ->whereIn('id', $questionIds)
            ->pluck('difficulty', 'id')
            ->all();
        $existingLookupIds = array_values(array_unique(array_merge(
            $questionIds,
            array_values($canonicalQidByInput)
        )));
        $existingByQid = DB::table(self::TABLE)
            ->whereIn('question_bank_id', $existingLookupIds)
            ->get()
            ->keyBy('question_bank_id');

        $types = array_values(array_unique(array_values($questionTypeByQid)));
        $baselines = $this->buildGlobalBaselines($types);
        $healthScaleByType = [];

        $now = now();
        $upserts = [];
        foreach ($qidToOutcome as $qid => $outcome) {
            $outcomeError = (float) ($outcome['outcome_error'] ?? 1.0);
            $isFullyCorrect = (int) ($outcome['is_fully_correct'] ?? 0) === 1 ? 1 : 0;
            $canonicalQid = (int) ($canonicalQidByInput[$qid] ?? $qid);
            $existing = $existingByQid->get((string) $canonicalQid);
            if ($existing === null) {
                $existing = $existingByQid->get($canonicalQid);
            }

            $originalDifficulty = $existing !== null
                ? (float) ($existing->original_difficulty ?? 0.5)
                : ($this->normalizeDifficultyValue($baseDifficultyByQid[$qid] ?? null) ?? 0.5);
            $originalDifficulty = $this->clamp($originalDifficulty, self::MIN_DIFF, self::MAX_DIFF);

            $prevDifficulty = $existing !== null
                ? (float) ($existing->calibrated_difficulty ?? $originalDifficulty)
                : $originalDifficulty;
            $prevDifficulty = $this->clamp($prevDifficulty, self::MIN_DIFF, self::MAX_DIFF);

            $prevWeightedAttempts = $existing !== null ? (float) ($existing->weighted_attempts ?? 0.0) : 0.0;
            $prevWeightedWrong = $existing !== null ? (float) ($existing->weighted_wrong ?? 0.0) : 0.0;
            $lastAtRaw = $existing !== null ? ($existing->last_graded_at ?? null) : null;
            $existingMeta = [];
            if ($existing !== null && ! empty($existing->algorithm_meta)) {
                $existingMeta = json_decode((string) $existing->algorithm_meta, true) ?: [];
            }

            $questionType = $questionTypeByQid[$canonicalQid] ?? ($questionTypeByQid[$qid] ?? 'unknown');
            $baselineErr = $this->resolveBaselineErrorRate($questionType, $paperDifficultyCategory, $baselines);
            if (! isset($healthScaleByType[$questionType])) {
                $healthScaleByType[$questionType] = $this->getHealthScaleForType($questionType);
            }
            $healthScale = (float) $healthScaleByType[$questionType];

            $estimate = $this->estimateOnlineBySingleOutcome(
                $originalDifficulty,
                $prevDifficulty,
                $prevWeightedAttempts,
                $prevWeightedWrong,
                $outcomeError,
                $baselineErr,
                $lastAtRaw,
                $healthScale
            );

            $event = $this->buildUpdateEvent(
                $outcomeError,
                $prevDifficulty,
                (float) $estimate['calibrated_difficulty'],
                (float) ($estimate['meta']['expected_error_rate'] ?? $baselineErr),
                (float) ($estimate['meta']['observed_error_rate'] ?? ($estimate['weighted_error_rate'] ?? 0.5)),
                (float) ($estimate['meta']['residual'] ?? 0.0),
                $now
            );

            $meta = array_merge($existingMeta, $estimate['meta'], [
                'mode' => 'online_single_outcome',
                'paper_id' => $paperId,
                'paper_difficulty_category' => $paperDifficultyCategory,
                'question_type' => $questionType,
                'baseline_error_rate' => round($baselineErr, 4),
                'health_scale' => round($healthScale, 4),
            ]);
            $meta = $this->appendRecentEvent($meta, $event);

            $prevAttempts = $existing !== null ? (int) ($existing->attempts ?? 0) : 0;
            $prevCorrectCount = $existing !== null ? (int) ($existing->correct_count ?? 0) : 0;
            $prevWrongCount = $existing !== null ? (int) ($existing->wrong_count ?? 0) : 0;
            $attempts = $prevAttempts + 1;
            $correctCount = $prevCorrectCount + ($isFullyCorrect === 1 ? 1 : 0);
            // wrong_count 与历史 is_correct 口径对齐：仅“全错”计入 wrong_count。
            $wrongCount = $prevWrongCount + ($outcomeError >= 0.9999 ? 1 : 0);

            $upserts[] = [
                'question_bank_id' => $canonicalQid,
                'original_difficulty' => round($originalDifficulty, 4),
                'calibrated_difficulty' => round($estimate['calibrated_difficulty'], 4),
                'difficulty_delta' => round($estimate['calibrated_difficulty'] - $originalDifficulty, 4),
                'attempts' => $attempts,
                'correct_count' => $correctCount,
                'wrong_count' => $wrongCount,
                'weighted_attempts' => round($estimate['weighted_attempts'], 4),
                'weighted_wrong' => round($estimate['weighted_wrong'], 4),
                'weighted_error_rate' => round($estimate['weighted_error_rate'], 4),
                'last_graded_at' => $now->toDateTimeString(),
                'algorithm' => self::ALGO.'_online',
                'algorithm_meta' => json_encode($meta, JSON_UNESCAPED_UNICODE),
                'updated_at' => $now,
                'created_at' => $now,
            ];
        }

        if ($upserts === []) {
            return 0;
        }

        DB::table(self::TABLE)->upsert(
            $upserts,
            ['question_bank_id'],
            [
                'original_difficulty',
                'calibrated_difficulty',
                'difficulty_delta',
                'attempts',
                'correct_count',
                'wrong_count',
                'weighted_attempts',
                'weighted_wrong',
                'weighted_error_rate',
                'last_graded_at',
                'algorithm',
                'algorithm_meta',
                'updated_at',
            ]
        );

        Log::info('QuestionDifficultyCalibrationService: 在线逐题更新完成', [
            'paper_id' => $paperId,
            'updated_question_count' => count($upserts),
        ]);

        return count($upserts);
    }

    /**
     * @param  array<int, int|string>  $questionIds
     * @return int 参与更新的题目数
     */
    public function recalibrateQuestionIds(array $questionIds): int
    {
        if (! $this->isReady()) {
            return 0;
        }

        $questionIds = collect($questionIds)
            ->map(fn ($id) => (int) $id)
            ->filter(fn ($id) => $id > 0)
            ->unique()
            ->values()
            ->all();
        if ($questionIds === []) {
            return 0;
        }

        $baseDifficultyById = DB::table('questions')
            ->whereIn('id', $questionIds)
            ->pluck('difficulty', 'id')
            ->all();

        $rows = DB::table('paper_questions as pq')
            ->join('papers as p', 'p.paper_id', '=', 'pq.paper_id')
            ->whereIn('pq.question_bank_id', $questionIds)
            ->whereNotNull('pq.is_correct')
            ->select([
                'pq.question_bank_id',
                'pq.question_type',
                'pq.is_correct',
                'pq.graded_at',
                'pq.updated_at',
                'pq.created_at',
                'p.difficulty_category',
            ])
            ->orderBy('pq.question_bank_id')
            ->get();

        $grouped = [];
        foreach ($rows as $row) {
            $qid = (int) ($row->question_bank_id ?? 0);
            if ($qid <= 0) {
                continue;
            }
            $grouped[$qid] ??= [];
            $grouped[$qid][] = [
                'question_type' => (string) ($row->question_type ?? ''),
                'is_correct' => (int) ($row->is_correct ?? 0) === 1 ? 1 : 0,
                'difficulty_category' => $row->difficulty_category ?? null,
                'graded_at' => $row->graded_at ?? null,
                'updated_at' => $row->updated_at ?? null,
                'created_at' => $row->created_at ?? null,
            ];
        }

        $questionTypeById = [];
        foreach ($grouped as $qid => $attempts) {
            $questionTypeById[$qid] = $this->resolveQuestionType($attempts);
        }
        $baselines = $this->buildGlobalBaselines(array_values($questionTypeById));

        $upserts = [];
        $now = now();
        foreach ($questionIds as $qid) {
            $attempts = $grouped[$qid] ?? [];
            if ($attempts === []) {
                continue;
            }

            $originalDifficulty = $this->normalizeDifficultyValue($baseDifficultyById[$qid] ?? null) ?? 0.5;
            $questionType = $questionTypeById[$qid] ?? 'unknown';
            $estimate = $this->estimateByStratifiedResidual(
                $attempts,
                $originalDifficulty,
                $questionType,
                $baselines
            );

            $upserts[] = [
                'question_bank_id' => $qid,
                'original_difficulty' => round($originalDifficulty, 4),
                'calibrated_difficulty' => round($estimate['calibrated_difficulty'], 4),
                'difficulty_delta' => round($estimate['calibrated_difficulty'] - $originalDifficulty, 4),
                'attempts' => $estimate['attempts'],
                'correct_count' => $estimate['correct_count'],
                'wrong_count' => $estimate['wrong_count'],
                'weighted_attempts' => round($estimate['weighted_attempts'], 4),
                'weighted_wrong' => round($estimate['weighted_wrong'], 4),
                'weighted_error_rate' => $estimate['weighted_error_rate'] === null
                    ? null
                    : round($estimate['weighted_error_rate'], 4),
                'last_graded_at' => $estimate['last_graded_at'],
                'algorithm' => self::ALGO,
                'algorithm_meta' => json_encode($estimate['meta'], JSON_UNESCAPED_UNICODE),
                'updated_at' => $now,
                'created_at' => $now,
            ];
        }

        if ($upserts === []) {
            return 0;
        }

        DB::table(self::TABLE)->upsert(
            $upserts,
            ['question_bank_id'],
            [
                'original_difficulty',
                'calibrated_difficulty',
                'difficulty_delta',
                'attempts',
                'correct_count',
                'wrong_count',
                'weighted_attempts',
                'weighted_wrong',
                'weighted_error_rate',
                'last_graded_at',
                'algorithm',
                'algorithm_meta',
                'updated_at',
            ]
        );

        Log::info('QuestionDifficultyCalibrationService: 题目难度已重估入库', [
            'question_count' => count($upserts),
            'algorithm' => self::ALGO,
        ]);

        return count($upserts);
    }

    private function resolveQuestionType(array $attempts): string
    {
        foreach ($attempts as $attempt) {
            $type = trim((string) ($attempt['question_type'] ?? ''));
            if ($type !== '') {
                return $type;
            }
        }

        return 'unknown';
    }

    /**
     * @param  array<int, string>  $questionTypes
     * @return array<string, mixed>
     */
    private function buildGlobalBaselines(array $questionTypes): array
    {
        $cacheKey = implode('|', $questionTypes);
        if (isset($this->baselineCache[$cacheKey])) {
            return $this->baselineCache[$cacheKey];
        }

        $questionTypes = array_values(array_unique(array_filter(array_map(
            fn ($t) => trim((string) $t),
            $questionTypes
        ))));
        sort($questionTypes);

        $cacheKeyPersistent = 'difficulty_baselines_v1:'.md5(implode('|', $questionTypes));
        $result = Cache::remember($cacheKeyPersistent, now()->addMinutes(10), function () use ($questionTypes) {
            $baseQuery = DB::table('paper_questions as pq')
                ->join('papers as p', 'p.paper_id', '=', 'pq.paper_id')
                ->whereNotNull('pq.is_correct');

            $rows = (clone $baseQuery)
                ->when($questionTypes !== [], function ($q) use ($questionTypes) {
                    $q->whereIn('pq.question_type', $questionTypes);
                })
                ->selectRaw('
                    COALESCE(NULLIF(pq.question_type, ""), "unknown") as question_type,
                    COALESCE(NULLIF(CAST(p.difficulty_category as char), ""), "unknown") as difficulty_category,
                    COUNT(*) as n,
                    SUM(CASE WHEN pq.is_correct = 0 THEN 1 ELSE 0 END) as wrong
                ')
                ->groupBy(DB::raw('COALESCE(NULLIF(pq.question_type, ""), "unknown")'))
                ->groupBy(DB::raw('COALESCE(NULLIF(CAST(p.difficulty_category as char), ""), "unknown")'))
                ->get();

            $allRows = (clone $baseQuery)
                ->selectRaw('
                    COALESCE(NULLIF(CAST(p.difficulty_category as char), ""), "unknown") as difficulty_category,
                    COUNT(*) as n,
                    SUM(CASE WHEN pq.is_correct = 0 THEN 1 ELSE 0 END) as wrong
                ')
                ->groupBy(DB::raw('COALESCE(NULLIF(CAST(p.difficulty_category as char), ""), "unknown")'))
                ->get();

            $result = [
                'type' => [],
                'all' => [
                    'by_cat' => [],
                    'fallback' => 0.5,
                ],
            ];

            foreach ($rows as $row) {
                $type = (string) ($row->question_type ?? 'unknown');
                $cat = (string) ($row->difficulty_category ?? 'unknown');
                $n = (int) ($row->n ?? 0);
                $wrong = (int) ($row->wrong ?? 0);
                $result['type'][$type]['by_cat'][$cat] = $this->smoothedRate($wrong, $n);
                $result['type'][$type]['n_total'] = (int) (($result['type'][$type]['n_total'] ?? 0) + $n);
                $result['type'][$type]['wrong_total'] = (int) (($result['type'][$type]['wrong_total'] ?? 0) + $wrong);
            }

            foreach ($result['type'] as $type => $v) {
                $n = (int) ($v['n_total'] ?? 0);
                $wrong = (int) ($v['wrong_total'] ?? 0);
                $result['type'][$type]['fallback'] = $this->smoothedRate($wrong, $n);
                $result['type'][$type]['by_cat'] = $this->enforceMonotonicCategoryRates(
                    $result['type'][$type]['by_cat'] ?? []
                );
            }

            $allN = 0;
            $allWrong = 0;
            foreach ($allRows as $row) {
                $cat = (string) ($row->difficulty_category ?? 'unknown');
                $n = (int) ($row->n ?? 0);
                $wrong = (int) ($row->wrong ?? 0);
                $result['all']['by_cat'][$cat] = $this->smoothedRate($wrong, $n);
                $allN += $n;
                $allWrong += $wrong;
            }
            $result['all']['by_cat'] = $this->enforceMonotonicCategoryRates($result['all']['by_cat']);
            $result['all']['fallback'] = $this->smoothedRate($allWrong, $allN);

            return $result;
        });

        $this->baselineCache[$cacheKey] = $result;

        return $result;
    }

    private function resolveBaselineErrorRate(string $questionType, string $difficultyCategory, array $baselines): float
    {
        $type = trim($questionType) !== '' ? trim($questionType) : 'unknown';
        $cat = trim($difficultyCategory) !== '' ? trim($difficultyCategory) : 'unknown';

        $typeByCat = $baselines['type'][$type]['by_cat'] ?? [];
        if (array_key_exists($cat, $typeByCat)) {
            return (float) $typeByCat[$cat];
        }
        if (isset($baselines['type'][$type]['fallback'])) {
            return (float) $baselines['type'][$type]['fallback'];
        }
        if (isset($baselines['all']['by_cat'][$cat])) {
            return (float) $baselines['all']['by_cat'][$cat];
        }

        return (float) ($baselines['all']['fallback'] ?? 0.5);
    }

    private function smoothedRate(int $wrong, int $n): float
    {
        return ($wrong + self::BETA_PRIOR_A) / max(1e-6, $n + self::BETA_PRIOR_A + self::BETA_PRIOR_B);
    }

    /**
     * 约束 difficulty_category 的基线错误率单调递增（0<=1<=2<=...），
     * 保留 unknown 等非数字类别原值。
     *
     * @param  array<string,float>  $ratesByCategory
     * @return array<string,float>
     */
    private function enforceMonotonicCategoryRates(array $ratesByCategory): array
    {
        if ($ratesByCategory === []) {
            return $ratesByCategory;
        }

        $numeric = [];
        foreach ($ratesByCategory as $cat => $rate) {
            if (preg_match('/^\\d+$/', (string) $cat) === 1) {
                $numeric[(int) $cat] = (float) $rate;
            }
        }
        if ($numeric === []) {
            return $ratesByCategory;
        }
        ksort($numeric);

        $keys = array_keys($numeric);
        $vals = array_values($numeric);
        $adj = $this->isotonicIncreasing($vals);

        foreach ($keys as $i => $cat) {
            $ratesByCategory[(string) $cat] = $adj[$i];
        }

        return $ratesByCategory;
    }

    /**
     * @param  array<int,float>  $values
     * @return array<int,float>
     */
    private function isotonicIncreasing(array $values): array
    {
        $blocks = [];
        foreach ($values as $v) {
            $blocks[] = ['sum' => (float) $v, 'weight' => 1.0, 'count' => 1];
            while (count($blocks) >= 2) {
                $k = count($blocks);
                $a = $blocks[$k - 2];
                $b = $blocks[$k - 1];
                $avgA = $a['sum'] / $a['weight'];
                $avgB = $b['sum'] / $b['weight'];
                if ($avgA <= $avgB) {
                    break;
                }
                $blocks[$k - 2] = [
                    'sum' => $a['sum'] + $b['sum'],
                    'weight' => $a['weight'] + $b['weight'],
                    'count' => $a['count'] + $b['count'],
                ];
                array_pop($blocks);
            }
        }

        $out = [];
        foreach ($blocks as $b) {
            $avg = (float) ($b['sum'] / max(1e-6, $b['weight']));
            for ($i = 0; $i < (int) $b['count']; $i++) {
                $out[] = $this->clamp($avg, self::MIN_DIFF, self::MAX_DIFF);
            }
        }

        return $out;
    }

    /**
     * 单次判卷结果的在线更新。
     *
     * @return array{weighted_attempts:float,weighted_wrong:float,weighted_error_rate:float,calibrated_difficulty:float,meta:array<string,mixed>}
     */
    private function estimateOnlineBySingleOutcome(
        float $originalDifficulty,
        float $prevDifficulty,
        float $prevWeightedAttempts,
        float $prevWeightedWrong,
        float $outcomeError,
        float $baselineErr,
        mixed $lastGradedAtRaw,
        float $healthScale
    ): array {
        $now = Carbon::now();

        $days = 0.0;
        if ($lastGradedAtRaw !== null && (string) $lastGradedAtRaw !== '') {
            try {
                $lastAt = Carbon::parse((string) $lastGradedAtRaw);
                $days = max(0.0, (float) $lastAt->diffInDays($now));
            } catch (\Throwable) {
                $days = 0.0;
            }
        }
        $decay = pow(0.5, $days / self::HALF_LIFE_DAYS);
        $outcomeError = $this->clamp($outcomeError, 0.0, 1.0);
        $wN = max(0.0, $prevWeightedAttempts) * $decay + 1.0;
        $wWrong = max(0.0, $prevWeightedWrong) * $decay + $outcomeError;
        $obsErr = $wN > 0.0 ? ($wWrong / $wN) : 0.5;
        $priorConfidence = min(1.0, max(0.0, $prevWeightedAttempts / 25.0));
        $expectedErr = (1.0 - $priorConfidence) * $baselineErr + $priorConfidence * $prevDifficulty;
        $residual = $this->clamp($obsErr - $expectedErr, -0.45, 0.45);

        $adaptive = $this->buildAdaptivePolicy($wN, $obsErr, $expectedErr, $residual);
        $residualGain = (float) $adaptive['residual_gain'] * $healthScale;
        $residualScaleDenom = (float) $adaptive['residual_scale_denom'];
        $shrinkageM0 = (float) $adaptive['shrinkage_m0'];
        $confidence = (float) ($adaptive['confidence'] ?? 0.0);

        // 在线模式下不做分段门控，始终可更新，但样本少时步长自动更小。
        $maxStep = 0.30 * (0.35 + 0.65 * $confidence) * $healthScale;
        $residualScale = min(1.0, abs($residual) / max(1e-6, $residualScaleDenom));
        $effectiveStep = $maxStep * $residualScale;

        $targetDifficulty = $this->clamp(
            $prevDifficulty + $residualGain * $residual,
            self::MIN_DIFF,
            self::MAX_DIFF
        );
        $candidateDifficulty = $prevDifficulty + $this->clamp(
            $targetDifficulty - $prevDifficulty,
            -$effectiveStep,
            $effectiveStep
        );
        $candidateDifficulty = $this->clamp($candidateDifficulty, self::MIN_DIFF, self::MAX_DIFF);

        $calibratedDifficulty = ($shrinkageM0 * $prevDifficulty + $wN * $candidateDifficulty) / ($shrinkageM0 + $wN);
        $calibratedDifficulty = $this->clamp($calibratedDifficulty, self::MIN_DIFF, self::MAX_DIFF);

        return [
            'weighted_attempts' => $wN,
            'weighted_wrong' => $wWrong,
            'weighted_error_rate' => $obsErr,
            'calibrated_difficulty' => $calibratedDifficulty,
            'meta' => [
                'decay_days' => round($days, 4),
                'decay_factor' => round($decay, 6),
                'prev_difficulty' => round($prevDifficulty, 4),
                'original_difficulty' => round($originalDifficulty, 4),
                'observed_error_rate' => round($obsErr, 4),
                'expected_error_rate' => round($expectedErr, 4),
                'residual' => round($residual, 4),
                'health_scale_applied' => round($healthScale, 4),
                'max_step' => round($maxStep, 4),
                'effective_step' => round($effectiveStep, 4),
                'target_difficulty' => round($targetDifficulty, 4),
                'candidate_difficulty' => round($candidateDifficulty, 4),
                'adaptive' => $adaptive,
            ],
        ];
    }

    /**
     * @param  array<int, array<string, mixed>>  $attempts
     * @param  array<string, mixed>  $baselines
     * @return array<string, mixed>
     */
    private function estimateByStratifiedResidual(
        array $attempts,
        float $originalDifficulty,
        string $questionType,
        array $baselines
    ): array {
        $now = Carbon::now();
        $originalDifficulty = $this->clamp($originalDifficulty, self::MIN_DIFF, self::MAX_DIFF);

        $weightedAttempts = 0.0;
        $weightedWrong = 0.0;
        $weightedExpectedWrong = 0.0;
        $correctCount = 0;
        $wrongCount = 0;
        $lastAt = null;
        $byCategory = [];

        foreach ($attempts as $attempt) {
            $isCorrect = (int) ($attempt['is_correct'] ?? 0) === 1 ? 1 : 0;
            $incorrect = 1 - $isCorrect;
            if ($isCorrect === 1) {
                $correctCount++;
            } else {
                $wrongCount++;
            }

            $difficultyCategory = (string) ($attempt['difficulty_category'] ?? 'unknown');
            $baselineErr = $this->resolveBaselineErrorRate($questionType, $difficultyCategory, $baselines);

            $answeredAt = $attempt['graded_at'] ?? $attempt['updated_at'] ?? $attempt['created_at'] ?? null;
            $days = 0.0;
            if ($answeredAt !== null && $answeredAt !== '') {
                try {
                    $at = Carbon::parse((string) $answeredAt);
                    $days = max(0.0, (float) $at->diffInDays($now));
                    if ($lastAt === null || $at->gt($lastAt)) {
                        $lastAt = $at;
                    }
                } catch (\Throwable) {
                    $days = 0.0;
                }
            }
            $w = pow(0.5, $days / self::HALF_LIFE_DAYS);

            $weightedAttempts += $w;
            $weightedWrong += $w * $incorrect;
            $weightedExpectedWrong += $w * $baselineErr;

            $key = trim($difficultyCategory) !== '' ? trim($difficultyCategory) : 'unknown';
            $byCategory[$key] ??= [
                'attempts' => 0,
                'wrong' => 0,
                'weighted_attempts' => 0.0,
                'weighted_wrong' => 0.0,
                'baseline_error_rate' => $baselineErr,
            ];
            $byCategory[$key]['attempts']++;
            $byCategory[$key]['wrong'] += $incorrect;
            $byCategory[$key]['weighted_attempts'] += $w;
            $byCategory[$key]['weighted_wrong'] += $w * $incorrect;
        }

        $weightedErrorRate = $weightedAttempts > 0 ? ($weightedWrong / $weightedAttempts) : null;
        $weightedExpectedErrorRate = $weightedAttempts > 0 ? ($weightedExpectedWrong / $weightedAttempts) : null;
        $residual = ($weightedErrorRate !== null && $weightedExpectedErrorRate !== null)
            ? ($weightedErrorRate - $weightedExpectedErrorRate)
            : 0.0;

        $adaptive = $this->buildAdaptivePolicy(
            $weightedAttempts,
            $weightedErrorRate,
            $weightedExpectedErrorRate,
            $residual
        );
        $residualGain = (float) $adaptive['residual_gain'];
        $residualScaleDenom = (float) $adaptive['residual_scale_denom'];
        $shrinkageM0 = (float) $adaptive['shrinkage_m0'];

        if ($weightedAttempts < 8) {
            $stepLimit = 0.0;
        } elseif ($weightedAttempts < 20) {
            $stepLimit = 0.08;
        } elseif ($weightedAttempts < 60) {
            $stepLimit = 0.15;
        } else {
            $stepLimit = 0.25;
        }
        $residualScale = min(1.0, abs($residual) / max(1e-6, $residualScaleDenom));
        $effectiveStep = $stepLimit * $residualScale;

        $targetDifficulty = $this->clamp(
            $originalDifficulty + $residualGain * $residual,
            self::MIN_DIFF,
            self::MAX_DIFF
        );
        $candidateDifficulty = $originalDifficulty + $this->clamp(
            $targetDifficulty - $originalDifficulty,
            -$effectiveStep,
            $effectiveStep
        );
        $candidateDifficulty = $this->clamp($candidateDifficulty, self::MIN_DIFF, self::MAX_DIFF);

        $calibratedDifficulty = ($weightedAttempts < 8)
            ? $originalDifficulty
            : (
                ($shrinkageM0 * $originalDifficulty + $weightedAttempts * $candidateDifficulty)
                / ($shrinkageM0 + $weightedAttempts)
            );
        $calibratedDifficulty = $this->clamp($calibratedDifficulty, self::MIN_DIFF, self::MAX_DIFF);

        foreach ($byCategory as $cat => $stats) {
            $wN = (float) ($stats['weighted_attempts'] ?? 0.0);
            $wWrong = (float) ($stats['weighted_wrong'] ?? 0.0);
            $n = (int) ($stats['attempts'] ?? 0);
            $wrong = (int) ($stats['wrong'] ?? 0);
            $byCategory[$cat]['error_rate'] = $n > 0 ? round($wrong / $n, 4) : null;
            $byCategory[$cat]['weighted_error_rate'] = $wN > 0 ? round($wWrong / $wN, 4) : null;
            $byCategory[$cat]['weighted_attempts'] = round($wN, 4);
            $byCategory[$cat]['weighted_wrong'] = round($wWrong, 4);
            $byCategory[$cat]['baseline_error_rate'] = round((float) ($stats['baseline_error_rate'] ?? 0.5), 4);
        }

        return [
            'attempts' => count($attempts),
            'correct_count' => $correctCount,
            'wrong_count' => $wrongCount,
            'weighted_attempts' => $weightedAttempts,
            'weighted_wrong' => $weightedWrong,
            'weighted_error_rate' => $weightedErrorRate,
            'last_graded_at' => $lastAt?->toDateTimeString(),
            'calibrated_difficulty' => $calibratedDifficulty,
            'meta' => [
                'algorithm' => self::ALGO,
                'question_type' => $questionType,
                'original_difficulty' => round($originalDifficulty, 4),
                'half_life_days' => self::HALF_LIFE_DAYS,
                'weighted_expected_error_rate' => $weightedExpectedErrorRate !== null
                    ? round($weightedExpectedErrorRate, 4)
                    : null,
                'residual' => round($residual, 4),
                'residual_gain' => round($residualGain, 4),
                'residual_scale_denom' => round($residualScaleDenom, 4),
                'step_limit' => round($stepLimit, 4),
                'residual_scale' => round($residualScale, 4),
                'effective_step' => round($effectiveStep, 4),
                'target_difficulty' => round($targetDifficulty, 4),
                'candidate_difficulty' => round($candidateDifficulty, 4),
                'shrinkage_m0' => round($shrinkageM0, 4),
                'adaptive_policy' => $adaptive,
                'by_difficulty_category' => $byCategory,
            ],
        ];
    }

    /**
     * 基于使用中的样本质量自动调整超参数，无需人工干预。
     *
     * @return array{residual_gain:float,residual_scale_denom:float,shrinkage_m0:float,confidence:float,signal_strength:float}
     */
    private function buildAdaptivePolicy(
        float $weightedAttempts,
        ?float $weightedErrorRate,
        ?float $weightedExpectedErrorRate,
        float $residual
    ): array {
        $confidence = min(1.0, max(0.0, $weightedAttempts / 80.0));

        // 信号强度由残差大小决定，残差越显著，收敛越快。
        $signalStrength = min(1.0, abs($residual) / 0.25);

        // 观测与期望偏差显著且样本充足时，提高 gain。
        $residualGain = self::RESIDUAL_GAIN_MIN
            + (self::RESIDUAL_GAIN_MAX - self::RESIDUAL_GAIN_MIN) * (0.55 * $confidence + 0.45 * $signalStrength);

        // 样本越充足，越敏感；信号越强，越敏感。
        $residualScaleDenom = self::RESIDUAL_SCALE_DENOM_MAX
            - (self::RESIDUAL_SCALE_DENOM_MAX - self::RESIDUAL_SCALE_DENOM_MIN) * (0.6 * $confidence + 0.4 * $signalStrength);

        // 收缩强度随置信度下降：样本少时强收缩，样本多时弱收缩。
        $shrinkageM0 = self::SHRINKAGE_M0_MAX
            - (self::SHRINKAGE_M0_MAX - self::SHRINKAGE_M0_MIN) * $confidence;

        // 若观测与期望非常接近，适度回拉避免无意义振荡。
        if ($weightedErrorRate !== null && $weightedExpectedErrorRate !== null && abs($weightedErrorRate - $weightedExpectedErrorRate) < 0.01) {
            $residualGain = max(self::RESIDUAL_GAIN_MIN, $residualGain * 0.75);
            $residualScaleDenom = min(self::RESIDUAL_SCALE_DENOM_MAX, $residualScaleDenom * 1.15);
            $shrinkageM0 = min(self::SHRINKAGE_M0_MAX, $shrinkageM0 * 1.10);
        }

        return [
            'residual_gain' => $this->clamp($residualGain, self::RESIDUAL_GAIN_MIN, self::RESIDUAL_GAIN_MAX),
            'residual_scale_denom' => $this->clamp($residualScaleDenom, self::RESIDUAL_SCALE_DENOM_MIN, self::RESIDUAL_SCALE_DENOM_MAX),
            'shrinkage_m0' => $this->clamp($shrinkageM0, self::SHRINKAGE_M0_MIN, self::SHRINKAGE_M0_MAX),
            'confidence' => round($confidence, 4),
            'signal_strength' => round($signalStrength, 4),
        ];
    }

    /**
     * @param  array<string,mixed>  $meta
     * @param  array<string,mixed>  $event
     * @return array<string,mixed>
     */
    private function appendRecentEvent(array $meta, array $event): array
    {
        $events = $meta['recent_events'] ?? [];
        if (! is_array($events)) {
            $events = [];
        }
        $events[] = $event;
        if (count($events) > self::RECENT_EVENTS_LIMIT) {
            $events = array_slice($events, -self::RECENT_EVENTS_LIMIT);
        }
        $meta['recent_events'] = $events;

        return $meta;
    }

    /**
     * @return array<string,mixed>
     */
    private function buildUpdateEvent(
        float $outcomeError,
        float $predBefore,
        float $predAfter,
        float $expectedErrorRate,
        float $observedErrorRate,
        float $residual,
        Carbon $now
    ): array {
        $outcomeError = $this->clamp($outcomeError, 0.0, 1.0);
        $p0 = $this->clamp($predBefore, 1e-6, 1.0 - 1e-6);
        $p1 = $this->clamp($predAfter, 1e-6, 1.0 - 1e-6);

        $brierBefore = ($p0 - $outcomeError) * ($p0 - $outcomeError);
        $brierAfter = ($p1 - $outcomeError) * ($p1 - $outcomeError);
        $loglossBefore = -($outcomeError * log($p0) + (1.0 - $outcomeError) * log(1.0 - $p0));
        $loglossAfter = -($outcomeError * log($p1) + (1.0 - $outcomeError) * log(1.0 - $p1));

        return [
            'ts' => $now->toDateTimeString(),
            'outcome_error' => round($outcomeError, 4),
            'pred_before' => round($predBefore, 4),
            'pred_after' => round($predAfter, 4),
            'expected_error_rate' => round($expectedErrorRate, 4),
            'observed_error_rate' => round($observedErrorRate, 4),
            'residual' => round($residual, 4),
            'abs_residual' => round(abs($residual), 4),
            'brier_before' => round($brierBefore, 6),
            'brier_after' => round($brierAfter, 6),
            'logloss_before' => round($loglossBefore, 6),
            'logloss_after' => round($loglossAfter, 6),
        ];
    }

    private function getHealthScaleForType(string $questionType): float
    {
        $type = trim($questionType) !== '' ? trim($questionType) : 'unknown';
        $cacheKey = 'difficulty_health_scale:'.$type;

        return Cache::remember($cacheKey, now()->addMinutes(5), function () use ($type) {
            $rows = DB::table(self::TABLE)
                ->where('updated_at', '>=', now()->subDays(14))
                ->select(['algorithm_meta'])
                ->get();

            $currResiduals = [];
            $prevResiduals = [];
            $brierDelta = 0.0;
            $loglossDelta = 0.0;
            $eventCount = 0;
            $nowTs = time();
            $cutTs = $nowTs - 7 * 86400;

            foreach ($rows as $row) {
                $meta = json_decode((string) ($row->algorithm_meta ?? ''), true);
                if (! is_array($meta)) {
                    continue;
                }
                if (($meta['question_type'] ?? 'unknown') !== $type) {
                    continue;
                }
                $events = $meta['recent_events'] ?? [];
                if (! is_array($events)) {
                    continue;
                }

                foreach ($events as $e) {
                    if (! is_array($e)) {
                        continue;
                    }
                    $ts = isset($e['ts']) ? strtotime((string) $e['ts']) : false;
                    if ($ts === false) {
                        continue;
                    }
                    $absResidual = abs((float) ($e['residual'] ?? 0.0));
                    if ($ts >= $cutTs) {
                        $currResiduals[] = $absResidual;
                        $brierDelta += (float) ($e['brier_after'] ?? 0.0) - (float) ($e['brier_before'] ?? 0.0);
                        $loglossDelta += (float) ($e['logloss_after'] ?? 0.0) - (float) ($e['logloss_before'] ?? 0.0);
                        $eventCount++;
                    } else {
                        $prevResiduals[] = $absResidual;
                    }
                }
            }

            if ($eventCount < 80) {
                return 1.0;
            }

            $avgBrierDelta = $brierDelta / max(1, $eventCount);
            $avgLoglossDelta = $loglossDelta / max(1, $eventCount);
            $medianCurrent = $this->median($currResiduals);
            $medianPrev = $this->median($prevResiduals);

            $scale = 1.0;
            if ($avgBrierDelta > 0.0 && $avgLoglossDelta > 0.0) {
                $scale *= 0.78;
            }
            if ($avgBrierDelta > 0.003 || $avgLoglossDelta > 0.01) {
                $scale *= 0.82;
            }
            if ($medianPrev !== null && $medianPrev > 0.0 && $medianCurrent !== null && $medianCurrent > $medianPrev * 1.05) {
                $scale *= 0.82;
            }

            $scale = $this->clamp($scale, 0.45, 1.0);

            Log::info('QuestionDifficultyCalibrationService: 在线健康监控快照', [
                'question_type' => $type,
                'events_7d' => $eventCount,
                'avg_brier_delta' => round($avgBrierDelta, 6),
                'avg_logloss_delta' => round($avgLoglossDelta, 6),
                'median_abs_residual_7d' => $medianCurrent !== null ? round($medianCurrent, 6) : null,
                'median_abs_residual_prev_7d' => $medianPrev !== null ? round($medianPrev, 6) : null,
                'health_scale' => round($scale, 3),
            ]);

            return $scale;
        });
    }

    /**
     * @param  array<int,float>  $values
     */
    private function median(array $values): ?float
    {
        if ($values === []) {
            return null;
        }
        sort($values);
        $n = count($values);
        $m = intdiv($n, 2);
        if ($n % 2 === 1) {
            return (float) $values[$m];
        }

        return ((float) $values[$m - 1] + (float) $values[$m]) / 2.0;
    }

    private function normalizeDifficultyValue(mixed $value): ?float
    {
        if ($value === null || $value === '') {
            return null;
        }

        $raw = (float) $value;
        if ($raw > 1.0) {
            $raw = $raw / 5.0;
        }

        return $this->clamp($raw, self::MIN_DIFF, self::MAX_DIFF);
    }

    private function clamp(float $value, float $min, float $max): float
    {
        return max($min, min($max, $value));
    }

    private function isReady(): bool
    {
        if ($this->tableReady !== null) {
            return $this->tableReady;
        }

        $this->tableReady = Schema::hasTable('paper_questions')
            && Schema::hasTable('papers')
            && Schema::hasTable('questions')
            && Schema::hasTable(self::TABLE);

        return $this->tableReady;
    }
}