import { FLEX } from "@/theme/mixins";
import { router, useLocalSearchParams } from "expo-router";
import { StatusBar } from "expo-status-bar";
import React, { useEffect, useState } from "react";
import {
  ScrollView,
  StyleSheet,
  Text,
  Linking,
} from "react-native";
import { SafeAreaView } from "react-native-safe-area-context";
import { getExamQuestions, answerQuestion, addUserCertificate, getAllExams } from "../../services/user";
import Loading from "@/components/common/Loading";
import Empty from "@/components/common/Empty";

// Quiz Components
import QuizHeader from "@/components/quiz/QuizHeader";
import QuizProgress from "@/components/quiz/QuizProgress";
import QuizQuestion from "@/components/quiz/QuizQuestion";
import QuizOptions from "@/components/quiz/QuizOptions";
import QuizContinueButton from "@/components/quiz/QuizContinueButton";
import QuizHintModal from "@/components/quiz/QuizHintModal";
import QuizCorrectModal from "@/components/quiz/QuizCorrectModal";
import QuizResultModal from "@/components/quiz/QuizResultModal";

export default function QuizScreen() {
  const { id, lessonId, courseId } = useLocalSearchParams();
  const [currentQuestion, setCurrentQuestion] = useState(1);
  const [selectedAnswer, setSelectedAnswer] = useState(null);
  const [answerStatus, setAnswerStatus] = useState(null);
  const [showHintModal, setShowHintModal] = useState(false);
  const [showCorrectModal, setShowCorrectModal] = useState(false);
  const [showResultModal, setShowResultModal] = useState(false);
  const [quizResult, setQuizResult] = useState(null);
  const [correctAnswers, setCorrectAnswers] = useState(0);
  const [examQuestions, setExamQuestions] = useState([]);
  const totalQuestions = examQuestions?.length ?? 0;
  const [examInfo, setExamInfo] = useState(null);
  const [totalPoints, setTotalPoints] = useState(0);
  const [earnedPoints, setEarnedPoints] = useState(0);
  const [resultPercentage, setResultPercentage] = useState(0);
  const [loading, setLoading] = useState(true);
  const [submitting, setSubmitting] = useState(false);
  const [hintContent, setHintContent] = useState("");
  const [errorMessage, setErrorMessage] = useState("");
  const [certificateFileName, setCertificateFileName] = useState("");

  useEffect(() => {
    questions();
  }, []);

  const questions = async () => {
    try {
      setLoading(true);
      const res = await getExamQuestions(id);
      if (res.success) {
        setExamInfo({
          examId: res?.data?.examId ?? id,
          title: res.data.title,
          description: res.data.description,
          duration: res.data.duration,
          attemptNumber: res.data.attemptNumber,
          passingScore: res?.data?.passingScore,
          maxAttempts: res?.data?.maxAttempts,
          courseId: res?.data?.courseId,
          lessonId: res?.data?.lessonId,
        });
        const questions = Array.isArray(res.data.questions) ? res.data.questions : [];
        setExamQuestions(questions);
        const tp = questions.reduce((sum, q) => sum + (Number(q?.points) || 0), 0);
        setTotalPoints(tp);
        setEarnedPoints(0);
        setCorrectAnswers(0);

        // passingScore yoksa /exams/all üzerinden doldur
        if (res?.data?.passingScore == null) {
          try {
            const all = await getAllExams();
            const examsList = all?.data ?? [];
            const matchCourse = examsList?.find(c => Array.isArray(c?.exams) && c.exams.some(e => String(e?.id) === String(res?.data?.examId ?? id)));
            const matchExam = matchCourse?.exams?.find(e => String(e?.id) === String(res?.data?.examId ?? id));
            const updates = {};
            if (matchExam?.passingScore != null) updates.passingScore = matchExam.passingScore;
            if (matchExam?.maxAttempts != null) updates.maxAttempts = matchExam.maxAttempts;
            if (Object.keys(updates).length > 0) {
              setExamInfo(prev => ({ ...(prev || {}), ...updates }));
            }
          } catch {
            // sessiz geç
          }
        }
      }
    } catch (error) {
      setErrorMessage(error?.message ?? "");
    } finally {
      setLoading(false);
    }
  };

  const handleBackPress = () => {
    router.back();
  };

  const handleAnswerSelect = (optionIndex) => {
    setSelectedAnswer(optionIndex);
  };

  const handleContinue = async () => {
    try {
      if (selectedAnswer === null) return;
      const currentQuestionData = examQuestions?.[currentQuestion - 1];
      const selectedOption = currentQuestionData?.options?.[selectedAnswer];
      const payload = {
        examId: examInfo?.examId ?? id,
        questionId: currentQuestionData?.id,
        optionId: selectedOption?.id,
      };
      setSubmitting(true);
      const res = await answerQuestion(payload);
      const isCorrect = res?.data?.isCorrect === true;
      setAnswerStatus(isCorrect ? "correct" : "incorrect");
      if (!isCorrect) {
        setHintContent(selectedOption?.content ?? "");
      }
      if (isCorrect) {
        const gained = Number(currentQuestionData?.points) || 0;
        setEarnedPoints(prev => prev + gained);
      }
      setTimeout(() => {
        if (!isCorrect) {
          setShowHintModal(true);
        } else {
          setShowCorrectModal(true);
        }
      }, 300);
    } catch (error) {
      // Error handling
    } finally {
      setSubmitting(false);
    }
  };

  const handleCloseHint = async () => {
    setShowHintModal(false);

    // Continue to next question after hint
    if (currentQuestion < (examQuestions?.length ?? 0)) {
      setCurrentQuestion(currentQuestion + 1);
      setSelectedAnswer(null);
      setAnswerStatus(null);
    } else {
      // Quiz completed with wrong answer
      const tp = totalPoints > 0 ? totalPoints : (examQuestions?.reduce((s,q)=> s + (Number(q?.points)||0),0) || 0);
      const successRate = tp > 0 ? (earnedPoints / tp) * 100 : 0;
      setResultPercentage(Math.round(successRate));
      const threshold = Number(examInfo?.passingScore) || 70;
      if (successRate >= threshold) {
        try {
          const payloadLessonId = (lessonId ?? examInfo?.lessonId ?? currentQuestionData?.lessonId)?.toString();
          const payloadCourseId = (courseId ?? examInfo?.courseId)?.toString();
          if (!payloadLessonId || !payloadCourseId) {
            setErrorMessage("Ders veya kurs bilgisi bulunamadı");
            return;
          }
          const res = await addUserCertificate({
            lessonId: payloadLessonId,
            courseId: payloadCourseId,
          });
          if (res?.success) {
            const fileName = res?.data?.fileName ?? res?.data?.document ?? "";
            setCertificateFileName(fileName);
            setQuizResult("success");
            setShowResultModal(true);
          } else {
            setErrorMessage(res?.message ?? "Sertifika oluşturulamadı");
          }
        } catch (err) {
          setErrorMessage(err?.message ?? "Sertifika oluşturulamadı");
        }
      } else {
        setQuizResult("failure");
        setShowResultModal(true);
      }
    }
  };

  const handleCloseCorrect = async () => {
    setShowCorrectModal(false);

    // Continue to next question after correct answer
    if (currentQuestion < (examQuestions?.length ?? 0)) {
      setCorrectAnswers(correctAnswers + 1);
      setCurrentQuestion(currentQuestion + 1);
      setSelectedAnswer(null);
      setAnswerStatus(null);
    } else {
      // Quiz completed with correct answer
      const finalScore = (Number(correctAnswers) || 0) + 1;
      const gained = Number((examQuestions?.[currentQuestion - 1])?.points) || 0;
      const finalEarned = (Number(earnedPoints) || 0) + gained;
      const tp = totalPoints > 0 ? totalPoints : (examQuestions?.reduce((s,q)=> s + (Number(q?.points)||0),0) || 0);
      const successRate = tp > 0 ? (finalEarned / tp) * 100 : 0;
      setResultPercentage(Math.round(successRate));
      setCorrectAnswers(finalScore);

      const threshold = Number(examInfo?.passingScore) || 70;
      if (successRate >= threshold) {
        try {
          const payloadCourseId = (courseId ?? examInfo?.courseId)?.toString();
          if ( !payloadCourseId) {
            setErrorMessage("Ders veya kurs bilgisi bulunamadı");
            return;
          }
          const res = await addUserCertificate({
            courseId: payloadCourseId,
            examId: examInfo?.examId,
          });
          if (res?.success) {
            const fileName = res?.data?.fileName ?? res?.data?.document ?? "";
            setCertificateFileName(fileName);
            setQuizResult("success");
            setShowResultModal(true);
          } else {
            setErrorMessage(res?.message ?? "Sertifika oluşturulamadı");
          }
        } catch (err) {
          setErrorMessage(err?.message ?? "Sertifika oluşturulamadı");
        }
      } else {
        setQuizResult("failure");
        setShowResultModal(true);
      }
    }
  };

  const handleDownloadCertificate = async () => {
    try {
      const fileName = certificateFileName;
      if (fileName) {
        const url = `https://api.bugunyap.com/src/uploads/certificates/${fileName}`;
        await Linking.openURL(url);
      }
    } catch (error) {
      // Certificate download error
    }
  };

  const handleRetryQuiz = () => {
    setShowResultModal(false);
    // Teste Başla Sayfasına Dön → eğitimler sayfasına git
    router.push("/courses");
  };

  const handleCloseResultModal = () => {
    setShowResultModal(false);
    // Kapat → quiz'den çık, geri dön
    router.back();
  };

  if (loading) {
    return (
      <SafeAreaView style={styles.container}>
        <Loading fullscreen={true} message="Sorular yükleniyor..." />
      </SafeAreaView>
    );
  }

  if (errorMessage) {
    return (
      <SafeAreaView style={styles.container}>
        <Empty title={errorMessage} />
      </SafeAreaView>
    );
  }

  if (!(examQuestions?.length > 0)) {
    return (
      <SafeAreaView style={styles.container}>
        <Empty title="Soru Bulunamadı" description="Bu sınav için soru bulunamadı." />
      </SafeAreaView>
    );
  }

  const currentQuestionData = examQuestions[currentQuestion - 1];



  return (
    <SafeAreaView style={styles.container}>
      <StatusBar style="dark" backgroundColor="#F5F5F5" />

      {/* Header */}
      <QuizHeader
        title={examInfo?.title}
        currentQuestion={currentQuestion}
        totalQuestions={examQuestions.length}
        onBackPress={handleBackPress}
      />

      <ScrollView
        style={styles.scrollView}
        contentContainerStyle={styles.scrollContent}
        showsVerticalScrollIndicator={false}
      >
        {/* Progress Indicator */}
        <QuizProgress
          currentQuestion={currentQuestion}
          totalQuestions={examQuestions.length}
        />

        {/* Question */}
        <QuizQuestion question={currentQuestionData?.question} />

        {/* Answer Options */}
        <QuizOptions
          options={currentQuestionData?.options}
          selectedAnswer={selectedAnswer}
          answerStatus={answerStatus}
          onAnswerSelect={handleAnswerSelect}
        />
      </ScrollView>

      {/* Fixed Continue Button */}
      <QuizContinueButton
        selectedAnswer={selectedAnswer}
        currentQuestion={currentQuestion}
        totalQuestions={examQuestions.length}
        onContinue={handleContinue}
      />

      {/* Modals */}
      <QuizHintModal
        visible={showHintModal}
        onClose={handleCloseHint}
        hintContent={hintContent}
      />
      
      <QuizCorrectModal
        visible={showCorrectModal}
        onClose={handleCloseCorrect}
        correctMessage={currentQuestionData?.correctMessage}
      />
      
      <QuizResultModal
        visible={showResultModal}
        quizResult={quizResult}
        correctAnswers={correctAnswers}
        totalQuestions={totalQuestions}
        resultPercentage={resultPercentage}
        passingScore={Number(examInfo?.passingScore) || undefined}
        attemptsLeft={
          (Number(examInfo?.maxAttempts) || 0) > 0 && Number.isFinite(Number(examInfo?.attemptNumber))
            ? Math.max(0, Number(examInfo?.maxAttempts) - Number(examInfo?.attemptNumber))
            : undefined
        }
        onDownloadCertificate={handleDownloadCertificate}
        onRetryQuiz={handleRetryQuiz}
        onClose={handleCloseResultModal}
      />
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  container: {
    ...FLEX.fill,
    backgroundColor: "#F5F5F5",
  },
  scrollView: {
    flex: 1,
  },
  scrollContent: {
    paddingBottom: 120,
  },
});