import { signal } from "@preact/signals-react";
import { Step_n } from "../../App";

// Signal global pour les données du formulaire
export const formData = signal({});

// Ajouter ce nouveau signal
export const stepValidator = signal({ fn: () => true });

// Signal pour la gestion du leadership
export const leadershipStatus = signal({
  pageId: null,
  isLeader: false,
});

// Fonctions utilitaires pour manipuler le signal
export const formulaireUtils = {
  handleChange(field, value, pageName, type) {
    formData.value = {
      ...formData.value,
      [pageName]: {
        ...formData.value[pageName],
        sections: formData.value[pageName].sections.map((section) =>
          section.type === type
            ? { ...section, data: { ...section.data, [field]: value } }
            : section
        ),
      },
    };
  },

  getSection(pageName, type) {
    return formData.value[pageName].sections.find(
      (section) => section.type === type
    );
  },
};

export const formDataContext = {
  isInitialized: false,
  saveInterval: null,

  async init() {
    if (this.isInitialized) return;

    try {
      const response = await wp.apiFetch({
        path: "/wb-onboard/v1/get-form",
      });
      console.log(response);
      if (response?.data?.wb_onboard_form_data) {
        formData.value = response.data.wb_onboard_form_data;
      } else {
        formData.value = {};
      }

      Step_n.value = 0;
      if (response?.data?.wb_onboard_form_step_n !== undefined) {
        Step_n.value = response.data.wb_onboard_form_step_n;
      }

      // Démarrer la vérification de leadership avec auto-claim
      await leadershipUtils.startLeadershipCheck();

      // Mettre en place la sauvegarde automatique
      this.setupAutoSave();

      this.isInitialized = true;
    } catch (error) {
      console.error("Erreur lors de l'initialisation du formulaire:", error);
    }
  },

  setupAutoSave() {
    // Nettoyer l'intervalle existant si présent
    if (this.saveInterval) {
      clearInterval(this.saveInterval);
    }

    // Créer un nouvel intervalle de sauvegarde
    this.saveInterval = setInterval(async () => {
      // Vérifier si on est leader avant de sauvegarder
      if (!leadershipStatus.value.isLeader) {
        console.log("Sauvegarde automatique ignorée - pas leader");
        return;
      }

      try {
        await wp.apiFetch({
          path: "/wb-onboard/v1/save-form",
          method: "POST",
          data: {
            wb_onboard_form_data: formData.value,
            step_n: Step_n.value,
            page_id: leadershipStatus.value.pageId,
          },
        });
        console.log("Sauvegarde automatique effectuée (leader)");
      } catch (error) {
        // Si erreur NOT_LEADER, on perd le leadership
        if (error.code === "NOT_LEADER") {
          console.log("Leadership perdu détecté - mise à jour du statut");
          leadershipStatus.value = {
            ...leadershipStatus.value,
            isLeader: false,
          };
        }
        console.error("Erreur lors de la sauvegarde automatique:", error);
      }
    }, 5000); // 5000ms = 5 secondes
  },

  // Recharger les données depuis le serveur
  async refreshFormData() {
    try {
      const response = await wp.apiFetch({
        path: "/wb-onboard/v1/get-form",
      });

      if (response?.data?.wb_onboard_form_data) {
        formData.value = response.data.wb_onboard_form_data;
        console.log("Données du formulaire rechargées depuis le serveur");
      }

      if (response?.data?.wb_onboard_form_step_n !== undefined) {
        Step_n.value = response.data.wb_onboard_form_step_n;
        console.log("Étape actuelle mise à jour:", Step_n.value);
      }

      return true;
    } catch (error) {
      console.error("Erreur lors du rechargement des données:", error);
      return false;
    }
  },

  // Méthode pour nettoyer l'intervalle quand nécessaire
  cleanup() {
    if (this.saveInterval) {
      clearInterval(this.saveInterval);
      this.saveInterval = null;
    }
    // Nettoyer aussi le leadership
    leadershipUtils.cleanup();
  },
};

