import {
  getTotalizadores,
  listarConfiguracoesAnexos,
  listarDadosFunil,
  listarKanban,
  listarLocks,
  listarLocksPermissoes,
  listarLocksResponsaveis,
  listarLocksRetrocesso,
  listarTodosKanbans,
} from "@/requests/CRM/kanban";

import { useRouter } from "next/router";
import {
  Dispatch,
  ReactNode,
  SetStateAction,
  createContext,
  useContext,
  useEffect,
  useReducer,
  useRef,
  useState,
} from "react";

import { listarContatos } from "@/requests/CRUD/Cliente/listarClientes";
import { listarDistribuidoresNativos } from "@/requests/CRUD/Distribuidores/listarDistribuidoresNativos";
import { listarDocumentosGerados } from "@/requests/CRUD/DocumentosGerados/listarDocumentosGeradosPorIdColeta";
import { listarDocumentosPersonalizados } from "@/requests/CRUD/DocumentosPersonalizados/listarDocumentosPersonalizados";
import { listarPendencias } from "@/requests/CRUD/LinhaPendencias/listarLinhaPendencias";
import {
  listarCidades,
  listarEstados,
} from "@/requests/common/EstadosCidades/estadosCidades";
import { addHours, differenceInDays, parseISO, startOfDay } from "date-fns";
import { usePathname } from "next/navigation";
import { useAuth } from "./authContext";

interface IProviderProps {
  children: ReactNode;
}
function shallowEqual(a: any, b: any) {
  if (a === b) return true;
  if (!a || !b) return false;
  const ka = Object.keys(a);
  const kb = Object.keys(b);
  if (ka.length !== kb.length) return false;
  for (const k of ka) if (a[k] !== b[k]) return false;
  return true;
}
function sanitizeLists(lists: any[] | undefined | null, listKey = "id") {
  return (lists || []).filter(
    (item) => item != null && item[listKey] != null && item[listKey] !== "",
  );
}

function toListsWithPlaceholders(
  baseLists: any[],
  prevLists: any[],
  listKey = "id",
  cardKey = "id_card",
) {
  const safeBaseLists = sanitizeLists(baseLists, listKey);
  const safePrevLists = sanitizeLists(prevLists, listKey);
  const prevById = new Map(safePrevLists.map((l) => [l[listKey], l]));
  return safeBaseLists.map((l) => {
    const prev = prevById.get(l[listKey]);
    const cardIds = l?.ids_cards?.split(",").filter(Boolean) || [];
    const prevCardsById = new Map(
      (prev?.cards || []).map((c: any) => [c[cardKey], c]),
    );
    const cards = cardIds.map((id: string) => {
      const pc: any = prevCardsById.get(id) as any;
      if (pc && !pc.isNotLoaded) return pc;
      return { [cardKey]: id, isNotLoaded: true };
    });
    return { ...l, cards };
  });
}

function mergeListsIncremental(
  prevLists: any[],
  nextLists: any[],
  listKey = "id",
  cardKey = "id_card",
) {
  const safePrevLists = sanitizeLists(prevLists, listKey);
  const safeNextLists = sanitizeLists(nextLists, listKey);

  if (safeNextLists.length === 0) {
    return safePrevLists;
  }

  if (safePrevLists.length === 0) {
    return safeNextLists;
  }

  const prevById = new Map(safePrevLists.map((l) => [l[listKey], l]));
  let somethingChanged = false;
  const merged = safeNextLists.map((nl) => {
    const pl = prevById.get(nl[listKey]);
    if (!pl) {
      somethingChanged = true;
      return nl; // lista nova
    }
    function shallowEqualExcept<T extends object>(
      a: T,
      b: T,
      exceptKeys: string[],
    ) {
      if (a === b) return true;
      if (!a || !b) return false;
      const ka = Object.keys(a).filter((k) => !exceptKeys.includes(k));
      const kb = Object.keys(b).filter((k) => !exceptKeys.includes(k));
      if (ka.length !== kb.length) return false;
      for (const k of ka) if ((a as any)[k] !== (b as any)[k]) return false;
      return true;
    }
    const sameMeta = shallowEqualExcept(pl, nl, ["cards", "ids_cards", "qtd_cards"]);

    const prevCards = (pl.cards || []).filter(
      (c: any) => c != null && c[cardKey] != null,
    );
    const nextCards = (nl.cards || []).filter(
      (c: any) => c != null && c[cardKey] != null,
    );
    const prevCardById = new Map(prevCards.map((c: any) => [c[cardKey], c]));

    let anyCardChanged = false;
    const mergedCards = nextCards.map((nc: any) => {
      const pc = prevCardById.get(nc[cardKey]);
      if (pc && shallowEqual(pc, nc)) return pc; // reaproveita ref do card
      anyCardChanged = true;
      return nc;
    });

    const cardsRef =
      !anyCardChanged && prevCards.length === mergedCards.length
        ? prevCards
        : mergedCards;

    const listChanged =
      !sameMeta ||
      pl.ids_cards !== nl.ids_cards ||
      pl.qtd_cards !== nl.qtd_cards ||
      cardsRef !== prevCards;
    if (!listChanged) return pl; // reaproveita ref da lista

    somethingChanged = true;
    return { ...pl, ...nl, cards: cardsRef };
  });

  // Se tamanho mudou (listas adicionadas/removidas), forçamos novo array
  if (merged.length !== safePrevLists.length) somethingChanged = true;

  return somethingChanged ? merged : safePrevLists;
}

