<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Paper;
use App\Models\PaperQuestion;
use App\Services\LearningAnalyticsService;
use App\Services\ExamPdfExportService;
use App\Services\QuestionBankService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\URL;

class IntelligentExamController extends Controller
{
    private LearningAnalyticsService $learningAnalyticsService;
    private QuestionBankService $questionBankService;
    private ExamPdfExportService $pdfExportService;

    public function __construct(
        LearningAnalyticsService $learningAnalyticsService,
        QuestionBankService $questionBankService,
        ExamPdfExportService $pdfExportService
    ) {
        $this->learningAnalyticsService = $learningAnalyticsService;
        $this->questionBankService = $questionBankService;
        $this->pdfExportService = $pdfExportService;
    }

    /**
     * 外部API：生成智能试卷，保存并返回 PDF/判卷链接
     */
    public function store(Request $request): JsonResponse
    {
        $normalized = $this->normalizePayload($request->all());

        $validator = validator($normalized, [
            'student_id' => 'required|string',
            'teacher_id' => 'required|string',
            'paper_name' => 'nullable|string|max:255',
            'grade' => 'nullable|string|max:50',
            'total_questions' => 'required|integer|min:6|max:100',
            'difficulty_category' => 'nullable|string',
            'kp_codes' => 'required|array|min:1',
            'kp_codes.*' => 'string',
            'skills' => 'array',
            'skills.*' => 'string',
            'question_type_ratio' => 'array',
            'difficulty_ratio' => 'array',
            'total_score' => 'nullable|numeric|min:1|max:1000',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => '参数错误',
                'errors' => $validator->errors()->toArray(),
            ], 422);
        }

        $data = $validator->validated();

        $questionTypeRatio = $this->normalizeQuestionTypeRatio($data['question_type_ratio'] ?? []);
        $difficultyRatio = $this->normalizeDifficultyRatio($data['difficulty_ratio'] ?? []);
        $paperName = $data['paper_name'] ?? ('智能试卷_' . now()->format('Ymd_His'));
        $difficultyCategory = $this->normalizeDifficultyCategory($data['difficulty_category'] ?? null);

        try {
            $result = $this->learningAnalyticsService->generateIntelligentExam([
                'student_id' => $data['student_id'],
                'grade' => $data['grade'] ?? null,
                'total_questions' => $data['total_questions'],
                'kp_codes' => $data['kp_codes'],
                'skills' => $data['skills'] ?? [],
                'question_type_ratio' => $questionTypeRatio,
                'difficulty_ratio' => $difficultyRatio,
            ]);

            if (empty($result['success'])) {
                return response()->json([
                    'success' => false,
                    'message' => $result['message'] ?? '智能出卷失败',
                ], 400);
            }

            $questions = $this->hydrateQuestions($result['questions'] ?? [], $data['kp_codes']);

            if (empty($questions)) {
                return response()->json([
                    'success' => false,
                    'message' => '未能生成有效题目，请检查知识点或题库数据',
                ], 400);
            }

            $totalScore = array_sum(array_column($questions, 'score'));

            $paperId = $this->questionBankService->saveExamToDatabase([
                'paper_name' => $paperName,
                'student_id' => $data['student_id'],
                'teacher_id' => $data['teacher_id'],
                'difficulty_category' => $difficultyCategory,
                'total_score' => $data['total_score'] ?? $totalScore,
                'questions' => $questions,
            ]);

            if (!$paperId) {
                return response()->json([
                    'success' => false,
                    'message' => '试卷保存失败',
                ], 500);
            }

            // 生成真实 PDF（试卷 + 判卷），若失败则回退到 HTML 预览
            $pdfUrl = $this->pdfExportService->generateExamPdf($paperId)
                ?? $this->questionBankService->exportExamToPdf($paperId)
                ?? route('filament.admin.auth.intelligent-exam.pdf', ['paper_id' => $paperId, 'answer' => 'false']);

            $gradingUrl = $this->pdfExportService->generateGradingPdf($paperId)
                ?? route('filament.admin.auth.intelligent-exam.grading', ['paper_id' => $paperId]);

            // 生成判卷PDF URL（带答案版本）
            $gradingPdfUrl = $this->pdfExportService->generateGradingPdf($paperId)
                ?? route('filament.admin.auth.intelligent-exam.pdf', ['paper_id' => $paperId, 'answer' => 'true']);

            // 构建包含完整信息的试卷内容
            $examContent = $this->buildCompleteExamContent($paperId);

            $payload = [
                'success' => true,
                'message' => '智能试卷生成成功',
                'data' => [
                    // 第一部分：组成卷子的所有内容
                    'exam_content' => $examContent,

                    // 第二部分：卷面和判卷的URL
                    'urls' => [
                        'grading_url' => route('filament.admin.auth.intelligent-exam.grading', ['paper_id' => $paperId]),
                        'student_exam_url' => route('filament.admin.auth.intelligent-exam.pdf', ['paper_id' => $paperId, 'answer' => 'false']),
                    ],

                    // 第三部分：卷面和判卷的PDF
                    'pdfs' => [
                        'exam_paper_pdf' => $pdfUrl,  // 纯试卷PDF（无答案）
                        'grading_pdf' => $gradingPdfUrl,  // 判卷PDF（带答案和解析）
                    ],

                    // 额外信息
                    'stats' => $result['stats'] ?? null,
                    'generated_at' => now()->toISOString(),
                ],
            ];

            // 返回不转义的完整 URL
            return response()->json($payload, 200, [], JSON_UNESCAPED_SLASHES);
        } catch (\Exception $e) {
            Log::error('Intelligent exam API failed', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
            ]);