// Utilitaires pour la gestion du leadership
export const leadershipUtils = {
  // Générer un page_id unique pour cet onglet
  generatePageId() {
    if (!leadershipStatus.value.pageId) {
      const newPageId = crypto.randomUUID();
      leadershipStatus.value = {
        ...leadershipStatus.value,
        pageId: newPageId,
      };
      console.log("Page ID généré:", newPageId);
    } else {
      console.log("Page ID existant:", leadershipStatus.value.pageId);
    }
    return leadershipStatus.value.pageId;
  },

  // Vérifier le statut du leadership
  async checkLeadershipStatus() {
    if (leadershipStatus.value.isChecking) return;

    leadershipStatus.value = {
      ...leadershipStatus.value,
      isChecking: true,
    };

    try {
      const response = await wp.apiFetch({
        path: `/wb-onboard/v1/check-leader${
          leadershipStatus.value.pageId
            ? `?page_id=${leadershipStatus.value.pageId}`
            : ""
        }`,
      });

      console.log("🔍 Debug leadership:");
      console.log("Mon page_id:", leadershipStatus.value.pageId);
      console.log(
        "Mes 8 derniers caractères:",
        leadershipStatus.value.pageId?.slice(-8)
      );
      console.log(
        "Leader affiché (8 chars):",
        response.data.current_leader?.page_id
      );
      console.log("Is leader:", response.data.is_leader);
      console.log("Full response:", response);

      leadershipStatus.value = {
        ...leadershipStatus.value,
        isLeader: response.data.is_leader,
        currentLeader: response.data.current_leader,
        lastCheck: new Date().toISOString(),
        isChecking: false,
      };

      return response;
    } catch (error) {
      console.error("Erreur lors de la vérification du leadership:", error);
      leadershipStatus.value = {
        ...leadershipStatus.value,
        isChecking: false,
      };
      throw error;
    }
  },

  // Prendre le leadership (auto ou forcé)
  async claimLeadership(force = false) {
    try {
      const response = await wp.apiFetch({
        path: "/wb-onboard/v1/claim-leader",
        method: "POST",
        data: {
          page_id: leadershipStatus.value.pageId,
          force: force,
        },
      });

      if (response.success) {
        leadershipStatus.value = {
          ...leadershipStatus.value,
          isLeader: true,
          currentLeader: {
            page_id: leadershipStatus.value.pageId,
            user_id: response.user_id,
            last_activity: new Date().toISOString(),
          },
        };

        await formDataContext.refreshFormData();
      }

      return response;
    } catch (error) {
      console.error("Erreur lors de la prise de leadership:", error);
      throw error;
    }
  },

  // Démarrer la vérification périodique du leadership
  async startLeadershipCheck() {
    // Générer le page_id si pas encore fait
    this.generatePageId();

    // Vérification initiale avec auto-claim si aucun leader
    try {
      const response = await this.checkLeadershipStatus();

      // Si aucun leader actuel, essayer de prendre le leadership automatiquement
      if (
        response &&
        response.data.can_claim &&
        !response.data.current_leader
      ) {
        console.log("Aucun leader détecté - auto-claim au démarrage");
        await this.claimLeadership(false); // auto-claim, pas forcé
      }
    } catch (error) {
      console.error("Erreur lors de l'auto-claim au démarrage:", error);
    }

    // Nettoyer l'intervalle existant si présent
    if (leadershipStatus.value.checkInterval) {
      clearInterval(leadershipStatus.value.checkInterval);
    }

    // Créer un nouvel intervalle de vérification
    const interval = setInterval(async () => {
      try {
        const response = await this.checkLeadershipStatus();

        // Auto-claim périodique si aucun leader
        if (
          response &&
          response.data.can_claim &&
          !response.data.current_leader
        ) {
          console.log("Aucun leader détecté - auto-claim périodique");
          await this.claimLeadership(false);
        }
      } catch (error) {
        console.error("Erreur lors du check périodique:", error);
      }
    }, 30000); // 30 secondes

    leadershipStatus.value = {
      ...leadershipStatus.value,
      checkInterval: interval,
    };
  },

  // Arrêter la vérification du leadership
  stopLeadershipCheck() {
    if (leadershipStatus.value.checkInterval) {
      clearInterval(leadershipStatus.value.checkInterval);
      leadershipStatus.value = {
        ...leadershipStatus.value,
        checkInterval: null,
      };
    }
  },

  // Nettoyer toutes les ressources du leadership
  cleanup() {
    this.stopLeadershipCheck();
    leadershipStatus.value = {
      pageId: null,
      isLeader: false,
      currentLeader: null,
      lastCheck: null,
      checkInterval: null,
      isChecking: false,
    };
  },
};