function applyKanbanListsResponse(
  res: any,
  prevLists: any[],
  listKey = "id",
  cardKey = "id_card",
) {
  const baseLists = Array.isArray(res)
    ? res
    : Array.isArray(res?.body)
      ? res.body
      : [];
  const prepared = toListsWithPlaceholders(
    baseLists,
    prevLists,
    listKey,
    cardKey,
  );
  return mergeListsIncremental(prevLists, prepared, listKey, cardKey);
}
interface IKanbanProviderProps {
  lists: any[];
  setLists: Dispatch<SetStateAction<any[]>>;
  originalLists: any[];
  setOriginalLists: Dispatch<SetStateAction<any[]>>;
  listarDadosKanban: () => Promise<any>;
  reListarDadosKanban: () => Promise<any>;
  funil: string | string[] | undefined;
  dadosFunil: any;
  setDadosFunil: any;
  cidades: any[];
  setCidades: Dispatch<SetStateAction<any[]>>;
  estados: any[];
  setEstados: Dispatch<SetStateAction<any[]>>;
  menuOnView: any;
  setMenuOnView: Dispatch<SetStateAction<boolean>>;
  openMenu: any;
  goBack: any;
  renameMenu: any;
  resetMenu: any;
  clientes: any[];
  estadosFiltro: any[];
  menuStack: any;
  locks: any[];
  locksResponsaveis: any[];
  locksRetrocesso: any[];
  categoriaslocksPermissoes: any[];
  docsPersonalizadosGerados: any[];
  businessFilters: any;
  setBusinessFilters: Dispatch<SetStateAction<any>>;
  todosKanbans: any[];
  categoriasAnexos: any[];
  documentosPersonalizados: any[];
  kanbanLoaded: boolean;
  reListarDistribuidores: () => Promise<void>;
  validateFilters: any;
  pendencias_card: any[];
  totalizadores: any;

  cardsState: any;
  setCardsState: Dispatch<SetStateAction<any>>;
  isLoadingTotalizadores: boolean;
}

const KanbanContext = createContext({} as IKanbanProviderProps);
type MenuComponent = JSX.Element;

type MenuItem = {
  component: JSX.Element;
  name?: string;
};

type MenuState = MenuItem[];

type MenuAction =
  | { type: "PUSH"; component: JSX.Element; name?: string }
  | { type: "POP" }
  | { type: "RESET" }
  | { type: "RENAME"; name: string; index?: number };

const menuReducer = (state: MenuState, action: MenuAction): MenuState => {
  switch (action.type) {
    case "PUSH":
      return [...state, { component: action.component, name: action.name }];
    case "POP":
      return state.length > 1 ? state.slice(0, -1) : state;
    case "RESET":
      return [];
    case "RENAME": {
      // por padrão renomeia o menu atual (topo da stack)
      const index = action.index ?? state.length - 1;

      return state.map((item, i) =>
        i === index ? { ...item, name: action.name } : item,
      );
    }
    default:
      return state;
  }
};

