// context/SyncContext.tsx
import { buscarSyncIdProgresso } from "@/requests/CRUD/Distribuidores/sincronizacaoDistribuidor";
import React, {
  createContext,
  useContext,
  useEffect,
  useRef,
  useState,
} from "react";
import { toast } from "react-toastify";
import useSWR from "swr";
//nao remover o arquivo <3
const SyncContext = createContext<any>(null);

export const SyncProvider = ({ children }: { children: React.ReactNode }) => {
  const [canSync, setCanSync] = useState(false);
  const [update, setUpdate] = useState(0);
  const [distribuidor, setDistribuidor] = useState<any>(null);
  const toastId = useRef<string | number | null>(null);

  // Referências para o cálculo do tempo que você já criou
  const prevProgress = useRef(0);
  const prevTime = useRef(0);

  // O SWR agora vive aqui no Global!
  const { data } = useSWR(
    canSync ? { distribuidor } : null,
    canSync ? buscarSyncIdProgresso : null,
    {
      refreshInterval: 2000,
      // revalidateOnFocus: true,
    }
  );

  const startGlobalSync = async (newDistribuidor: string) => {
    if (newDistribuidor !== "BE") {
      return;
    }

    setCanSync(true);
    setUpdate(0);
    prevProgress.current = 0;
    prevTime.current = Date.now();
    setDistribuidor(newDistribuidor);

    toastId.current = toast.loading("Iniciando sincronização...", {
      position: "bottom-right",
      closeButton: true,
      onClose: () => setCanSync(false), // Para o polling se fechar o toast
    });
  };

  // Efeito global que atualiza o toast independente da página que você está
  useEffect(() => {
    if (data && toastId.current) {
      const progresso = +data.processed_kits / +data.total_kits;

      // ... sua lógica de calcular tempo que fizemos antes ...
      let tempoRestante = "Calculando...";
      if (progresso > prevProgress.current) {
        tempoRestante = calcularETALinear(
          prevProgress.current,
          progresso,
          prevTime.current
        );
      }

      prevProgress.current = progresso;
      prevTime.current = Date.now();

      if (data?.status != "completed") {
        toast.update(toastId.current, {
          autoClose: false,
          render: (
            <div className="flex flex-col">
              <div className="flex flex-row flex-nowrap gap-3">
                <div>Status</div>
                <div className="font-bold whitespace-nowrap">Sincronizando</div>
              </div>
              <div className="flex flex-row flex-nowrap gap-3">
                <div className="whitespace-nowrap">
                  Quantidade de kits totais
                </div>
                <div className="font-bold whitespace-nowrap">
                  {String(data.total_kits)}
                </div>
              </div>
              <div className="flex flex-row flex-nowrap gap-3">
                <div className="whitespace-nowrap">
                  Quantidade de kits processados
                </div>
                <div className="font-bold whitespace-nowrap">
                  {String(data.processed_kits)}
                </div>
              </div>
              <div className="flex flex-row flex-nowrap gap-3">
                <div className="whitespace-nowrap">Tempo Estimado</div>
                <div className="font-bold whitespace-nowrap">
                  {String(tempoRestante)}
                </div>
              </div>
            </div>
          ),
          progress: progresso,
        });

        setUpdate(1);
      } else if (update != 0) {
        toast.update(toastId.current, {
          render: "Sincronização concluída! 🚀",
          type: "success",
          isLoading: false,
          autoClose: 5000,
        });
        // setIsSyncing(false);
      }
    }
  }, [data, toastId]);

  function calcularETALinear(
    lastProgress: number,
    currentProgress: number,
    lastTime: number
  ): string {
    const agora = Date.now();
    const deltaProgress = currentProgress - lastProgress;
    const deltaTime = (agora - lastTime) / 1000; // segundos entre as consultas

    if (deltaProgress <= 0) return "Calculando...";

    const velocidadeInstatanea = deltaProgress / deltaTime;
    const progressoRestante = 1 - currentProgress;
    let segundosRestantes = progressoRestante / velocidadeInstatanea;

    if (segundosRestantes <= 0) return "Finalizando...";

    // Lógica de formatação HH:MM:SS
    const horas = Math.floor(segundosRestantes / 3600);
    segundosRestantes %= 3600;
    const minutos = Math.floor(segundosRestantes / 60);
    const segundos = Math.round(segundosRestantes % 60);

    if (horas > 0) {
      return `${horas}h ${minutos}m ${segundos}s`;
    } else if (minutos > 0) {
      return `${minutos}m ${segundos}s`;
    }

    return `${segundos}s`;
  }

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

export const useSync = () => useContext(SyncContext);