import React, { useState, useEffect } from "react";
import { Box, CircularProgress, Alert } from "@mui/material";
import { useSearchParams, Navigate } from "react-router-dom";
import Intro from "../components/Intro";
import EvaluationDisplay from "../components/EvaluationDisplay";
import { useThemeMode } from "../hooks/useThemeMode";
import getTheme from "../config/theme";
import API_CONFIG from "../config/api";

function EvaluationDisplayPage() {
  const [searchParams] = useSearchParams();
  const sessionId = searchParams.get("session");
  const [isValidSession, setIsValidSession] = useState(true);
  const [isLoading, setIsLoading] = useState(true);
  const [evaluationResults, setEvaluationResults] = useState(null);
  const [error, setError] = useState(null);
  const { mode } = useThemeMode();
  const theme = getTheme(mode);

  // Liste des documents de base qui ne doivent pas être supprimés
  const baseDocuments = ["the-bitter-lesson", "hurricane-faq", "pokemon-guide"];
  const isBaseDocument = baseDocuments.includes(sessionId);

  useEffect(() => {
    if (!sessionId) {
      console.log(
        "Session ID manquante pour l'affichage des résultats, redirection vers l'accueil"
      );
      setIsValidSession(false);
      return;
    }

    const fetchEvaluationResults = async () => {
      try {
        // Vérifier d'abord si la session existe
        const sessionCheckResponse = await fetch(
          `${API_CONFIG.BASE_URL}/benchmark-questions/${sessionId}`
        );

        if (!sessionCheckResponse.ok) {
          console.error(
            `Session invalide ou erreur serveur: ${sessionCheckResponse.status}`
          );
          setIsValidSession(false);
          return;
        }

        // Récupérer les résultats d'évaluation
        const evalResponse = await fetch(
          `${API_CONFIG.BASE_URL}/evaluation-results/${sessionId}`
        );

        if (!evalResponse.ok) {
          setError(`Failed to fetch results: ${evalResponse.status}`);
          setIsLoading(false);
          return;
        }

        const data = await evalResponse.json();

        if (!data.success) {
          setError(data.message || "Failed to fetch evaluation results");
          setIsLoading(false);
          return;
        }

        setEvaluationResults(data.results);
      } catch (error) {
        console.error("Error fetching evaluation results:", error);
        setError(error.message);
      } finally {
        setIsLoading(false);
      }
    };

    fetchEvaluationResults();
  }, [sessionId]);

  // Effet pour nettoyer le dossier de session après avoir affiché les résultats
  useEffect(() => {
    // Ne pas nettoyer si c'est un document de base ou si les résultats ne sont pas encore chargés
    if (isBaseDocument || isLoading || !evaluationResults) {
      return;
    }

    // Fonction pour supprimer le dossier de session
    const cleanupSession = async () => {
      try {
        const response = await fetch(
          `${API_CONFIG.BASE_URL}/cleanup-session/${sessionId}`,
          {
            method: "DELETE",
          }
        );

        if (response.ok) {
          console.log(`Session ${sessionId} cleaned up successfully`);
        } else {
          console.warn(`Failed to clean up session ${sessionId}`);
        }
      } catch (error) {
        console.error("Error cleaning up session:", error);
      }
    };

    // Appeler la fonction après un délai pour s'assurer que l'utilisateur a eu le temps de voir les résultats
    const cleanupTimeout = setTimeout(() => {
      cleanupSession();
    }, 2000);

    // Nettoyer le timeout si le composant est démonté
    return () => clearTimeout(cleanupTimeout);
  }, [sessionId, isBaseDocument, isLoading, evaluationResults]);

  if (!isValidSession) {
    return <Navigate to="/" />;
  }

  return (
    <>
      <Intro />
      {isLoading ? (
        <Box
          sx={{
            display: "flex",
            justifyContent: "center",
            alignItems: "center",
            mt: 8,
            mb: 8,
          }}
        >
          <CircularProgress size={60} />
        </Box>
      ) : error ? (
        <Alert severity="error" sx={{ mt: 4, mb: 4 }}>
          {error}
        </Alert>
      ) : (
        <Box
          sx={{
            border: `1px solid ${theme.palette.divider}`,
            borderRadius: 2,
            p: 4,
            bgcolor: "background.paper",
          }}
        >
          <EvaluationDisplay
            sessionId={sessionId}
            results={evaluationResults}
          />
        </Box>
      )}
    </>
  );
}

export default EvaluationDisplayPage;
