import { listarLojas } from "@/requests/CRUD/Lojas/listarLojas";
import React, {
  createContext,
  ReactNode,
  useContext,
  useEffect,
  useState,
} from "react";
import { useAuth } from "./authContext";

// Tipos para as lojas
interface Loja {
  id_loja: string;
  nome_loja: string;
  endereco_loja: string;
  numero_loja: string;
  bairro_loja: string;
  cidade_loja: string;
  estado_loja: string;
  cep_loja: string;
  telefone_loja: string;
  email_loja: string;
  status_loja: string;
  comissao_indicacao_loja: string;
  comissao_preVendedor_loja: string;
  comissao_gerente_loja: string;
  comissao_supervisor_loja: string;
  pre_apuracao_comissao_loja: string;
  accessTokenGoogle_loja: string;
  [key: string]: any; // Para outras propriedades dinâmicas
}

// Interface do contexto
interface LojaContextType {
  // Estados
  lojas: Loja[];
  lojasUsuario: Loja[];
  lojaAtual: Loja | null;
  isLoading: boolean;
  error: string | null;

  // Ações
  setLojaAtual: (loja: Loja | null) => void;
  obterLojaPorId: (id: string) => Loja | undefined;
  recarregarLojas: () => Promise<void>;
  verificarAcessoLoja: (idLoja: string) => boolean;
  obterLojasUsuario: () => Loja[];
}

// Criação do contexto
const LojaContext = createContext<LojaContextType | undefined>(undefined);

// Provider do contexto
interface LojaProviderProps {
  children: ReactNode;
}

export const LojaProvider: React.FC<LojaProviderProps> = ({ children }) => {
  const [lojas, setLojas] = useState<Loja[]>([]);
  const [lojasUsuario, setLojasUsuario] = useState<Loja[]>([]);
  const [lojaAtual, setLojaAtual] = useState<Loja | null>(null);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const { usuario, valuesSession } = useAuth();
  const { session } = valuesSession();

  // Função para carregar todas as lojas
  const carregarLojas = async () => {
    setIsLoading(true);
    setError(null);

    try {
      const todasLojas = await listarLojas();
      setLojas(todasLojas);

      // Filtra as lojas que o usuário tem acesso
      if (usuario?.loja_usuario) {
        const idsLojasUsuario = usuario.loja_usuario.split(",");
        const lojasComAcesso = todasLojas.filter((loja: Loja) =>
          idsLojasUsuario.includes(loja.id_loja)
        );
        setLojasUsuario(lojasComAcesso);

        // Define a loja atual se ainda não foi definida
        if (!lojaAtual && session?.loja_padrao_usuario) {
          const lojaPadrao = lojasComAcesso.find(
            (loja: Loja) => loja.id_loja === session.loja_padrao_usuario
          );
          if (lojaPadrao) {
            setLojaAtual(lojaPadrao);
          } else if (lojasComAcesso.length > 0) {
            // Se não encontrar a loja padrão, usa a primeira disponível
            setLojaAtual(lojasComAcesso[0]);
          }
        }
      }
    } catch (err) {
      setError("Erro ao carregar lojas");
      console.error("Erro ao carregar lojas:", err);
    } finally {
      setIsLoading(false);
    }
  };

  // Função para recarregar as lojas
  const recarregarLojas = async () => {
    await carregarLojas();
  };

  // Função para obter uma loja por ID
  const obterLojaPorId = (id: string): Loja | undefined => {
    return lojas.find((loja) => loja.id_loja === id);
  };

  // Função para verificar se o usuário tem acesso a uma loja
  const verificarAcessoLoja = (idLoja: string): boolean => {
    if (!usuario?.loja_usuario) return false;
    const idsLojasUsuario = usuario.loja_usuario.split(",");
    return idsLojasUsuario.includes(idLoja);
  };

  // Função para obter as lojas que o usuário tem acesso
  const obterLojasUsuario = (): Loja[] => {
    return lojasUsuario;
  };

  // Efeito para carregar as lojas quando o usuário muda
  useEffect(() => {
    if (usuario) {
      carregarLojas();
    }
  }, [usuario]);

  // Efeito para limpar os dados quando não há usuário
  useEffect(() => {
    if (!usuario) {
      setLojas([]);
      setLojasUsuario([]);
      setLojaAtual(null);
      setError(null);
    }
  }, [usuario]);

  // Valor do contexto
  const contextValue: LojaContextType = {
    // Estados
    lojas,
    lojasUsuario,
    lojaAtual,
    isLoading,
    error,

    // Ações
    setLojaAtual,
    obterLojaPorId,
    recarregarLojas,
    verificarAcessoLoja,
    obterLojasUsuario,
  };

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

// Hook personalizado para usar o contexto
export const useLoja = (): LojaContextType => {
  const context = useContext(LojaContext);

  if (context === undefined) {
    throw new Error("useLoja deve ser usado dentro de um LojaProvider");
  }

  return context;
};

export const useLojasUsuario = (): Loja[] => {
  const { lojasUsuario } = useLoja();
  return lojasUsuario;
};

export const useLojaAtual = (): [Loja | null, (loja: Loja | null) => void] => {
  const { lojaAtual, setLojaAtual } = useLoja();
  return [lojaAtual, setLojaAtual];
};

// Exportação do tipo para uso externo
export type { Loja, LojaContextType };