            return response()->json([
                'success' => false,
                'message' => '服务异常，请稍后重试',
            ], 500);
        }
    }

    /**
     * 兼容字符串/数组入参
     */
    private function normalizePayload(array $payload): array
    {
        if (isset($payload['kp_codes']) && is_string($payload['kp_codes'])) {
            $payload['kp_codes'] = array_values(array_filter(array_map('trim', explode(',', $payload['kp_codes']))));
        }

        if (isset($payload['skills']) && is_string($payload['skills'])) {
            $payload['skills'] = array_values(array_filter(array_map('trim', explode(',', $payload['skills']))));
        }

        return $payload;
    }

    private function normalizeQuestionTypeRatio(array $input): array
    {
        // 默认按 4:2:4
        $defaults = [
            '选择题' => 40,
            '填空题' => 20,
            '解答题' => 40,
        ];

        $normalized = [];
        foreach ($input as $key => $value) {
            if (!is_numeric($value)) {
                continue;
            }
            $type = $this->normalizeQuestionTypeKey($key);
            if ($type) {
                $normalized[$type] = (float) $value;
            }
        }

        $merged = array_merge($defaults, $normalized);

        // 归一化到 100%
        $sum = array_sum($merged);
        if ($sum > 0) {
            foreach ($merged as $k => $v) {
                $merged[$k] = round(($v / $sum) * 100, 2);
            }
        }

        return $merged;
    }

    private function normalizeQuestionTypeKey(string $key): ?string
    {
        $key = trim($key);
        if (in_array($key, ['choice', '选择题', 'single_choice', 'multiple_choice'])) {
            return '选择题';
        }
        if (in_array($key, ['fill', '填空题', 'blank'])) {
            return '填空题';
        }
        if (in_array($key, ['answer', '解答题', '计算题'])) {
            return '解答题';
        }

        return null;
    }

    private function normalizeDifficultyRatio(array $input): array
    {
        $defaults = [
            '基础' => 50,
            '中等' => 35,
            '拔高' => 15,
        ];

        $normalized = [];
        foreach ($input as $key => $value) {
            if (!is_numeric($value)) {
                continue;
            }
            $label = trim($key);
            if (in_array($label, ['基础', 'easy', '简单'])) {
                $normalized['基础'] = (float) $value;
            } elseif (in_array($label, ['中等', 'medium'])) {
                $normalized['中等'] = (float) $value;
            } elseif (in_array($label, ['拔高', 'hard', '困难', '竞赛'])) {
                $normalized['拔高'] = (float) $value;
            }
        }

        return array_merge($defaults, $normalized);
    }

    private function normalizeDifficultyCategory(?string $category): string
    {
        if (!$category) {
            return '基础';
        }

        $category = trim($category);
        if (in_array($category, ['基础', '进阶', '中等', 'easy'])) {
            return $category === 'easy' ? '基础' : $category;
        }
        if (in_array($category, ['拔高', '困难', 'hard', '竞赛'])) {
            return '拔高';
        }

        return '基础';
    }

    private function hydrateQuestions(array $questions, array $kpCodes): array
    {
        $normalized = [];
        foreach ($questions as $question) {
            $type = $this->normalizeQuestionTypeKey($question['question_type'] ?? $question['type'] ?? '') ?? $this->guessType($question);
            $score = $question['score'] ?? $this->defaultScore($type);

            $normalized[] = [
                'id' => $question['id'] ?? $question['question_id'] ?? null,
                'question_id' => $question['question_id'] ?? null,
                'question_type' => $type === '选择题' ? 'choice' : ($type === '填空题' ? 'fill' : 'answer'),
                'stem' => $question['stem'] ?? $question['content'] ?? ($question['question_text'] ?? ''),
                'content' => $question['content'] ?? $question['stem'] ?? '',
                'options' => $question['options'] ?? ($question['choices'] ?? []),
                'answer' => $question['answer'] ?? $question['correct_answer'] ?? '',
                'solution' => $question['solution'] ?? '',
                'difficulty' => isset($question['difficulty']) ? (float) $question['difficulty'] : 0.5,
                'score' => $score,
                'estimated_time' => $question['estimated_time'] ?? 300,
                'kp' => $question['kp_code'] ?? $question['kp'] ?? $question['knowledge_point'] ?? ($kpCodes[0] ?? ''),
                'kp_code' => $question['kp_code'] ?? $question['kp'] ?? $question['knowledge_point'] ?? ($kpCodes[0] ?? ''),
            ];
        }

        return array_values(array_filter($normalized, fn ($q) => !empty($q['id'])));
    }

    private function guessType(array $question): string
    {
        if (!empty($question['options']) && is_array($question['options'])) {
            return '选择题';
        }

        $content = $question['stem'] ?? $question['content'] ?? '';
        if (is_string($content) && (strpos($content, '____') !== false || strpos($content, '（）') !== false)) {
            return '填空题';
        }

        return '解答题';
    }

    private function defaultScore(string $type): int
    {
        if ($type === '选择题' || $type === '填空题') {
            return 5;
        }

        return 10;
    }

    /**
     * 构建完整的试卷信息（包含所有题目详情）
     */
    private function buildCompleteExamContent(string $paperId): array
    {
        $paper = Paper::with('questions')->find($paperId);
        $questions = $paper ? $paper->questions : collect();

        return [
            // 试卷基本信息
            'paper_info' => [
                'paper_id' => $paperId,
                'paper_name' => $paper?->paper_name ?? '',
                'student_id' => $paper?->student_id ?? '',
                'teacher_id' => $paper?->teacher_id ?? '',
                'total_questions' => $questions->count(),
                'total_score' => $paper?->total_score ?? 0,
                'difficulty_category' => $paper?->difficulty_category ?? '基础',
                'created_at' => $paper?->created_at?->toISOString(),
                'updated_at' => $paper?->updated_at?->toISOString(),
            ],

            // 完整题目信息
            'questions' => $questions->map(function (PaperQuestion $q) {
                // 构建选择题选项（如果适用）
                $options = [];
                if ($q->question_type === 'choice') {
                    // 从题目文本中提取选项
                    $questionText = $q->question_text ?? '';
                    preg_match_all('/([A-D])\s*[\.\、\:]\s*([^A-D]+?)(?=[A-D]\s*[\.\、\:]|$)/u', $questionText, $matches, PREG_SET_ORDER);
                    foreach ($matches as $match) {
                        $options[] = [
                            'label' => $match[1],
                            'content' => trim($match[2]),
                        ];
                    }
                }

                return [
                    // 基本信息
                    'question_number' => $q->question_number,
                    'question_id' => $q->question_id,
                    'question_bank_id' => $q->question_bank_id,
                    'question_type' => $q->question_type,
                    'knowledge_point' => $q->knowledge_point,
                    'difficulty' => $q->difficulty,
                    'score' => $q->score,
                    'estimated_time' => $q->estimated_time,

                    // 题目内容
                    'stem' => $q->question_text ?? '',
                    'options' => $options,

                    // 答案和解析
                    'correct_answer' => $q->correct_answer ?? '',
                    'solution' => $q->solution ?? '',

                    // 元数据
                    'student_answer' => $q->student_answer,
                    'is_correct' => $q->is_correct,
                    'score_obtained' => $q->score_obtained,
                    'score_ratio' => $q->score_ratio,
                    'teacher_comment' => $q->teacher_comment,
                    'graded_at' => $q->graded_at?->toISOString(),
                    'graded_by' => $q->graded_by,

                    // 题目属性
                    'metadata' => [
                        'has_solution' => !empty($q->solution),
                        'is_choice' => $q->question_type === 'choice',
                        'is_fill' => $q->question_type === 'fill',
                        'is_answer' => $q->question_type === 'answer',
                        'difficulty_label' => $this->getDifficultyLabel($q->difficulty),
                        'question_type_label' => $this->getQuestionTypeLabel($q->question_type),
                    ],
                ];
            })->toArray(),

            // 统计信息
            'statistics' => [
                'type_distribution' => $this->getTypeDistribution($questions),
                'difficulty_distribution' => $this->getDifficultyDistribution($questions),
                'knowledge_point_distribution' => $this->getKnowledgePointDistribution($questions),
                'total_score' => $questions->sum('score'),
                'average_difficulty' => $questions->avg('difficulty'),
                'total_estimated_time' => $questions->sum('estimated_time'),
            ],

            // 知识点和技能标签
            'knowledge_points' => $questions->pluck('knowledge_point')->unique()->filter()->values()->toArray(),
            'skills' => $this->extractSkillsFromQuestions($questions),
        ];
    }

    /**
     * 获取题型中文标签
     */
    private function getQuestionTypeLabel(string $type): string
    {
        return match($type) {
            'choice' => '选择题',
            'fill' => '填空题',
            'answer' => '解答题',
            default => '未知题型'
        };
    }

    /**
     * 获取难度中文标签
     */
    private function getDifficultyLabel(?float $difficulty): string
    {
        if ($difficulty === null) return '未知';
        if ($difficulty <= 0.4) return '基础';
        if ($difficulty <= 0.7) return '中等';
        return '拔高';
    }

    /**
     * 获取题型分布
     */
    private function getTypeDistribution($questions): array
    {
        $distribution = [];
        foreach ($questions as $q) {
            $type = $q->question_type;
            $distribution[$type] = ($distribution[$type] ?? 0) + 1;
        }
        return $distribution;
    }

    /**
     * 获取难度分布
     */
    private function getDifficultyDistribution($questions): array
    {
        $distribution = [];
        foreach ($questions as $q) {
            $label = $this->getDifficultyLabel($q->difficulty);
            $distribution[$label] = ($distribution[$label] ?? 0) + 1;
        }
        return $distribution;
    }

    /**
     * 获取知识点分布
     */
    private function getKnowledgePointDistribution($questions): array
    {
        $distribution = [];
        foreach ($questions as $q) {
            $kp = $q->knowledge_point;
            if ($kp) {
                $distribution[$kp] = ($distribution[$kp] ?? 0) + 1;
            }
        }
        return $distribution;
    }

    /**
     * 从题目中提取技能标签
     */
    private function extractSkillsFromQuestions($questions): array
    {
        $skills = [];
        // 注意：由于题库在PostgreSQL中，MySQL的questions表可能不存在
        // 我们从PaperQuestion的solution或metadata中提取技能信息
        foreach ($questions as $q) {
            // 从解题过程中提取技能关键词
            $solution = $q->solution ?? '';
            if ($solution) {
                // 简单的技能提取（基于常见关键词）
                $skillKeywords = ['代入法', '配方法', '因式分解', '换元法', '判别式', '求根公式', '韦达定理'];
                foreach ($skillKeywords as $keyword) {
                    if (strpos($solution, $keyword) !== false) {
                        $skills[] = $keyword;
                    }
                }
            }

            // 从题目文本中提取技能标签（如果存在）
            $stem = $q->question_text ?? '';
            if ($stem) {
                // 尝试从题干中提取技能信息（格式如：{技能1,技能2}）
                preg_match_all('/\{([^}]+)\}/', $stem, $matches);
                foreach ($matches[1] as $match) {
                    $skillList = array_map('trim', explode(',', $match));
                    $skills = array_merge($skills, $skillList);
                }
            }
        }
        return array_unique(array_filter($skills));
    }
}