import {
  atualizarDadosKanban,
  criarEtapaFunil,
  enviar_email_notificacao,
  gerarTarefas,
  insereLogAutomacao,
  listarCardInfo,
  listarLocksResponsaveis,
  salvarLocks,
} from "@/requests/CRM/kanban";

import Button from "@/components/Forms/Button";
import ModalComponente from "@/components/Modal/ModalComponente";
import { Skeleton } from "@/components/ui/skeleton";
import { useKanban } from "@/hooks/useKanban";
import { listarUsuarios } from "@/requests/CRM/Dashboard/listarDashboard";
import {
  listarCamposGravados,
  listarCamposPersonalizados,
  listarCheckboxNegocio,
} from "@/requests/CRUD/CamposPersonalizados/listarCamposPersonalizados";
import {
  listarPendencias,
  verificaEtapaParalela,
} from "@/requests/CRUD/ColetaDados/cadastroColetaDados";
import { listarDocumentosGerados } from "@/requests/CRUD/DocumentosGerados/listarDocumentosGeradosPorIdColeta";
import { listarPerfil } from "@/requests/CRUD/Perfil/listarPerfil";
import { listarPerfis } from "@/requests/CRUD/Perfil/listarPerfis";
import { useAuth } from "@/src/contexts/authContext";
import BoardContext from "@/src/contexts/boardContext";
import { useKanbanContext } from "@/src/contexts/kanbanContext";
import { useScreenContext } from "@/src/contexts/ScreenContext";
import { useSocketContext } from "@/src/contexts/SocketContext";
import { GetForm } from "@/utils";
import { getArr } from "@/utils/helpers";
import { produce } from "immer";
import { useRouter } from "next/router";
import { useEffect, useRef, useState } from "react";
import { FieldValues } from "react-hook-form";
import { IoIosAddCircleOutline } from "react-icons/io";
import { toast } from "react-toastify";
import Swal from "sweetalert2";
import * as yup from "yup";
import List from "../List";
import FormLockEtapas from "../List/FormLockEtapas";

