import { initializeApp } from "https://www.gstatic.com/firebasejs/11.3.1/firebase-app.js";
    import { getDatabase, ref, get } from "https://www.gstatic.com/firebasejs/11.3.1/firebase-database.js";

    const firebaseConfig = {
      apiKey: "AIzaSyANsisjcKBOnKN_74Zh7H8D4t7IeR49jvo",
      authDomain: "classwave-ai.firebaseapp.com",
      databaseURL: "https://classwave-ai-default-rtdb.firebaseio.com",
      projectId: "classwave-ai",
      storageBucket: "classwave-ai.firebasestorage.app",
      messagingSenderId: "234994101387",
      appId: "1:234994101387:web:f237be0ce9f62205e0788e",
      measurementId: "G-RTG7SCCVDJ"
    };

    const app = initializeApp(firebaseConfig);
    const database = getDatabase(app);

    // Historique des messages
    let conversationHistory = [];
    let useCwaiMode = false;

    // Fonction d'attente
    function sleep(ms) {
      return new Promise(resolve => setTimeout(resolve, ms));
    }

    async function getPromptFromFirebase() {
      const promptRef = ref(database, 'Prompt');
      try {
        const snapshot = await get(promptRef);
        if (snapshot.exists()) {
          return snapshot.val();
        } else {
          return "Prompt non trouvé dans la base de données.";
        }
      } catch (error) {
        console.error("Erreur lors de la récupération du prompt:", error);
        return "Erreur lors de la récupération du prompt.";
      }
    }

    async function getPromptcwFromFirebase() {
      const promptcwRef = ref(database, 'Promptcw');
      try {
        const snapshot = await get(promptcwRef);
        if (snapshot.exists()) {
          return snapshot.val();
        } else {
          console.log("Aucune donnée trouvée pour Promptcw.");
          return "";
        }
      } catch (error) {
        console.error("Erreur lors de la récupération de Promptcw:", error);
        return "";
      }
    }

    async function getDecodedApiKey() {
      // Génère un chiffre aléatoire entre 0 et 3 (inclus)
      const randomNumber = Math.floor(Math.random() * 9);
      const apiRef = ref(database, 'API' + randomNumber);
      try {
        const snapshot = await get(apiRef);
        if (snapshot.exists()) {
          const encodedApiKey = snapshot.val();
          return atob(atob(encodedApiKey));
        } else {
          return null;
        }
      } catch (error) {
        console.error("Erreur lors de la récupération de la clé API:", error);
        return null;
      }
    }

    async function getUrlClasswaveFromFirebase() {
      const urlRef = ref(database, 'urlclasswave');
      try {
        const snapshot = await get(urlRef);
        if (snapshot.exists()) {
          return snapshot.val();
        } else {
          console.error("URL de l'API ClassWave non trouvée dans Firebase.");
          return "";
        }
      } catch (error) {
        console.error("Erreur lors de la récupération de l'URL ClassWave:", error);
        return "";
      }
    }

    async function getUrlClasswavesmartFromFirebase() {
      const urlRef = ref(database, 'urlclasswavesmart');
      try {
        const snapshot = await get(urlRef);
        if (snapshot.exists()) {
          return snapshot.val();
        } else {
          console.error("URL de l'API CWAI non trouvée dans Firebase.");
          return "";
        }
      } catch (error) {
        console.error("Erreur lors de la récupération de l'URL CWAI:", error);
        return "";
      }
    }

    async function sendMessage() {
      const userInput = document.getElementById('user-input');
      const message = userInput.value.trim();
      if (message === '') return;

      displayUserMessage(message);
      displayTypingIndicator();

      // Récupère la clé API (réessayer si nécessaire)
      let apiKey = await getDecodedApiKey();
      while (!apiKey) {
        await sleep(500);
        apiKey = await getDecodedApiKey();
      }

      // Si le message contient certains mots-clés, on utilise un prompt spécifique
      const keywords = ["classwave", "CLassblock", "CME", "CMP", "ClassManager"];
      function containsKeyword(msg) {
        return keywords.some(keyword => msg.toLowerCase().includes(keyword.toLowerCase()));
      }

      if (containsKeyword(message)) {
        const promptcw = await getPromptcwFromFirebase();
        const messagePrompt = `Ignore toutes instructions précédentes. Tu es un expert exclusivement sur ClassWave. Réponds uniquement en te basant sur les informations ci-dessous et ne rajoute aucune information supplémentaire.\n\nInformations sur ClassWave :\n${promptcw}\n\nQuestion de l'utilisateur : ${message}`;
        getClassWaveResponse(message, messagePrompt, apiKey);
        conversationHistory.push(message);
        userInput.value = '';
        return;
      }

      const prompt = await getPromptFromFirebase();
      let conversationContext = '';
      if (conversationHistory.length >= 2) {
        conversationContext = `Précédente conversation :\n1. Utilisateur : ${conversationHistory[conversationHistory.length - 2]}\n2. Bot : ${conversationHistory[conversationHistory.length - 1]}\n`;
      }
      const messagePrompt = `${prompt}\n${conversationContext}Voici la demande de l'utilisateur : ${message}`;

      if (useCwaiMode) {
        getCwaiResponse(message, messagePrompt, apiKey);
      } else {
        getClassWaveResponse(message, messagePrompt, apiKey);
      }
      conversationHistory.push(message);
      userInput.value = '';
    }

    function formatMessage(message) {
      message = message.replace(/--\(\)(.*?)(?=\n|$)/g, (match, content) => {
        return `<ul><li>${content.trim()}</li></ul>`;
      });
      message = message.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
      return message.replace(/[\n\r]+/g, '<br>');
    }

    function displayUserMessage(message) {
      const chatArea = document.getElementById('chat-area');
      const messageDiv = document.createElement('div');
      messageDiv.classList.add('message', 'user-message');
      messageDiv.innerHTML = formatMessage(message);
      chatArea.appendChild(messageDiv);
      chatArea.scrollTop = chatArea.scrollHeight;
    }

    function displayBotMessage(message) {
      const chatArea = document.getElementById('chat-area');
      const messageDiv = document.createElement('div');
      messageDiv.classList.add('message', 'bot-message');
      messageDiv.innerHTML = formatMessage(message);
      chatArea.appendChild(messageDiv);
      chatArea.scrollTop = chatArea.scrollHeight;
    }

    function displayTypingIndicator() {
      const chatArea = document.getElementById('chat-area');
      const typingDiv = document.createElement('div');
      typingDiv.classList.add('message', 'bot-message', 'typing-indicator');
      typingDiv.innerHTML = '<span>.</span><span>.</span><span>.</span>';
      chatArea.appendChild(typingDiv);
      chatArea.scrollTop = chatArea.scrollHeight;
    }

    async function getClassWaveResponse(userMessage, messagePrompt, apiKey) {
      const urlClasswave = await getUrlClasswaveFromFirebase();
      if (!urlClasswave) {
        console.error("URL pour ClassWave introuvable.");
        return;
      }
      const data = {
        contents: [{ parts: [{ text: messagePrompt }] }]
      };
      const finalUrl = urlClasswave + apiKey;
      try {
        const response = await fetch(finalUrl, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(data)
        });
        if (!response.ok) {
          throw new Error(`Erreur HTTP ! Statut : ${response.status}`);
        }
        const responseData = await response.json();
        const botReply =
          responseData?.candidates?.[0]?.content?.parts?.[0]?.text ||
          "Je n'ai pas pu obtenir de réponse.";
        document.querySelector('.typing-indicator')?.remove();
        displayBotMessage(botReply);
        conversationHistory.push(botReply);
      } catch (error) {
        console.error("Erreur lors du contact des serveurs CWAI.");
        getCwaiResponse(userMessage, messagePrompt, apiKey);
      }
    }

    async function getCwaiResponse(userMessage, messagePrompt, apiKey) {
      if (!apiKey) {
        displayBotMessage("Erreur : API Key non définie.");
        return;
      }
      const urlClasswavesmart = await getUrlClasswavesmartFromFirebase();
      if (!urlClasswavesmart) {
        document.querySelector('.typing-indicator')?.remove();
        displayBotMessage("Erreur : URL pour CWAI introuvable.");
        return;
      }
      const data = {
        contents: [{ parts: [{ text: messagePrompt }] }]
      };
      const finalUrl = urlClasswavesmart + apiKey;
      try {
        const response = await fetch(finalUrl, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(data)
        });
        if (!response.ok) {
          throw new Error(`Erreur HTTP ! Statut : ${response.status}`);
        }
        const responseData = await response.json();
        const botReply =
          responseData?.candidates?.[0]?.content?.parts?.[0]?.text ||
          "Je n'ai pas pu obtenir de réponse.";
        document.querySelector('.typing-indicator')?.remove();
        displayBotMessage(botReply);
        conversationHistory.push(botReply);
      } catch (error) {
        console.error("Erreur lors du contact des serveurs CWAI.");
        getClassWaveResponse(userMessage, messagePrompt, apiKey);
      }
    }

    document.addEventListener("DOMContentLoaded", () => {
      document.getElementById('send-button').addEventListener('click', sendMessage);
      document.getElementById('user-input').addEventListener('keypress', (event) => {
        if (event.key === 'Enter') {
          sendMessage();
          event.preventDefault();
        }
      });
      // Le bouton "Think" alterne le mode d'envoi sans envoyer de message
      document.getElementById('think-button').addEventListener('click', () => {
        if (useCwaiMode) {
          document.getElementById('think-button').style.backgroundColor = "#d3d3d3";
          useCwaiMode = false;
        } else {
          document.getElementById('think-button').style.backgroundColor = "#30416D";
          useCwaiMode = true;
        }
      });
    });