export const KanbanProvider = ({ children }: IProviderProps) => {
  const [lists, setLists] = useState<any[]>([]);
  const [originalLists, setOriginalLists] = useState<any[]>([]); // New state variable for original lists
  const [dadosFunil, setDadosFunil] = useState<any>();
  const [cidades, setCidades] = useState<any[]>([]);
  const [clientes, setClientes] = useState<any[]>([]);
  const [estadosFiltro, setEstadosFiltro] = useState<any[]>([]); // New state variable for original lists
  const [locks, setLocks] = useState<any[]>([]);
  const [locksResponsaveis, setLocksResponsaveis] = useState<any[]>([]);
  const [locksRetrocesso, setLocksRetrocesso] = useState<any[]>([]);
  const [docsPersonalizadosGerados, setDocsPersonalizadosGerados] = useState<
    any[]
  >([]);
  const [categoriaslocksPermissoes, setCategoriaslocksPermissoes] = useState<
    any[]
  >([]);

  const [todosKanbans, setTodosKanbans] = useState<any[]>([]);
  const [categoriasAnexos, setCategoriaAnexos] = useState<any[]>([]);
  const [distribuidores, setDistribuidores] = useState<any[]>([]);

  const [documentosPersonalizados, setDocumentosPersonalizados] = useState<
    any[]
  >([]);
  const [menuOnView, setMenuOnView] = useState<boolean>(false);
  const [kanbanLoaded, setKanbanLoaded] = useState(false);
  const [businessFilters, setBusinessFilters] = useState<any>({});

  const [pendencias_card, setPendencias_card] = useState<any[]>([]);
  const [menuStack, dispatch] = useReducer(menuReducer, []);

  const [totalizadores, setTotalizadores] = useState();
  const [isLoadingTotalizadores, setIsLoadingTotalizadores] = useState(false);

  const [cardsState, setCardsState] = useState({});
  const skipBusinessFiltersRelistRef = useRef(true);

  // const [availableCards, setAvailableCards] = useState<string[]>(["*"]);

  const openMenu = (component: MenuComponent, name?: string) => {
    dispatch({ type: "PUSH", component, name });
    setMenuOnView(true);
  };
  const renameMenu = (name: string, index?: number) => {
    dispatch({ type: "RENAME", name, index });
  };

  const goBack = () => dispatch({ type: "POP" });
  const resetMenu = () => {
    dispatch({ type: "RESET" });
    setMenuOnView(false);
  };

  const router = useRouter();
  const { funil } = router.query;
  const pathname = usePathname();
  const { localToken, valuesSession } = useAuth();
  const { session } = valuesSession();

  useEffect(() => {
    if (localToken && pathname != "/") {
      //(localToken)
      listarCidades().then((arr) => setCidades(arr));
      listarEstados().then((arr) => setEstadosFiltro(arr));
      listarContatos().then((arr) => setClientes(arr));
      listarLocks().then((res) => setLocks(res));
      listarLocksResponsaveis().then((res) => setLocksResponsaveis(res));
      listarLocksRetrocesso().then((res) => setLocksRetrocesso(res));
      listarLocksPermissoes().then((res) => setCategoriaslocksPermissoes(res));
      listarDocumentosGerados().then((res) =>
        setDocsPersonalizadosGerados(res),
      );
      listarTodosKanbans().then((res) => setTodosKanbans(res));
      listarConfiguracoesAnexos().then((res) => setCategoriaAnexos(res));
      listarDistribuidoresNativos().then((res) => setDistribuidores);

      listarDocumentosPersonalizados().then((res) =>
        setDocumentosPersonalizados(res),
      );
    }
  }, [localToken]);

  function getApprovedProposal(card: any) {
    return (
      card?.propostas?.find((prop: any) => prop.status_proposta == 1) || {}
    );
  }
  function validateFilters(businessFilters: any, card: any, responsaveis: any) {
    if (card?.isNotLoaded) {
      return false;
    }
    return true;
    const filtersToCheck = [
      { key: "responsavel_filtro", value: responsaveis["Administrativo"] },
      { key: "gerente_filtro", value: responsaveis["Gerente"] },
      { key: "supervisor_filtro", value: responsaveis["Supervisor"] },
      { key: "vendedor_filtro", value: responsaveis["Vendedor"] },
      { key: "preVendedor_filtro", value: responsaveis["Pré-Vendedor"] },
      { key: "tecnico_filtro", value: responsaveis["Técnico"] },
      { key: "instalador_filtro", value: responsaveis["Instalador"] },
      { key: "tipo_negocio_filtro", value: card.tipoNegocio_coleta },
      { key: "numNegocio_filtro", value: card.id_coleta_cliente },
      { key: "cliente_filtro", value: card.id_cliente },
      { key: "loja_filtro", value: card.id_loja_coleta },
      { key: "estado_contato_filtro", value: card.estado_cliente },
      { key: "cidade_contato_filtro", value: card.cidade_cliente },
      { key: "estado_instalacao_filtro", value: card.uf_coleta },
      { key: "cidade_instalacao_filtro", value: card.cidade_coleta },
      { key: "etapa1_filtro", value: card.id_lista },
      { key: "urgencia_filtro", value: card.urgencia },
    ];

    for (const { key, value } of filtersToCheck) {
      if (businessFilters[key] && businessFilters[key] != "") {
        if (Array.isArray(businessFilters[key])) {
          if (!businessFilters[key].some((v: any) => v === value)) {
            return false;
          }
        } else {
          if (businessFilters[key] !== value) {
            return false;
          }
        }
      }
    }

    if (
      businessFilters.etiqueta_filtro &&
      !card?.etiquetas.some(
        (etiqueta: any) =>
          etiqueta.id_etiqueta_kanban === businessFilters.etiqueta_filtro,
      )
    ) {
      return false;
    }

    if (businessFilters.diasNaEtapa_filtro) {
      let dataCriacao = parseISO(card?.datahora_na_lista);
      dataCriacao = startOfDay(dataCriacao);
      const hoje = startOfDay(new Date());

      const diasNaEtapa = differenceInDays(hoje, dataCriacao);

      if (businessFilters.diasNaEtapa_filtro != diasNaEtapa) {
        return false;
      }
    }

    const dateFilters = [
      {
        key: "dataI_negocio_filtro",
        value: card?.data_criacao_coleta,
        operator: "<",
      },
      {
        key: "dataF_negocio_filtro",
        value: card?.data_criacao_coleta,
        operator: ">",
        adjust: 23,
      },
      {
        key: "dataI_proposta_filtro",
        value: getApprovedProposal(card)?.data_hora_aprovacao,
        operator: "<",
      },
      {
        key: "dataF_proposta_filtro",
        value: getApprovedProposal(card)?.data_hora_aprovacao,
        operator: ">",
        adjust: 23,
      },
    ];

    for (const { key, value, operator, adjust } of dateFilters) {
      if (!validateDateFilter(businessFilters[key], value, operator, adjust))
        return false;
    }

    const numericFilters = [
      {
        key: "min_potencia_filtro",
        value: getApprovedProposal(card)?.potenciaSistema_proposta,
        operator: "<",
      },
      {
        key: "max_potencia_filtro",
        value: getApprovedProposal(card)?.potenciaSistema_proposta,
        operator: ">",
      },
      {
        key: "min_valor_filtro",
        value: getApprovedProposal(card)?.valorTotal_proposta,
        operator: "<",
      },
      {
        key: "max_valor_filtro",
        value: getApprovedProposal(card)?.valorTotal_proposta,
        operator: ">",
      },
      { key: "min_consumo_filtro", value: card?.consumo_medio, operator: "<" },
      { key: "max_consumo_filtro", value: card?.consumo_medio, operator: ">" },
    ];

    for (const { key, value, operator } of numericFilters) {
      if (!validateNumericFilter(businessFilters[key], value, operator))
        return false;
    }

    if (businessFilters.qtd_ucs_filtro) {
      const qtdUcs = card?.qtd_ucs;
      if (qtdUcs == null || qtdUcs === "") return false;

      const filterValue = +businessFilters.qtd_ucs_filtro;
      const isEqual = businessFilters.igual_qtd_ucs_filtro == "true";

      if (isEqual) {
        if (+qtdUcs !== filterValue) return false;
      } else if (+qtdUcs < filterValue) {
        return false;
      }
    }

    // Filtros de pendências
    if (businessFilters.pendencia_filtro) {
      const pendenciaFiltro = businessFilters.pendencia_filtro;
      const pendencias = [
        { condition: card?.cpfcnpj_cliente, code: "1" },
        { condition: card?.email_cliente, code: "2" },
        { condition: card?.rua_cliente, code: "3" },
        { condition: card?.estadoCivil_cliente, code: "21" },
        { condition: card?.profissao_cliente, code: "22" },
        { condition: card?.latitude && card?.longitude, code: "4" },
        { condition: card?.classificacao_coleta, code: "23" },
        { condition: card?.tipoLigacao_coleta, code: "24" },
        { condition: card?.concessionaria_coleta, code: "25" },
        { condition: card?.grupo_coleta, code: "26" },
        { condition: card?.subgrupo_coleta, code: "27" },
        { condition: card?.uc_coleta_numero, code: "28" },
        { condition: card?.consumo_medio > 0, code: "29" },
        { condition: card?.propostas.length > 0, code: "5" },
        {
          condition: card?.propostas.some((p: any) => p.status_proposta === 1),
          code: "6",
        },
        { condition: card?.contratos.length > 0, code: "7" },
        {
          condition: card?.contratos.some((c: any) => c.status_contrato === 1),
          code: "8",
        },
        { condition: card?.notas.length > 0, code: "10" },
        { condition: +card?.pagamentosCliente > 0, code: "31" }, // Aprovado Pagamento Cliente
        { condition: card?.dataFinalizacaoVenda_coleta, code: "32" }, // Finalizado a Venda
        { condition: card?.agendamentos.length > 0, code: "9" },
        { condition: card?.data_conclusao_instalacao, code: "33" }, // Concluído a Instalação
        {
          condition:
            card.dataNascimento_cliente || card.data_aberturaEmpresa_cliente,
          code: "34",
        }, // Data Nascimento/Data Abertura
        { condition: card?.responsaveis?.["Administrativo"], code: "35" }, // Administrativo
        { condition: card?.responsaveis?.["Vendedor"], code: "36" }, // Vendedor
        { condition: card?.responsaveis?.["Gerente"], code: "37" }, // Gerente
        { condition: card?.responsaveis?.["Pré-Vendedor"], code: "38" }, // Pré-Vendedor
        { condition: card?.responsaveis?.["Instalador"], code: "39" }, // Instalador
        { condition: card?.responsaveis?.["Técnico"], code: "40" }, // Técnico
      ];

      for (const pendencia of pendencias) {
        if (pendencia.condition && pendenciaFiltro.includes(pendencia.code)) {
          return false;
        }
      }
    }

    if (businessFilters.linha_pendencias_filtro) {
      const linha_pendencias_filtro = businessFilters.linha_pendencias_filtro;
      const sequenciaPendencias_coleta = (
        card?.sequenciaPendencias_coleta?.split(",") || []
      ).splice(0, +card?.indexAtual_coleta - 1);
      if (
        linha_pendencias_filtro.some(
          (pendencia_card: string) =>
            !sequenciaPendencias_coleta.includes(pendencia_card),
        )
      ) {
        return false;
      }
    }

    if (businessFilters.linha_pendencia_atual_filtro) {
      const sequenciaPendencias_coleta =
        card?.sequenciaPendencias_coleta?.split(",") || [];
      if (
        sequenciaPendencias_coleta[+card?.indexAtual_coleta - 1] !=
        businessFilters.linha_pendencia_atual_filtro
      ) {
        return false;
      }
    }

    return true;
  }
  function validateDateFilter(
    filter: any,
    date: any,
    operator: any,
    adjust = 0,
  ) {
    if (!filter) return true;
    let dtFiltro = parseISO(filter);
    if (adjust) dtFiltro = addHours(dtFiltro, adjust);
    const dtCard = parseISO(date);
    return operator === "<" ? dtCard >= dtFiltro : dtCard <= dtFiltro;
  }
  function validateNumericFilter(filter: any, value: any, operator: any) {
    if (filter && !value) return false;
    if (!filter || value == null) return true;
    return operator === "<" ? +value >= +filter : +value <= +filter;
  }

  useEffect(() => {
    if (!funil) return;

    setKanbanLoaded(false);
    setLists([]);
    setOriginalLists([]);
    listarDadosKanban();
  }, [funil]);

  const listarDadosKanban = async () => {
    listarDadosFunil(funil).then((res) => {
      listarPendencias({ tipoNegocio_pendencia: res?.tipo_negocio_funil }).then(
        setPendencias_card,
      ),
        setDadosFunil(res);
    });

    const filters = Object.keys(businessFilters).reduce(
      (acc: any, curr: any) => {
        const valor = businessFilters[curr];
        return {
          ...acc,
          [curr]: Array.isArray(valor) ? valor?.join(",") : String(valor),
        };
      },
      funil == "0" ? { status_coleta: "= 100" } : {},
    );

    setIsLoadingTotalizadores(true);

    return Promise.all([
      getTotalizadores({
        funil: funil,
        id_usuario: session.id_usuario,
        filters,
      })
        .then(setTotalizadores)
        .catch((error) => {
          console.error("Erro ao carregar totalizadores:", error);
        })
        .finally(() => setIsLoadingTotalizadores(false)),
      listarKanban({
        funil: funil,
        id_usuario: session.id_usuario,
        filters,
      })
        .then((res: any) => {
          setOriginalLists((prev) =>
            applyKanbanListsResponse(res, prev, "id", "id_card"),
          );
          setLists((prev) =>
            applyKanbanListsResponse(res, prev, "id", "id_card"),
          );
        })
        .catch((error) => {
          console.error("Erro ao listar kanban:", error);
        })
        .finally(() => setKanbanLoaded(true)),
      listarTodosKanbans().then((res) => setTodosKanbans(res)),
    ]);
  };

  const reListarDadosKanban = async () => {
    if (funil) {
      try {
        listarDadosFunil(funil).then((res: any) => {
          setDadosFunil(res);
        });

        const filters = Object.keys(businessFilters).reduce(
          (acc: any, curr: any) => {
            const valor = businessFilters[curr];
            return {
              ...acc,
              [curr]: Array.isArray(valor) ? valor?.join(",") : String(valor),
            };
          },
          funil == "0" ? { status_coleta: "= 100" } : {},
        );

        setIsLoadingTotalizadores(true);

        await Promise.all([
          getTotalizadores({
            funil: funil,
            id_usuario: session.id_usuario,
            filters,
          })
            .then(setTotalizadores)
            .catch((error) => {
              console.error("Erro ao carregar totalizadores:", error);
            })
            .finally(() => setIsLoadingTotalizadores(false)),
          listarKanban({
            funil: funil,
            id_usuario: session.id_usuario,
            filters,
          })
            .then((res: any) => {
              setOriginalLists((prev) =>
                applyKanbanListsResponse(res, prev, "id", "id_card"),
              );
              setLists((prev) =>
                applyKanbanListsResponse(res, prev, "id", "id_card"),
              );
            })
            .catch((error) => {
              console.error("Erro ao relistar kanban:", error);
            })
            .finally(() => setKanbanLoaded(true)),
          listarTodosKanbans().then((res) => setTodosKanbans(res)),
        ]);
      } catch (error) {
        console.error("Erro em reListarDadosKanban:", error);
      }
    }
  };

  useEffect(() => {
    if (skipBusinessFiltersRelistRef.current) {
      skipBusinessFiltersRelistRef.current = false;
      return;
    }

    if (!businessFilters?.noRelist) {
      reListarDadosKanban();
    }
  }, [businessFilters]);

  const reListarDistribuidores = async () => {
    listarDistribuidoresNativos().then((res: any) => {
      setDistribuidores(res);
    });
  };

  return (
    <KanbanContext.Provider
      value={{
        lists,
        setLists,
        originalLists,
        setOriginalLists,
        listarDadosKanban,
        reListarDadosKanban,
        categoriasAnexos,
        reListarDistribuidores,
        documentosPersonalizados,
        funil,
        menuStack,
        dadosFunil,
        renameMenu,
        setDadosFunil,
        kanbanLoaded,
        docsPersonalizadosGerados,
        cidades,
        setCidades,
        clientes,
        estadosFiltro,
        estados: estadosFiltro,
        goBack,
        openMenu,
        setEstados: setEstadosFiltro,
        locks,
        locksResponsaveis,
        locksRetrocesso,
        categoriaslocksPermissoes,
        todosKanbans,
        businessFilters,
        setBusinessFilters,
        validateFilters,
        pendencias_card,
        menuOnView,
        resetMenu,
        setMenuOnView,
        totalizadores,
        cardsState,
        setCardsState,
        isLoadingTotalizadores,
      }}
    >
      {children}
    </KanbanContext.Provider>
  );
};

export const useKanbanContext = () => {
  return useContext(KanbanContext);
};