"use client";

import React, {
  createContext,
  useContext,
  useEffect,
  useRef,
  useState,
  useMemo,
} from "react";
import { useRouter } from "next/navigation";

interface ExamTimerContextType {
  timeRemaining: number;
  totalSeconds: number;
  isTimeUp: boolean;
}

const ExamTimerContext = createContext<ExamTimerContextType | null>(null);

export function ExamTimerProvider({
  children,
  initialRemainingSeconds,
  examId,
}: {
  children: React.ReactNode;
  initialRemainingSeconds: number;
  examId: string | number;
}) {
  const router = useRouter();

  const [timeRemaining, setTimeRemaining] = useState(
    initialRemainingSeconds
  );
  const [isTimeUp, setIsTimeUp] = useState(false);

  const deadlineRef = useRef<number | null>(null);
  const hasSubmittedRef = useRef(false);

  useEffect(() => {
    deadlineRef.current = Date.now() + initialRemainingSeconds * 1000;
  }, [initialRemainingSeconds]);

  useEffect(() => {
    if (!deadlineRef.current) return;

    const id = setInterval(() => {
      const now = Date.now();
      const remaining = Math.max(
        0,
        Math.floor((deadlineRef.current! - now) / 1000)
      );

      setTimeRemaining(remaining);

      if (remaining === 0 && !hasSubmittedRef.current) {
        hasSubmittedRef.current = true;
        setIsTimeUp(true);

        router.replace(`/exam/${examId}/result`);
      }
    }, 1000);

    return () => clearInterval(id);
  }, [router, examId]);

  const value = useMemo(
    () => ({
      timeRemaining,
      totalSeconds: initialRemainingSeconds,
      isTimeUp,
    }),
    [timeRemaining, initialRemainingSeconds, isTimeUp]
  );

  return (
    <ExamTimerContext.Provider value={value}>
      {children}
    </ExamTimerContext.Provider>
  );
}

export function useExamTimer() {
  const ctx = useContext(ExamTimerContext);
  if (!ctx) {
    throw new Error("useExamTimer must be used within ExamTimerProvider");
  }
  return ctx;
}