export default function Board({
  kanbanId,
  setLists,
  corListaKanban,
  canEditList,
}: any) {
  const [yupSchema, setYupSchema] = useState<
    yup.ObjectSchema<{}, yup.AnyObject, {}, "">
  >(yup.object().shape({}));
  const [camposPersonalizadosBd, setCamposPersonalizadosBd] = useState<any>();
  const [camposPersonalizadosGravacao, setCamposPersonalizadosGravacao] =
    useState<any>();
  const { handleSubmit, ...form } = GetForm(yupSchema, setYupSchema);
  let etapaDestiny = null as any;
  let idCardDestiny = null as any;
  const [dropped, setDropped] = useState(false);
  const [renderLists, setRenderLists] = useState<any>([]);
  const { isMobile } = useScreenContext();
  const [cardSelecionado, setCardSelecionado] = useState<any>();
  const { valuesSession, usuario, perfil } = useAuth();
  const { session } = valuesSession();
  const id_usuario = session.id_usuario;
  const [isLoading, setIsLoading] = useState(false);
  const [locksId, setLocksId] = useState<any[]>([]);
  const [locks_responsaveis, setLocks_responsaveis] = useState<any[]>([]);
  const [sheetModalOpen, setSheetModalOpen] = useState(false);
  const [isOpenCfgEtapa, setIsOpenCfgEtapa] = useState(false);
  const router = useRouter();
  const [pendencias, setPendencias] = useState<any>([]);
  const [docsPersonalizadosGerados, setDocsPersonalizadosGerados] =
    useState<any>([]);
  const { relistarPerfil, obterDadosSecao } = useAuth();
  const [perfis, setPerfis] = useState([]);
  const [usuarios, setUsuarios] = useState([]);
  //Pq as coisas tem que ser assim
  //pq o codigo tem que ter lógica se as melhores coisas da vida n tem sentido
  //pq a vida é assim

  let cardSelecionado2 = "";
  const {
    lists,
    todosKanbans,
    locks,
    dadosFunil,
    listarDadosKanban,
    reListarDadosKanban,
    categoriasAnexos,
    documentosPersonalizados,
    locksRetrocesso,
    kanbanLoaded,
    setOriginalLists,
  } = useKanbanContext();
  let listasExemplo: any = lists;
  const { publish } = useKanban();
  const { notificarNotificacao } = useSocketContext();
  const barraEtapas = useRef(null);

  useEffect(() => {
    listarUsuarios().then((res) => {
      setUsuarios(res);
    });
    listarPerfis().then((res) => {
      setPerfis(res);
    });
    listarCamposPersonalizados().then((res) =>
      setCamposPersonalizadosBd(
        res.filter((a: any) => a.status_campo_personalizado == "1"),
      ),
    );
    listarCamposGravados().then(setCamposPersonalizadosGravacao);
    listarDocumentosGerados().then(setDocsPersonalizadosGerados);
    listarLocksResponsaveis().then(setLocks_responsaveis);
  }, []);
  const handleDroppedCard = () => {
    setDropped(!dropped);
  };
  const isStandalone =
    window.matchMedia("(display-mode: standalone)").matches ||
    (window.navigator as any).standalone;

  async function createNewStep(data: any) {
    const newStep = {
      titulo_etapa_funil: data.titulo_etapa_funil,
      criavel_etapa_funil: "0",
      validade_etapa_funil: data.validade_etapa_funil,
      grupo_etapa_funil: kanbanId,
      index_etapa_funil: lists.length,
      locks_id: data.locks,
      locks_retrocesso_id: data.locks_retrocesso,
      camposPersonalizadosEditLock: data.camposPersonalizadosEditLock,
      camposPersonalizadosLock: data.camposPersonalizadosLock,
      locksPermissoes_id: data.locksPermissoes,
      locksPendencias: data.pendenciasLock,
      cor_etapa_funil: data.cor_etapa_funil,
      locks_responsaveis_id: data.locks_responsaveis,
      status_etapa_funil: "1",
      anexos_locks: data.anexosLock,
      docks_locks: data.documentosLock,
      listCanSendFor: data.listCanSendFor,
      permite_mover_cards_etapa_funil: data.permite_mover_cards_etapa_funil,
    };
    return criarEtapaFunil(newStep).then(relistarPerfil);
  }

  function atualizarKanban() {
    setLists((lists: any) => {
      lists.map((list: any, index: number) => {
        let newCard = list.cards.map((card: any, index2: any) => {
          const updatedCard = {
            ...card,
            index_card: index2,
          };
          return updatedCard;
        });
        return {
          ...list,
          cards: newCard,
          selectedCard: cardSelecionado2,
        };
      });

      return lists;
    });
  }

  const onSubmitFormLockEtapas = async (data: FieldValues) => {
    setIsLoading(true);

    const { ...rest } = data;
    const toastPromise = new Promise((resolve, reject) => {
      salvarLocks(rest)
        .then((res) =>
          listarDadosKanban().then(() => {
            resolve(res);
          }),
        )
        .catch((err) => reject(err));
    });

    return toast
      .promise(toastPromise, {
        pending: {
          render(data: any) {
            return "Aguarde";
          },
        },
        success: {
          render(data: any) {
            return data.data;
          },
          theme: "light",
        },
        error: {
          render(data: any) {
            return data.data;
          },
        },
      })
      .finally(() => setIsLoading(false));
  };
  const [permissionsState, setPermissionsState] = useState<any>();

  async function validarChecklist(
    camposPersonalizadosBd: any[],
    selectedCard: any,
    etapaDestino: any,
  ): Promise<string[]> {
    const erros: string[] = [];

    const res = await listarCheckboxNegocio({
      id_negocio: selectedCard.id_coleta_cliente,
    });

    const checklist = res.filter((b: any) =>
      getArr(
        etapaDestino.camposPersonalizadosLock,
        selectedCard.tipoNegocio_coleta,
      ).includes(b.id_campo_personalizado),
    );

    const qtdTotalCheck = checklist.map((a: any) => ({
      id: a.id_campo_personalizado,
      qtd: a.qtd_checklist_personalizado,
    }));

    const hasChecklist = checklist.map((grupo: any) =>
      grupo.descricao_checklist_personalizado.filter(
        (a: any) =>
          a.codNegocio_gravacao_checklist_personalizado ===
          selectedCard.id_coleta_cliente,
      ),
    );

    hasChecklist.forEach((grupoFiltrado: any, index: any) => {
      if (qtdTotalCheck[index].qtd !== grupoFiltrado.length) {
        erros.push(qtdTotalCheck[index].id);
      }
    });

    const flatted = hasChecklist.flat();
    if (flatted.length > 0) {
      hasChecklist.map((check: any) => {
        check.map((item: any) => {
          const t = item.subOpcoes_checklist_personalizado
            ? item.subOpcoes_checklist_personalizado
                .split(",")
                .map((o: string) => o.trim())
                .filter((o: string) => o !== "")
            : [];

          if (t.length > 0) {
            if (
              item.opcao_escolhida_gravacao_checklist_personalizado === "" ||
              item.marcado_gravacao_checklist_personalizado === ""
            ) {
              erros.push(item.codCampo_checklist_personalizado);
            }
          } else {
            if (item.marcado_gravacao_checklist_personalizado === "") {
              erros.push(item.codCampo_checklist_personalizado);
            }
          }
        });
      });
    } else {
      checklist.map((chk: any) => erros.push(chk.id_campo_personalizado));
    }

    if (erros.length > 0) {
    }

    return erros;
  }

  let newListSet: any = renderLists;
  let statePermissions: any = [];

  async function move(
    fromList: any,
    toList: any,
    from: any,
    to: any,
    item: any,
    cardId?: any,
  ) {
    const newListSet = renderLists;
    if (!newListSet[fromList].cards[from]) {
      return;
    }
    const idDoCard = item?.data?.id ?? cardId;

    // localizar o card pelo id (primeiro tenta na lista informada)
    let selectedCardIndex = -1;
    let selectedCard: any = null;
    if (idDoCard) {
      if (newListSet[fromList]) {
        selectedCardIndex = newListSet[fromList].cards.findIndex(
          (c: any) => c && c.id === idDoCard,
        );
        if (selectedCardIndex !== -1) {
          selectedCard = newListSet[fromList].cards[selectedCardIndex];
        }
      }

      // se não encontrou na lista indicada, procurar em todas as listas (card pode ter sido removido)
      if (selectedCardIndex === -1) {
        for (const key of Object.keys(newListSet)) {
          const idx = newListSet[key].cards.findIndex(
            (c: any) => c && c.id === idDoCard,
          );
          if (idx !== -1) {
            selectedCardIndex = idx;
            selectedCard = newListSet[key].cards[idx];
            fromList = Number(key); // atualiza de onde o card realmente veio
            break;
          }
        }
      }
    } else {
      // fallback: usar o índice que foi passado (compatibilidade)
      selectedCardIndex = from;
      selectedCard = newListSet[fromList]?.cards[from];
    }

    // se não encontrou, aborta com log
    if (selectedCardIndex === -1 || !selectedCard) {
      console.warn("move: card não encontrado", {
        fromList,
        from,
        idDoCard,
        snapshotCards: newListSet[fromList]?.cards?.map((c: any) => c?.id),
      });
      return;
    }

    // Busca os dados mais atuais do card para não validar locks com snapshot defasado.
    if (idDoCard) {
      try {
        const cardAtualizado = await listarCardInfo({ id_card: idDoCard });

        if (cardAtualizado && typeof cardAtualizado === "object") {
          selectedCard = {
            ...selectedCard,
            ...cardAtualizado,
          };

          if (newListSet[fromList]?.cards?.[selectedCardIndex]) {
            newListSet[fromList].cards[selectedCardIndex] = {
              ...newListSet[fromList].cards[selectedCardIndex],
              ...cardAtualizado,
            };
          }
        }
      } catch (error) {
        console.warn("move: erro ao atualizar dados do card", {
          idDoCard,
          error,
        });
      }
    }

    if (item != undefined) {
      idCardDestiny = item.data.id;
    }

    const etapaSaida = newListSet[fromList];
    const etapaDestino = newListSet[toList];

    const responsaveis = item?.data?.responsaveis || {};
    const idsResponsaveis = Object.values(responsaveis).filter(
      (id) => id !== null,
    );

    //Trecho comentando pois o Rafael da Amaro sugeriu permitir mover o card mesmo com usuarios inativos

    // const invalido = usuarios.filter((usuario: any) => {
    //   return (
    //     idsResponsaveis.includes(usuario.id_usuario) &&
    //     usuario.status_usuario != "1"
    //   );
    // });

    // if (invalido.length > 0) {
    //   const nomesInativos = invalido
    //     .map((usuario: any) => usuario.nome_usuario)
    //     .join(", ");
    //   Swal.fire({
    //     title: "Ação não Permitida!",
    //     html: `Os seguintes responsáveis estão inativos: <br> ${nomesInativos}`,
    //     icon: "warning",
    //   });
    //   return;
    // }

    if (etapaSaida.id === etapaDestino.id) return;
    const movimArr = getArr(
      etapaSaida?.movimEntreEtapas,
      selectedCard.tipoNegocio_coleta,
    );
    const contemValor =
      !etapaSaida.movimEntreEtapas ||
      (etapaSaida.permite_mover_cards_etapa_funil == 1 &&
        movimArr.length === 0) ||
      movimArr.includes(etapaDestino.id);

    if (!contemValor) {
      return Swal.fire(
        "Ação não Permitida!",
        `O card não pode ser movido:<br>de '${etapaSaida.title}'<br>para '${etapaDestino.title}'!`,
        "warning",
      );
    }

    // const selectedCard = newListSet[fromList].cards.filter(Boolean)[from];

    const locksAnexosPermissions: any[] = [];
    const locksResponsaveis: any[] = [];
    const locksCamposPermissions: any[] = [];
    const locksDocumentosPermissions: any[] = [];
    const lockPermissions: any[] = [];
    const lockPendencias: any[] = [];
    const lockRetrocesso: any[] = [];

    if (selectedCard?.propostas.length != 0)
      //LOCKS PARA RETROCESSO DO CARD
      lockRetrocesso.push("1");

    if (
      selectedCard?.propostas.length != 0 &&
      selectedCard?.propostas.some(
        (proposta: any) => proposta.status_proposta == 1,
      )
    )
      lockRetrocesso.push("2");
    // conclusão instalação = 10
    // pagamento instalação = 11

    // if (!selectedCard.dataPagamentoCliente_coleta) lockRetrocesso.push(5);
    if (!(selectedCard.qtd_pagamentosCliente != 0)) lockRetrocesso.push(5);
    if (!selectedCard.dataFinalizacaoVenda_coleta) lockRetrocesso.push(6);
    if (selectedCard.status_coleta == 10) lockRetrocesso.push(8);
    if (selectedCard.status_coleta == 11) lockRetrocesso.push(9);

    if (selectedCard.contratos.length != 0) lockRetrocesso.push("3");

    if (
      selectedCard.contratos.length != 0 &&
      selectedCard.contratos.some(
        (contrato: any) => contrato.status_contrato == 1,
      )
    )
      lockRetrocesso.push("4");

    if (selectedCard.agendamentos != 0) lockRetrocesso.push("7");

    //LOCKS PADRAO
    if (selectedCard.cpfcnpj_cliente) lockPermissions.push("1");
    if (selectedCard.email_cliente) lockPermissions.push("2");

    if (selectedCard.cep_cliente || selectedCard.cepEmpresa_cliente)
      lockPermissions.push("3");
    if (selectedCard.rg_cliente) lockPermissions.push("36");
    if (selectedCard.estadoCivil_cliente) lockPermissions.push("21");
    if (selectedCard.profissao_cliente) lockPermissions.push("22");
    if (selectedCard.latitude && selectedCard.longitude)
      lockPermissions.push("4");
    if (selectedCard.classificacao_coleta) lockPermissions.push("23");
    if (selectedCard.tipoLigacao_coleta) lockPermissions.push("24");
    if (selectedCard.concessionaria_coleta) lockPermissions.push("25");
    if (selectedCard.grupo_coleta) lockPermissions.push("26");
    if (selectedCard.disjuntor_coleta) lockPermissions.push("35");
    if (selectedCard.subgrupo_coleta) lockPermissions.push("27");
    const lockTipoEdificacao = locks.find(
      (e: any) => e.nome_lock === "Tipo de Edificação",
    )?.id_lock;
    if (selectedCard.tipo_edificacao_coleta && lockTipoEdificacao) {
      lockPermissions.push(String(lockTipoEdificacao));
    }
    if (selectedCard.uc_coleta_numero) lockPermissions.push("28");
    if (selectedCard.responsaveis["Administrativo"])
      locksResponsaveis.push("1");
    if (selectedCard.responsaveis["Vendedor"]) locksResponsaveis.push("2");
    if (selectedCard.responsaveis["Gerente"]) locksResponsaveis.push("3");
    if (selectedCard.responsaveis["Pré-Vendedor"]) locksResponsaveis.push("4");
    if (selectedCard.responsaveis["Instalador"]) locksResponsaveis.push("5");
    if (selectedCard.responsaveis["Técnico"]) locksResponsaveis.push("6");
    if (selectedCard.responsaveis["Supervisor"]) locksResponsaveis.push("7");
    if (
      selectedCard.tipoPessoa_cliente == "F" &&
      selectedCard.dataNascimento_cliente != null &&
      selectedCard.dataNascimento_cliente != "0000-00-00"
    )
      lockPermissions.push("34");
    if (
      selectedCard.tipoPessoa_cliente == "J" &&
      selectedCard.data_aberturaEmpresa_cliente != null &&
      selectedCard.data_aberturaEmpresa_cliente != "0000-00-00"
    )
      lockPermissions.push("34");
    if (selectedCard.consumo_medio && selectedCard.consumo_medio > 0)
      lockPermissions.push("29");
    if (
      selectedCard.propostas.length != 0 &&
      selectedCard.propostas.some(
        (proposta: any) => proposta.status_proposta != 3,
      )
    )
      lockPermissions.push("5");
    if (
      selectedCard.propostas.length != 0 &&
      selectedCard.propostas.some(
        (proposta: any) => proposta.status_proposta == 1,
      )
    )
      lockPermissions.push("6"); // 1
    if (selectedCard.contratos.length != 0) lockPermissions.push("7");
    if (
      selectedCard.contratos.length != 0 &&
      selectedCard.contratos.some(
        (contrato: any) => contrato.status_contrato == 1,
      )
    )
      lockPermissions.push("8"); // 1
    // if (selectedCard.notas.length != 0) lockPermissions.push("10");
    if (selectedCard.data_instalacao) lockPermissions.push("9");
    // if (selectedCard.dataPagamentoCliente_coleta) lockPermissions.push("31");
    if (selectedCard.qtd_pagamentosCliente != 0) lockPermissions.push("31");
    if (selectedCard.dataFinalizacaoVenda_coleta) lockPermissions.push("32");
    if (selectedCard.data_conclusao_instalacao) lockPermissions.push("33");
    if (!selectedCard.ids_follow_ups_pendentes) lockPermissions.push("10");
    if (+selectedCard?.qtd_follow_ups > 0) lockPermissions.push("11");

    if (selectedCard.id_lista_card == "1") lockPermissions.push("*");
    const anexosLock = selectedCard.anexosLock ?? "";

    getArr(etapaDestino.anexosLock, selectedCard.tipoNegocio_coleta).map(
      (e: any) => {
        if (!anexosLock.split(",").some((res: any) => res == e)) {
          locksAnexosPermissions.push(e);
        }
      },
    );

    const sequenciaColeta = selectedCard?.sequenciaPendencias_coleta.split(",");
    const indexAtual_coleta = selectedCard?.indexAtual_coleta;

    if (etapaDestino.locksPendencias) {
      getArr(etapaDestino.locksPendencias, selectedCard.tipoNegocio_coleta).map(
        (a: any) => {
          const indexEncontrado = sequenciaColeta?.findIndex(
            (item: any) => item === a,
          );
          const correcaoIndex = indexEncontrado + 1;

          if (
            selectedCard?.ids_pendencias_negocio
              ?.split(",")
              ?.includes(String(a))
          ) {
            if (
              Number(indexAtual_coleta) < Number(correcaoIndex) ||
              Number(indexAtual_coleta) === Number(correcaoIndex)
            ) {
              lockPendencias.push(a);
            }
          }
        },
      );
    }
    if (etapaDestino.camposPersonalizadosLock.length > 0) {
      await (
        await validarChecklist(
          camposPersonalizadosBd,
          selectedCard,
          etapaDestino,
        )
      )?.map((a: any) => locksCamposPermissions.push(a));
    }

    const checklist = camposPersonalizadosBd
      ?.filter((b: any) => b.tipo_campo_personalizado === "5")
      .map((a: any) => a.id_campo_personalizado);

    const campoBd = camposPersonalizadosBd
      .filter((a: any) => a.tipo_campo_personalizado !== "5")
      .map((a: any) => a.id_campo_personalizado);

    const campos = camposPersonalizadosGravacao?.filter(
      (a: any) =>
        a.codNegocio_gravacao_personalizado == selectedCard.id_coleta_cliente,
    );
    const camposMap = campos.map((a: any) => a.codCampo_gravacao_personalizado);

    const campoBdNaoGravado = campoBd.filter(
      (a: any) => !camposMap.includes(a),
    );

    getArr(
      etapaDestino.camposPersonalizadosLock,
      selectedCard.tipoNegocio_coleta,
    ).map(
      (a: any) =>
        campoBdNaoGravado.includes(a) && locksCamposPermissions.push(a),
    );

    if (campos.length > 0) {
      const camposNaoGravados = campos
        ?.filter(
          (a: any) =>
            !checklist.includes(a?.codCampo_gravacao_personalizado) &&
            a.dados_gravacao_personalizado === "",
        )
        .map((b: any) => b.codCampo_gravacao_personalizado);

      camposNaoGravados.map(
        (a: any) =>
          getArr(
            etapaDestino.camposPersonalizadosLock,
            selectedCard.tipoNegocio_coleta,
          ).includes(a) && locksCamposPermissions.push(a),
      );
    } else {
      getArr(
        etapaDestino.camposPersonalizadosLock,
        selectedCard.tipoNegocio_coleta,
      ).map(
        (a: any) => !checklist.includes(a) && locksCamposPermissions.push(a),
      );
    }
    const docsGerados = docsPersonalizadosGerados.filter(
      (a: any) =>
        a.codColeta_documento_gerado == selectedCard.id_coleta_cliente,
    );
    const documentosLock = selectedCard.documentosLock || [];
    getArr(
      etapaDestino.documentosLock,
      selectedCard.tipoNegocio_coleta,
    ).forEach((e: any) => {
      const hasDocument = docsGerados.some(
        (doc: any) => doc.codModelo_documento_gerado === e,
      );

      if (!hasDocument) {
        locksDocumentosPermissions.push(e);
      }
    });
    const mergeArraysLocks = [
      ...getArr(newListSet[toList].locks, "*"),
      ...getArr(newListSet[toList].locks, selectedCard.tipoNegocio_coleta),
    ];

    const isAllLocksIn = mergeArraysLocks.every((lock: string) =>
      lockPermissions.includes(lock),
    );

    const commonLocks = getArr(
      newListSet[toList].locks_retrocesso,
      selectedCard.tipoNegocio_coleta,
    ).filter((lock: string) => lockRetrocesso.includes(lock));

    if (
      commonLocks.length > 0 && // Verifica se existem IDs em comum
      etapaSaida.index_lista_kanban > etapaDestino.index_lista_kanban
    ) {
      let errorMsg = ``;

      errorMsg +=
        "<b>Já possui:</b> <br>" +
        commonLocks
          .map(
            (lock: string) =>
              locksRetrocesso.find((e) => e.id_lock_retrocesso == lock)
                ?.nome_lock_retrocesso,
          )
          .join("<br>");

      Swal.fire({
        title: `Ação não Permitida de Retrocesso do <span class="highlight">Negócio!</span>`,
        html: `
              <style>
                .swal2-title {
                  font-size: 20px; /* Ajuste o tamanho do texto do título aqui */
                }
                .highlight {
                  font-size: 25px; /* Ajuste o tamanho do texto "Negócio!" aqui */
                  font-weight: bold; /* Opcional: adicione negrito ao texto */
                }
              </style>
              <div>${errorMsg}</div>
            `,
        icon: "warning",
      });
      return;
    }
    statePermissions = [
      {
        locks: lockPermissions,
        locksAnexos: locksAnexosPermissions[0],
      },
    ];
    setPermissionsState({
      locks: lockPermissions,
      locksAnexos: locksAnexosPermissions[0],
    });
    const locksResponsaveisNotIn = lists[toList].locks_responsaveis.filter(
      (lock: string) => !locksResponsaveis.includes(lock),
    );

    if (
      !isAllLocksIn ||
      lockPendencias[0] ||
      locksAnexosPermissions[0] ||
      locksDocumentosPermissions[0] ||
      locksCamposPermissions[0] ||
      locksResponsaveisNotIn[0]
    ) {
      let errorMsg = ``;
      const locksNotIn = mergeArraysLocks.filter(
        (lock: string) => !lockPermissions.includes(lock),
      );

      if (locksNotIn[0]) {
        errorMsg +=
          "<b>Não possui:</b> <br>" +
          locksNotIn
            .map(
              (lock: string) =>
                locks.find((e) => e.id_lock == lock)?.nome_lock +
                `${lock == "10" ? ` ID ${selectedCard?.ids_follow_ups_pendentes} está pendente` : ""}`,
            )
            .join("<br>");
      }

      if (locksResponsaveisNotIn[0]) {
        errorMsg += errorMsg ? "<br>" : "";

        errorMsg +=
          "<b>Não possui Responsaveis:</b> <br>" +
          locksResponsaveisNotIn
            .map(
              (lock: string) =>
                locks_responsaveis.find((e) => e.id_lock == lock)?.nome_lock,
            )
            .join("<br>");
      }

      if (locksAnexosPermissions[0]) {
        errorMsg += errorMsg ? "<br>" : "";

        errorMsg +=
          "<b>Não possui Anexos:</b> <br>" +
          locksAnexosPermissions
            .map(
              (lock: string) =>
                categoriasAnexos.find((e) => e.id_anexo_crm == lock)
                  ?.identificacao_cfg_anexo,
            )
            .join("<br>");
      }
      if (lockPendencias[0]) {
        errorMsg += errorMsg ? "<br>" : "";

        errorMsg +=
          "<b>Não possui a pendencia concluída:</b> <br>" +
          lockPendencias
            .map(
              (lock: string) =>
                pendencias.find((e: any) => e.id_pendencia == lock)
                  ?.nome_pendencia,
            )
            .join("<br>");
      }

      if (locksDocumentosPermissions[0]) {
        errorMsg += errorMsg ? "<br>" : "";

        errorMsg +=
          "<b>Não possui Documentos:</b> <br>" +
          locksDocumentosPermissions
            .map(
              (lock: string) =>
                documentosPersonalizados.find(
                  (e) => e.id_documento_personalizado == lock,
                )?.nome_documento_personalizado,
            )
            .join("<br>");
      }
      if (locksCamposPermissions[0]) {
        errorMsg += errorMsg ? "<br>" : "";

        const locksUnicos = [...new Set(locksCamposPermissions)];

        errorMsg +=
          "<b>Campos Personalizados Não Informados:</b> <br>" +
          locksUnicos
            .map(
              (lock: string) =>
                camposPersonalizadosBd.find(
                  (e: any) => e.id_campo_personalizado == lock,
                )?.nome_campo_personalizado,
            )
            .join("<br>");
      }

      Swal.fire({
        title: `Ação não Permitida!`,
        html: `
          <style>
            .swal2-title {
              font-size: 20px; /* Ajuste o tamanho do texto do título aqui */
            }
            .highlight {
              font-size: 25px; /* Ajuste o tamanho do texto "Negócio!" aqui */
              font-weight: bold; /* Opcional: adicione negrito ao texto */
            }
          </style>
          <div>${errorMsg}</div>
        `,
        icon: "warning",
      });
    } else {
      // Enviar email Notificação
      const notificaces_email = JSON.parse(
        newListSet[toList].notificaces_email,
      );

      if (notificaces_email && notificaces_email.length > 0) {
        const id_coleta_cliente = selectedCard.id_coleta_cliente;

        const dataNotifEmail: any = {
          id_coleta_cliente: id_coleta_cliente,
          notificaces_email: notificaces_email,
          nome_usuario: usuario.nome_usuario,
          // Usado no "Usuário que Movimentou" das notificações da Central
          id_usuario: usuario.id_usuario,
          // Etapa de onde o card saiu, gravada na notificação da Central
          etapa_origem_id: etapaSaida?.id_etapa_funil,
          nome_projeto: selectedCard.nome_negocio_coleta,
          data_projeto: selectedCard.datahora,
        };

        const propostaAprovada = selectedCard.propostas.find(
          (proposta: any) => proposta.status_proposta == 1,
        );

        if (propostaAprovada) {
          dataNotifEmail.qtd_modulos =
            propostaAprovada.modulosDigitado_proposta;
          dataNotifEmail.potencia_modulos =
            propostaAprovada.potencia_modulo_proposta;
          dataNotifEmail.potencia_inversores =
            propostaAprovada.potencia_inversores_proposta;
          dataNotifEmail.kit_proposta = propostaAprovada.kit_proposta;
        }

        enviar_email_notificacao(dataNotifEmail);
      }
      etapaDestiny = newListSet[toList];
      setCardSelecionado(selectedCard);
      // Dentro do move, antes de chamar processNextAutomations

      await processNextAutomations(selectedCard, etapaDestiny, {
        from,
        fromList,
        to,
        toList,
      });
      const tarefasGeradas = item["data"]["tarefas_geradas"];

      const tarefasGeradasIds = tarefasGeradas?.map(
        (tarefa: any) => tarefa.automacao_tarefa_gerada,
      );
      const automacoesTarefas = etapaDestino["automacoes_tarefas"];
      const tarefasNaoGeradas = automacoesTarefas.filter(
        (tarefa: any) =>
          !tarefasGeradasIds?.includes(tarefa.id_automacao_tarefa),
      );

      if (etapaDestino["automacoes_tarefas"].length > 0) {
        if (tarefasNaoGeradas.length > 0) {
          Swal.fire({
            title: `Tarefas Não Geradas!`,
            html: `
              <style>
                .swal2-title {
                  font-size: 20px; /* Ajuste o tamanho do texto do título aqui */
                }
                .highlight {
                  font-size: 25px; /* Ajuste o tamanho do texto "Negócio!" aqui */
                  font-weight: bold; /* Opcional: adicione negrito ao texto */
                }
              </style>
              <div>O card possui tarefas pendentes de geração da automação numero: ${tarefasNaoGeradas.map((tarefas: any) => tarefas.id_automacao_tarefa)}!</div>
            `,
            icon: "warning",
            showConfirmButton: true,
            showCancelButton: true,
            confirmButtonText: "Gerar Tarefas",
            cancelButtonText: "Fechar",
          }).then(async (result) => {
            if (result.isConfirmed) {
              await createTask(tarefasNaoGeradas, selectedCard);
            }
          });
        } else {
          Swal.fire({
            title: `Tarefas Já Existentes!`,
            html: `
              <style>
                .swal2-title {
                  font-size: 20px; /* Ajuste o tamanho do texto do título aqui */
                }
                .highlight {
                  font-size: 25px; /* Ajuste o tamanho do texto "Negócio!" aqui */
                  font-weight: bold; /* Opcional: adicione negrito ao texto */
                }
              </style>
              <div>Este card já possui tarefa(s) vinculada(s) a esta(s) automação(ões). Finalize a(s) tarefa(s) pendente(s) ou ajuste o fluxo de tarefas antes de prosseguir.</div>
            `,
            icon: "success",
            showCancelButton: true,
            cancelButtonText: "Fechar",
          });
        }
      }
    }
  } // <- essa dependência garante que a função seja atualizada quando `lists` mudar

  async function processNextAutomations(
    card: any,
    currentListId: any,
    { from, fromList, to, toList }: any,

    automacao = 0,
    triedLists = new Set(),
    fromID?: any,
  ) {
    if (!currentListId) {
      return;
    }
    triedLists.add(currentListId.id);

    const nextStep = await getStepParalel(
      card,
      currentListId,
      automacao,
      {
        from,
        fromList,
        to,
        toList,
      },
      fromID,
    );

    if (nextStep && !triedLists.has(nextStep.etapaDestino)) {
      const realFromIndex = from;

      let toIndex = null as any;
      let fromIndex = null as any;
      let fromID = null as any;
      let realToIndex = null as any;

      if (nextStep.funilDestino === dadosFunil?.id_funil) {
        fromIndex = Object.keys(newListSet).find(
          (key: any) => newListSet[key].id == currentListId.id,
        );
        fromID = newListSet[fromIndex].id;
        toIndex = Object.keys(newListSet).find(
          (key: any) => newListSet[key].id === nextStep.etapaDestino,
        );
        realToIndex = newListSet[Number(toIndex)].cards.length;
      } else {
        const funilList = todosKanbans.find(
          (t: any) => t.id_funil === nextStep.funilDestino,
        );

        const idFunil =
          currentListId.grupo_etapa_funil ?? currentListId.id_funil;

        const funilListFrom = todosKanbans.find(
          (t: any) => t.id_funil == idFunil,
        );

        fromIndex = funilListFrom.listas_kanban.findIndex(
          (lista: any) => currentListId.id === lista.id_etapa_funil,
        );

        fromID = funilListFrom.listas_kanban.find(
          (lista: any) => currentListId.id === lista.id_etapa_funil,
        ).id_etapa_funil;

        toIndex = funilList.listas_kanban.findIndex(
          (lista: any) =>
            Number(lista.id_etapa_funil) === Number(nextStep.etapaDestino),
        );

        realToIndex = funilList.listas_kanban[toIndex].cards_kanban.length;
      }

      if (!toIndex) return console.error("toIn");
      if (fromIndex && toIndex) {
        setTimeout(async () => {
          const automacao = 1;
          await processNextAutomations(
            card,
            {
              ...todosKanbans.find(
                (t: any) => t.id_funil === nextStep.funilDestino,
              ).listas_kanban[toIndex],
              id: todosKanbans.find(
                (t: any) => t.id_funil === nextStep.funilDestino,
              ).listas_kanban[toIndex].id_etapa_funil,
            },
            {
              from: +realFromIndex,
              fromList: +fromIndex,
              to: +realToIndex,
              toList: +toIndex,
            },
            automacao,
            triedLists,
            fromID,
          );
        }, 1000);
      }
    }
  }
  const toArr = (v: any): string[] => {
    if (Array.isArray(v)) return v.map(String).filter(Boolean);
    if (typeof v === "string")
      return v
        .split(",")
        .map((s) => s.trim())
        .filter(Boolean);
    return v == null ? [] : [String(v)];
  };

  const insertAt = (arr: string[], index: number, value: string) => {
    const idx = Math.max(0, Math.min(index, arr.length));
    arr.splice(idx, 0, value);
  };

  const getEtapaCardCount = (etapa: any) => {
    if (etapa?.qtd_cards != null && etapa?.qtd_cards !== "") {
      return Number(etapa.qtd_cards);
    }
    return toArr(etapa?.ids_cards).length;
  };

  const adjustQtdCardsAfterMove = (
    draft: any,
    fromList: number,
    toList: number,
  ) => {
    draft[fromList].qtd_cards = Math.max(
      0,
      getEtapaCardCount(draft[fromList]) - 1,
    );
    draft[toList].qtd_cards = getEtapaCardCount(draft[toList]) + 1;
  };

  const produceLists = <T,>(
    prevLists: T[],
    recipe: (draft: T[]) => void,
  ): T[] => produce(prevLists, recipe) as T[];

  const syncContextListsAfterMove = (updatedRenderLists: any[]) => {
    setLists((prevLists: any[]) =>
      produceLists(prevLists, (draft) => {
        updatedRenderLists.forEach((etapaAtualizada: any) => {
          const idx = draft.findIndex(
            (etapa) => String(etapa.id) === String(etapaAtualizada.id),
          );
          if (idx === -1) return;
          draft[idx].ids_cards = etapaAtualizada.ids_cards;
          draft[idx].qtd_cards = etapaAtualizada.qtd_cards;
        });
      }),
    );
  };

  const applyMoveOnDraft = (
    draft: any,
    fromList: number,
    toList: number,
    from: number,
    to: number,
    selectedCard: any,
  ) => {
    draft[fromList].cards = draft[fromList]?.cards?.filter(Boolean);
    const dragged = draft[fromList]?.cards?.find(
      (card: any) => card.id == selectedCard.id,
    );
    if (!dragged) return false;

    draft[fromList].cards.splice(from, 1);
    const fromClean = toArr(draft[fromList].ids_cards).filter(
      (id) => id !== String(selectedCard.id),
    );
    draft[fromList].ids_cards = fromClean.join(",");

    draft[toList].cards.splice(to, 0, dragged);
    const toClean = toArr(draft[toList].ids_cards).filter(
      (id) => id !== String(selectedCard.id),
    );
    insertAt(toClean, to, String(selectedCard.id));
    draft[toList].ids_cards = toClean.join(",");

    adjustQtdCardsAfterMove(draft, fromList, toList);
    return true;
  };

  const getStepParalel = async (
    selectedCard: any,
    etapaDestiny: any,
    automacao: any,
    { from, fromList, to, toList }: any,
    fromID?: any,
  ) => {
    if (
      from === undefined ||
      fromList === undefined ||
      to === undefined ||
      toList === undefined
    )
      return;

    let funilEncontrado = todosKanbans.find((kanban: any) =>
      kanban.listas_kanban.some((lista: any) =>
        lista.cards_kanban.some(
          (card: any) => card.id_card === selectedCard.id,
        ),
      ),
    );
    const etapaFrom = funilEncontrado.listas_kanban[fromList].id_etapa_funil;
    const etapaTo = funilEncontrado.listas_kanban[toList].id_etapa_funil;

    if (etapaDestiny.paralelizar_etapa_funil) {
      const etapaParalela = await verificaEtapaParalela({
        etapaDestino: etapaDestiny.id,
        tipo_negocio: selectedCard.tipoNegocio_coleta,
      });
      if (etapaParalela && etapaParalela.etapaDestino !== "0") {
        const idColeta = selectedCard.id_coleta_cliente;

        const funilDestino = todosKanbans.find(
          (kanban: any) =>
            kanban.id_funil == etapaParalela.funilDestino &&
            kanban.id_funil != funilEncontrado.id_funil,
        );

        if (funilDestino) {
          const existeNoDestinoMesmaColeta = funilDestino.listas_kanban.some(
            (lista: any) =>
              lista.cards_kanban.some(
                (card: any) =>
                  card.id_coleta_card === idColeta &&
                  card.id_card !== selectedCard.id,
              ),
          );

          if (existeNoDestinoMesmaColeta) {
            toast.error(
              "Já existe um card com o mesmo projeto para o fluxo destino!",
            );
            setRenderLists((prevLists: any) => {
              const updatedLists = produce(prevLists, (draft: any) => {
                draft[fromList].cards = draft[fromList].cards.filter(Boolean);
                const dragged = draft[fromList].cards[from];
                if (!dragged) {
                  console.warn("Card a ser movido está undefined", {
                    fromList,
                    from,
                  });
                  return;
                }
                draft[fromList].cards.splice(from, 1);
                draft[toList].cards.splice(to, 0, dragged);
              });
              newListSet = updatedLists;
              return updatedLists;
            });
            const params = {
              etapas: lists,
              selectedCard: selectedCard,
              listaDestino: etapaDestiny,
              idCardDestino: selectedCard.id,
              id_usuario: session.id_usuario,
              movimenta: 0,
            };
            let msg = "";
            if (etapaParalela.acao === "duplicar") {
              msg = `O "Duplicar" Negócio no Fluxo ${etapaParalela.tituloFunilDestino}, foi impedido, pois o mesmo já está presente lá neste Fluxo, e não há necessidade de enviar novamente.`;
            } else {
              msg = `O "Mover" Negócio para o Fluxo ${etapaParalela.tituloFunilDestino}, foi impedido, pois o mesmo já está presente lá neste Fluxo. caso necessário, utilize a opção "Remover Negócio deste fluxo."`;
            }

            const dados = {
              id_card: selectedCard.id,
              descricao_log: msg,
              id_lista: etapaDestiny.id,
              tipo_log: "31",
              id_coleta: selectedCard.id_coleta_cliente,
              id_usuario: session.id_usuario,
            };

            insereLogAutomacao(dados);
            atualizarDadosKanban(params)
              .then((res) => {})
              .finally(() => {
                reListarDadosKanban();
                notificarNotificacao();
              });
            return null;
          }
        }
        const locksEtapaDestiny = getArr(
          etapaParalela?.locks,
          selectedCard.tipoNegocio_coleta,
        );

        const allLocks = statePermissions.flatMap((sp: any) => sp.locks || []);
        const compareLocks = locksEtapaDestiny?.every((lock: any) =>
          allLocks.includes(lock),
        );

        const locksNotIn = [
          ...new Set(
            locksEtapaDestiny?.filter(
              (lock: string) => !statePermissions?.locks?.includes(lock),
            ),
          ),
        ];

        if (!compareLocks && compareLocks !== undefined) {
          await Swal.fire({
            title: `Automatização Não Realizada!`,
            html: `
            <style>
              .swal2-title {
                font-size: 20px; /* Ajuste o tamanho do texto do título aqui */
              }
              .highlight {
                font-size: 25px; /* Ajuste o tamanho do texto "Negócio!" aqui */
                font-weight: bold; /* Opcional: adicione negrito ao texto */
              }
            </style>
            <div>Não foi possível <b>${etapaParalela.acao}</b> para a etapa <b>${etapaParalela.tituloEtapaDestino}</b> do Fluxo <b>${etapaParalela.tituloFunilDestino}</b> pois o negócio não possui os 
            locks: <br> ${locksNotIn.map((lock: any) => locks.find((e) => e.id_lock == lock)?.nome_lock).join("<br>")}</div>
          `,
            icon: "warning",
          });

          setRenderLists((prevLists: any) => {
            const updatedLists = produce(prevLists, (draft: any) => {
              draft[fromList].cards = draft[fromList].cards.filter(Boolean);
              const dragged = draft[fromList].cards[from];
              if (!dragged) {
                console.warn("Card a ser movido está undefined", {
                  fromList,
                  from,
                });
                return; // ou trate isso de outra forma
              }

              draft[fromList].cards.splice(from, 1);
              draft[toList].cards.splice(to, 0, dragged);
            });
            newListSet = updatedLists;
            return updatedLists;
          });
          const params = {
            etapas: lists,
            selectedCard: selectedCard,
            listaDestino: etapaDestiny,
            idCardDestino: selectedCard.id,
            id_usuario: session.id_usuario,
          };

          atualizarDadosKanban(params)
            .then((res) => {})
            .finally(() => {
              reListarDadosKanban();
              notificarNotificacao();
            });
          return;
        } else {
          const params = {
            etapas: lists,
            fromList: etapaFrom,
            toList: automacao === 0 ? etapaTo : etapaParalela.etapaDestino,
            automacao,
            selectedCard: selectedCard,
            listaDestino: etapaDestiny,
            idCardDestino: selectedCard.id,
            id_usuario: session.id_usuario,
            acao: etapaParalela.acao,
            funilDestino: etapaParalela.funilDestino,
            etapaDestino: etapaParalela.etapaDestino,
            titulo_funil: etapaParalela.tituloFunilDestino,
            titulo_etapa_funil: etapaParalela.tituloEtapaDestino,
          };

          setRenderLists((prevLists: any[]) => {
            const updatedLists = produceLists(prevLists, (draft) => {
              const moved = applyMoveOnDraft(
                draft,
                fromList,
                toList,
                from,
                to,
                selectedCard,
              );
              if (!moved) {
                console.warn("Card a ser movido está undefined", {
                  fromList,
                  from,
                });
              }
            });
            newListSet = updatedLists;
            syncContextListsAfterMove(updatedLists);
            return updatedLists;
          });

          await atualizarDadosKanban(params)
            .then((res) => {})
            .finally(() => {
              notificarNotificacao();
              return reListarDadosKanban().then(() => {
                if (kanbanId !== etapaParalela.funilDestino) {
                  Swal.fire({
                    title: `Automatização Realizada!`,
                    html: `
              <style>
                .swal2-title {
                  font-size: 20px; /* Ajuste o tamanho do texto do título aqui */
                }
                .highlight {
                  font-size: 25px; /* Ajuste o tamanho do texto "Negócio!" aqui */
                  font-weight: bold; /* Opcional: adicione negrito ao texto */
                }
              </style>
              <div>O negócio foi <b>${etapaParalela.acao == "mover" ? "movido" : "duplicado"}</b> para o Fluxo <b>${etapaParalela.tituloFunilDestino}</b> na etapa <b>${etapaParalela.tituloEtapaDestino}</b> com sucesso!</div>
              </br>
              Deseja ser redirecionado para o fluxo ?
            `,
                    icon: "success",
                    showConfirmButton: true,
                    confirmButtonText: "Redirecionar",
                    showCancelButton: true,
                    cancelButtonText: "Fechar",
                  }).then((result) => {
                    if (result.isConfirmed) {
                      const permissoesFunis: any =
                        perfil.permissoes_funis_perfil;

                      const hasPermission = permissoesFunis
                        .split("^")
                        .includes(etapaParalela.funilDestino);

                      if (!hasPermission) {
                        return;
                      }

                      return router.push(
                        `CXESCRM002?funil=${etapaParalela.funilDestino}`,
                      );
                    }
                  });
                }
              });
            });

          if (etapaParalela.acao === "duplicar") return;
          return etapaParalela;
        }
      }
    } else {
      const params = {
        etapas: lists,
        fromList: etapaFrom,
        selectedCard: selectedCard,
        listaDestino: etapaDestiny,
        idCardDestino: selectedCard.id,
        id_usuario: session.id_usuario,
      };
      setRenderLists((prevLists: any[]) => {
        const updatedLists = produceLists(prevLists, (draft) => {
          const moved = applyMoveOnDraft(
            draft,
            fromList,
            toList,
            from,
            to,
            selectedCard,
          );
          if (!moved) {
            console.warn("Card a ser movido está undefined", {
              fromList,
              from,
            });
          }
        });
        newListSet = updatedLists;
        syncContextListsAfterMove(updatedLists);
        return updatedLists;
      });

      atualizarDadosKanban(params)
        .then((res) => {})
        .finally(() => {
          reListarDadosKanban();
          notificarNotificacao();
          publish({
            action: "move",
            resource: "card",
            data: { cardId: selectedCard.id, fromList, toList, to },
          });
        });
    }
  };

  const resposaveisTarefa = [
    { value: "pre_vendedor", label: "Pré-Vendedor do Projeto" },
    { value: "vendedor", label: "Vendedor do Projeto" },
    { value: "tecnico", label: "Técnico do Projeto" },
    { value: "gerente", label: "Gerente do Projeto" },
    { value: "instalador", label: "Instalador do Projeto" },
    { value: "listaUsuario", label: "Lista de Usuários" },
    { value: "perfilUsuario", label: "Perfil de Usuários" },
  ];

  async function createTask(tasks: any, selectedCard: any) {
    const tarefasGeradas = [];

    for (const task of tasks) {
      const tipoResponsavelLabel =
        resposaveisTarefa.find((e) => e.value == task.responsavel_tarefa_id)
          ?.label || "Responsável não encontrado";

      let nomesResponsaveis = "";

      if (
        task.responsavel_tarefa_id === "perfilUsuario" &&
        task.perfil_tarefa_id
      ) {
        const ids = task.perfil_tarefa_id
          .split(",")
          .map((id: string) => id.trim());
        nomesResponsaveis = perfis
          .filter((perfil: any) => ids.includes(perfil.id_perfil.toString()))
          .map((perfil: any) => perfil.nome_perfil)
          .join(", ");
      } else if (
        task.responsavel_tarefa_id === "listaUsuario" &&
        task.usuario_tarefa_id
      ) {
        const ids = task.usuario_tarefa_id
          .split(",")
          .map((id: string) => id.trim());
        nomesResponsaveis = usuarios
          .filter((usuario: any) => ids.includes(usuario.id_usuario.toString()))
          .map((usuario: any) => usuario.nome_usuario)
          .join(", ");
      }
      const logData = {
        id_card: selectedCard.id,
        id_lista: selectedCard.id_lista_card,
        descricao_log: `Tarefa gerada automaticamente para o negocio ${selectedCard.nome_negocio_coleta}
        para o ${tipoResponsavelLabel}
        ${nomesResponsaveis}`,
        responsavel: session.id_usuario,
        coleta: selectedCard.id_coleta_cliente,
        id_etapaGo: task.id_etapa_automacao,
      };
      const previsaoEntrega = new Date();
      previsaoEntrega.setDate(
        previsaoEntrega.getDate() + Number(task.prazo_tarefa),
      );

      tarefasGeradas.push({
        user_tarefa_gerada: session.id_usuario,
        automacao_tarefa_gerada: task.id_automacao_tarefa,
        codNegocio_tarefa_gerada: selectedCard.id_coleta_cliente,
        codTarefa_tarefa_gerada: task.tarefa_loja_id,
        previsaoEntrega_tarefa_gerada: formatDateToMySQL(previsaoEntrega),
        data_tarefa_gerada: formatDateToMySQL(new Date()),
        codEtapaInicio_tarefa_gerada: task.etapa_automacao_id,
        funilEnvioConcluir_tarefa_gerada: task.funil_destino_id,
        etapaEnvioConcluir_tarefa_gerada: task.etapa_destino_id,
        tipoResponsaveis_tarefa_gerada: task.responsavel_tarefa_id,
        responsaveis_tarefa_gerada:
          task.usuario_tarefa_id || task.perfil_tarefa_id,
        status_tarefa_gerada: 0,
        logData: logData,
      });
    }

    return gerarTarefas(tarefasGeradas).then((res) => listarDadosKanban());
  }

  function formatDateToMySQL(date: Date): string {
    const pad = (n: number) => n.toString().padStart(2, "0");

    return (
      `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
      `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
    );
  }

  const onSubmitStep = (data: FieldValues) => {
    setIsLoading(true);
    createNewStep(data).then(async () => {
      await fetchIdsDoBanco();
      await listarDadosKanban();

      setLocksId([]);
      setIsLoading(false);
      setIsOpenCfgEtapa(false);
    });
  };
  useEffect(() => {
    listarPendencias().then(setPendencias);
  }, []);

  const handleMoveList = (list: any, number: any, indexAtual: any) => {
    const newLists: any = [...list];
    const temp = newLists[indexAtual + number];

    newLists[indexAtual] = temp;

    newLists[indexAtual + number] = list[indexAtual];

    setLists(newLists);
    setOriginalLists(newLists);
  };

  // async function obterIdsDoBanco(): Promise<number[]> {
  //   try {
  //     const perfil = session.perfil_usuario;
  //     if (!perfil) return [];

  //     const idsDoBanco = await listarPerfil(perfil);

  //     return idsDoBanco?.permissoes_etapas_perfil
  //       ? idsDoBanco.permissoes_etapas_perfil.split("^").map(Number)
  //       : [];
  //   } catch (error) {
  //     console.error("Erro ao obter IDs do banco:", error);
  //     return [];
  //   }
  // }
  const [idsDoBanco, setIdsDoBanco] = useState<number[] | null>(null);
  async function fetchIdsDoBanco() {
    if (session.perfil_usuario === "1000" || kanbanId === "0") {
      setIdsDoBanco([]); // Permissão total
      return;
    }

    try {
      const perfil = session.perfil_usuario;
      if (!perfil) {
        setIdsDoBanco([]);
        return;
      }

      const data = await listarPerfil(perfil);
      const ids = data?.permissoes_etapas_perfil
        ? data.permissoes_etapas_perfil.split("^").map(Number)
        : [];
      setIdsDoBanco(ids);
    } catch (error) {
      console.error("Erro ao obter IDs do banco:", error);
      setIdsDoBanco([]);
    }
  }
  useEffect(() => {
    fetchIdsDoBanco();
  }, []);

  useEffect(() => {
    if (idsDoBanco === null) return; // ainda carregando

    if (session.perfil_usuario === "1000" || kanbanId === "0") {
      setRenderLists(lists);
      return;
    }

    const renderableLists = lists.filter((list: any) =>
      idsDoBanco.includes(+list.id),
    );
    setRenderLists(renderableLists);
  }, [lists, idsDoBanco, session.perfil_usuario, kanbanId]);

  return (
    <BoardContext.Provider value={{ lists, move, updatedList: lists }}>
      {kanbanLoaded ? (
        <div
          style={{
            height: isMobile ? "calc(100vh - 237px)" : "calc(100vh - 163px)",
          }}
          className="flex overflow-auto overflow-y-hidden "
          ref={barraEtapas}
          onDrag={(e) => {
            const barraDeEtapas: any = barraEtapas.current;
            const barraDeEtapasBox = barraDeEtapas.getBoundingClientRect();
            const left = barraDeEtapasBox.left;
            const right = barraDeEtapasBox.right;
            if (e.clientX >= right - 50) {
              barraDeEtapas.scrollLeft += 10;
            }
            if (e.clientX <= left + 50) {
              barraDeEtapas.scrollLeft -= 10;
            }
          }}
        >
          {renderLists.length > 0 &&
            renderLists.map((list: any, index: any) => {
              return (
                <List
                  kanbanId={kanbanId}
                  form={form}
                  pendencias={pendencias}
                  key={list.id}
                  index={list?.index_lista_kanban}
                  indexLista={index}
                  data={list}
                  corListaKanban={corListaKanban}
                  droppedCard={handleDroppedCard}
                  atualizarKanban={atualizarKanban}
                  handleMoveList={handleMoveList}
                  renderListsView={lists}
                  viewArrows={canEditList}
                />
              );
            })}
          <div className="flex justify-center items-center">
            {kanbanId != 0 &&
              (session.perfil_usuario == "1000" ||
                perfil?.edita_funis_perfil == "1") && (
                <div className="flex cursor-pointer z-1 pl-2">
                  <div
                    className="flex rounded-lg bg-secondaryMenu p-3 text-white cursor-pointer w-[150px] gap-1"
                    onClick={() => setIsOpenCfgEtapa(true)}
                  >
                    <IoIosAddCircleOutline size={24} />
                    Criar Etapa
                  </div>
                  <ModalComponente
                    hasForm={false}
                    header={
                      <div className="w-full flex flex-row justify-center uppercase font-bold">
                        Configurações da Etapa
                      </div>
                    }
                    hasSaveButton={false}
                    opened={isOpenCfgEtapa}
                    onClose={() => setIsOpenCfgEtapa(false)}
                    className={"overflow-x-hidden"}
                  >
                    <FormLockEtapas
                      onSubmitFunction={onSubmitStep}
                      listOther={lists}
                      corListaKanban={corListaKanban}
                    >
                      <div className="flex w-full justify-end sticky left-[100%] bottom-0 p-2 bg-white dark:bg-black">
                        <Button
                          loading={isLoading}
                          className=" bg-success rounded-md"
                        >
                          Salvar
                        </Button>
                      </div>
                    </FormLockEtapas>
                  </ModalComponente>
                </div>
              )}
          </div>
        </div>
      ) : (
        <div className="flex flex-row mt-[10px] h-[80%]">
          {Array.from({ length: 6 }).map((e: any, index: number) => {
            const cor = corListaKanban.toString();
            return (
              <Skeleton
                key={index}
                style={{ backgroundColor: cor }}
                className="overflow-hidden flex-[0_0_320px] pt-2 mr-1 rounded-xl group relative  w-[250px] h-[100%]"
              ></Skeleton>
            );
          })}
        </div>
      )}
    </BoardContext.Provider>
  );
}