import Input from "@/components/Forms/Input";
import ModalComponente from "@/components/Modal/ModalComponente";
import LoaderSun from "@/components/common/Loader/LoaderSun";
import { useRouter } from "next/router";

import {
  atualizarEtapaFunilNovo,
  desativarCardColeta,
  duplicaCard,
  listarCardInfo,
  listarDadosCard,
  listarFunisEtapasCard,
  listarLocksResponsaveis,
  listarTodosKanbans,
  logarAcaoCardNaoRealizada,
  logarAutomacaoNaoRealizada,
  obterFluxosDoNegocio,
} from "@/requests/CRM/kanban";
import { listarDocumentosGerados } from "@/requests/CRUD/DocumentosGerados/listarDocumentosGeradosPorIdColeta";

import Button from "@/components/Forms/Button";
import InputSelectComponent from "@/components/Forms/InputSelect";
import Map from "@/components/Map";
import ModalRejeicao from "@/components/Modal/ModalReprovacao";
import { handleSweetAlert } from "@/components/Modal/SweetAlertConfirm";
import { useCamposPersonalizados } from "@/hooks/useCamposPersonalizados";
import { cadastrarInstalacao } from "@/requests/CRM/AgendamentosInstalacoes/cadastrarInstalacao";
import { concluirInstalacao } from "@/requests/CRM/AgendamentosInstalacoes/concluirInstalacao";
import { pagarInstalacao } from "@/requests/CRM/AgendamentosInstalacoes/pagarInstalacao";
import { agendarManutencao } from "@/requests/CRM/AgendamentosManutencoes/cadastrarInstalacao";
import { listarContratosPorColeta } from "@/requests/CRM/Contrato/listarContrato";
import {
  listarTodosUsuarios,
  listarUsuarios,
} from "@/requests/CRM/Dashboard/listarDashboard";
import { listarOrdensServicoPorColeta } from "@/requests/CRM/PosvOrdensServico/listarOrdensServicoPorColeta";
import {
  getUcColeta,
  listarUcsColeta,
} from "@/requests/CRM/UCs/listarUcsColeta";
import {
  concluirAcaoPreApuracao,
  listarPreApuracoes,
} from "@/requests/CRUD/Apuracoes/cadastroPreApuracao";
import { estornarPreApuracao } from "@/requests/CRUD/Apuracoes/estornarPreApuracao";
import {
  gravarCamposPersonalizados,
  listarCamposGravados,
  listarCamposPersonalizados,
  listarCheckboxNegocio,
} from "@/requests/CRUD/CamposPersonalizados/listarCamposPersonalizados";
import {
  aprovarPagamento,
  atualizaPendenciaAtual,
  editarDataFinalizacaoVenda,
  fecharVenda,
  listarNegocioPeloId,
  listarPendencias,
  verificaEtapaParalela,
} from "@/requests/CRUD/ColetaDados/cadastroColetaDados";
import { buscaDadosAmpliacao } from "@/requests/CRUD/ColetaDados/editarColeta";
import {
  addConclusaoPendencia,
  remConclusaoPendencia,
} from "@/requests/CRUD/ConclusaoPendencia/conclusaoPendencia";
import { listarCondicoesPagamento } from "@/requests/CRUD/CondicoesPagamento/listarCondicoesPagamento";
import { listarContasBancariasLojas } from "@/requests/CRUD/ContasBancariasLojas/listarContasBancariasLojas";
import { listarFormasPagamento } from "@/requests/CRUD/FormasPagamento/listarFormasPagamento";
import { listarIndicadores } from "@/requests/CRUD/Indicadores/listarIndicadores";
import {
  listarLinhaPendenciasEtapas,
  listarPendenciasColeta,
} from "@/requests/CRUD/LinhaPendencias/listarLinhaPendencias";
import { atualizarCompraMaterialColeta } from "@/requests/CRUD/PendenciaCompraMaterial/atualizarCompraMaterialColeta";
import { salvarPendenciaCompraMaterial } from "@/requests/CRUD/PendenciaCompraMaterial/salvarPendenciaCompraMaterial";
import { atualizarEngenhariaNegocio } from "@/requests/CRUD/PendenciaEngenharia/atualizarEngenhariaNegocio";
import { salvarPendenciaEngenhariaNegocio } from "@/requests/CRUD/PendenciaEngenharia/salvarPendenciaEngenhariaNegocio";
import { salvarPendenciaEntregaKit } from "@/requests/CRUD/PendenciaEntregaKit/salvarPendenciaEntregaKit";
import { atualizarFaturamentoColeta } from "@/requests/CRUD/PendenciaFaturamento/atualizarFaturamento";
import { salvarFaturamento } from "@/requests/CRUD/PendenciaFaturamento/salvarFaturamento";
import { listarPerfil } from "@/requests/CRUD/Perfil/listarPerfil";
import { cadastrarPesquisa } from "@/requests/CRUD/PesquisaSatisfacao/cadastrarPesquisa";
import { editarDataContato } from "@/requests/CRUD/PosvColetas/editarDataContato";
import { salvarContatoClienteColeta } from "@/requests/CRUD/PosvColetas/salvarContatoClienteColeta";
import { listarPropostas } from "@/requests/CRUD/Propostas/listarPropostas";
import { listarTiposNegocios } from "@/requests/CRUD/TiposNegocios/listarTiposNegocios";
import { listarServicos } from "@/requests/CRUD/TiposServico/listarServicos";
import {
  baixarAwsBase64,
  baixarAwsContent,
} from "@/requests/common/Aws/baixarAws";
import { useScreenContext } from "@/src/contexts/ScreenContext";
import { Perfil, useAuth } from "@/src/contexts/authContext";
import { useKanbanContext } from "@/src/contexts/kanbanContext";
import { useUsuarios } from "@/src/contexts/userContext";
import { IValueLabel } from "@/types/formInterfaces";
import { GetForm } from "@/utils";
import { isFluxoPerdas } from "@/utils/fluxoPerdas";
import { getArr } from "@/utils/helpers";
import {
  AcaoPendencia,
  podeExecutarPendencia,
  validarPermissaoPendencia,
} from "@/utils/permissoesPendencias";
import {
  nomeLegivel,
  validarCamposPersonalizadosObrigatorios,
} from "@/utils/validarCamposPersonalizados";
import { Step, StepLabel, Stepper } from "@mui/material";
import { Sparkles } from "lucide-react";
import { useCallback, useEffect, useState } from "react";
import { FieldValues } from "react-hook-form";
import { FaInfoCircle } from "react-icons/fa";
import { toast } from "react-toastify";
import Swal from "sweetalert2";
import { LoadingIcon } from "yet-another-react-lightbox";
import * as yup from "yup";
import ContatoCliente from "./ContatoCliente";
import FormCancelamento from "./ContatoCliente/FormCancelamento";
import OrdensServico from "./OrdensServico";
import FormCustosOS from "./OrdensServico/FormCustosOS";
import FormValidacaoOS from "./OrdensServico/FormValidacaoOS";
import VisualizacaoValidacaoOS from "./OrdensServico/VisualizacaoValidacaoOS";
import CamposPersonalizados from "./campos_personalizados";
import ContatoCard from "./contato";
import Contratos from "./contratos";
import DadosTecnicos from "./dadosTecnicos";
import DocumentosPersonalizados from "./documentos_gerados";
import DropdownsEditCard from "./dropdowns/dropdownsEditCard";
import FollowUpCard from "./followUpCard";
import Historico from "./historico/cardHistorico";
import CardFluxos from "./lead/card/CardFluxos";
import CardInfoCliente from "./lead/card/cardInfoCliente";
import FluxoInfo from "./lead/card/fluxoInfo";
import TabsCard from "./lead/card/tabsCard";
import AgendamentosInstalacaoNegocio from "./lead/modal/AgendamentosInstalacaoNegocio";
import ConclusaoInstalacaoNegocio from "./lead/modal/ConclusaoInstalacaoNegocio";
import FormAgendamento from "./lead/modal/FormAgendamento";
import FormAgendamentoManutencao from "./lead/modal/FormAgendamentoManutencao";
import FormConclusaoInsalacao from "./lead/modal/FormConclusaoInsalacao";
import FormPagamentoInstalacao from "./lead/modal/FormPagamentoInstalacao";
import PagamentoInstalacao from "./lead/modal/PagamentoInstalacao";
import PendenciaCompraMaterial from "./lead/modal/PendenciaCompraMaterial";
import PendenciaEngenharia from "./lead/modal/PendenciaEngenharia";
import PendenciaEntregaKit from "./lead/modal/PendenciaEntregaKit";
import PendenciaFaturamento from "./lead/modal/PendenciaFaturamento";
import PesquisaSatisfacao from "./lead/modal/PesquisaSatisfacao";
import VisualizacaoAgendamentosManutencao from "./lead/modal/VisualizacaoAgendamentosManutencao";
import VisualizacaoCompraMaterial from "./lead/modal/VisualizacaoCompraMaterial";
import VisualizacaoEntregaKit from "./lead/modal/VisualizacaoEntregaKit";
import VisualizacaoFaturamento from "./lead/modal/VisualizacaoFaturamento";
import VisualizacaoPendenciaEngenharia from "./lead/modal/VisualizacaoPendenciaEngenharia";
import VisualizacaoPendenciaPesquisa from "./lead/modal/VisualizacaoPendenciaPesquisa";
import AnexosModal from "./lead/modal/anexos";
import NegocioCard from "./negocio";
import ObsColeta from "./obs_coleta";
import InformacoesPagamentoCliente from "./pendencias/informacoesPagamentoCliente";
import InformacoesPreApuracao from "./pendencias/informacoesPreApuracao";
import PreApuracaoComissao from "./pendencias/preApuracaoComissao";
import PropostasTab from "./propostas/propostas";

interface IEtapaProps {
  id: string;
  descricao: string;
}

const EditCard = ({
  form,
  kanbanId,
  dadosCard: dadosNegocioCard,
  // setDadosCard,
  dadosLista,
  changeNomeNegocio,
  closeModal,
  pendencias,
  autoExecuteAction,
}: any) => {
  const { usuarios } = useUsuarios();
  const [todosUsuarios, setTodosUsuarios] = useState<any[]>([]);
  const [dadosCard, setDadosCard] = useState(dadosNegocioCard);
  const [docsPersonalizadosGerados, setDocsPersonalizadosGerados] =
    useState<any>([]);
  useEffect(() => {
    setDadosCard(dadosNegocioCard);
  }, [dadosNegocioCard]);
  const [selectedUsers, setSelectedUsers] = useState([]);
  const [selectedCategoria, setSelectedCategoria] = useState([]);
  const [dateInicio, setDateInicio] = useState("");
  const [dateFim, setDateFim] = useState("");
  const [cliente, setCliente] = useState<any>({});
  const [pendenciasList, setPendenciasList] = useState<any[]>([]);
  // const isFluxoPerdas =
  //   String(kanbanId) === "0" ||
  //   String(dadosCard?.status_coleta) === "100" ||
  //   !!dadosCard?.motivoCancel_coleta;
  const [blockEditCard, setBlockEditCard] = useState<boolean>(
    isFluxoPerdas || dadosCard?.todasPendencias_concluidas_coleta == "1"
  );
  const [inseridoDadosAmpliacao, setInseridoDadosAmpliacao] = useState(true);
  const router = useRouter();

  const [financiadorCliente, setFinanciadorCliente] = useState<any>({});
  const [propostas, setPropostas] = useState<any[]>([]);
  const [propostaAtiva, setPropostaAtiva] = useState<any>([]);
  const [coletaContratos, setColetaContratos] = useState<any[]>([]);
  const [ordensServico, setOrdensServico] = useState<any[]>([]);
  const { valuesSession, perfil, usuario } = useAuth();
  const { session } = valuesSession();
  const [eventSchema2, setEventSchema3] = useState<
    yup.ObjectSchema<{}, yup.AnyObject, {}, "">
  >(yup.object().shape({}));
  const { ...formDados } = GetForm();
  const { ...formTrocaEtapa } = GetForm();
  const { handleSubmit, ...formCamposPersonalizados } = GetForm(
    eventSchema2,
    setEventSchema3
  );
  const [loading, setLoading] = useState(true);
  const [historico, setHistorico] = useState<any[]>([]);
  const [logs, setLogs] = useState<any[]>([]);

  const [notas, setNotas] = useState("");
  const id_usuario = session.id_usuario;

  const [allFunis, setAllFunis] = useState<any[]>([]);
  const [openModalAnexo, setOpenModalAnexo] = useState(false);
  const [openModalVisualizaPreApuracao, setOpenModalVisualizaPreApuracao] =
    useState(false);
  const [isLoading, setIsLoading] = useState(false);
  const [isLoadingAgendamentoInstalacao, setIsLoadingAgendamentoInstalacao] =
    useState(false);
  const [isLoadingAgendamentoManutencao, setIsLoadingAgendamentoManutencao] =
    useState(false);
  const [openModalChangeEtapa, setOpenModalChangeEtapa] = useState(false);
  const [openModalPagamento, setOpenModalPagamento] = useState(false);
  const [openModalDeleteCard, setOpenModalDeleteCard] = useState(false);
  const [canDeleteCard, setCanDeleteCard] = useState(false);
  const [fluxosDoNegocio, setFluxosDoNegocio] = useState<any>([]);
  const [openModalChangeFunil, setOpenModalChangeFunil] = useState([false, ""]);
  const [selectedFunilDestiny, setSelectedFunilDestiny] = useState<any>("");
  const [funilOriginName, setFunilOrigimName] = useState<string>("");

  const [etapasDestinoMovim, setEtapasDestinoMovim] = useState<IEtapaProps[]>(
    []
  );
  const [anexoPagamento, setAnexoPagamento] = useState<File>();
  const [openModalRejeicao, setOpenModalRejeicao] = useState(false);
  const [openModalAgendamento, setOpenModalAgendamento] = useState(false);
  const [
    openModalReAgendamentoInstalacao,
    setOpenModalReAgendamentoInstalacao,
  ] = useState(false);
  const [openModalAgendamentoManutencao, setOpenModalAgendamentoManutencao] =
    useState(false);
  const [openPendenciaFaturamento, setOpenPendenciaFaturmento] =
    useState(false);
  const [
    openVisualizaAgendamentosInstalacoes,
    setOpenVisualizaAgendamentosInstalacoes,
  ] = useState(false);
  const [
    openVisualizaConclusaoInstalacao,
    setOpenVisualizaConclusaoInstalacao,
  ] = useState(false);
  const [openModalVisualizaResumoIA, setOpenModalVisualizaResumoIA] =
    useState(false);
  const [
    openVisualizaPagamentoInstalacao,
    setOpenVisualizaPagamentoInstalacao,
  ] = useState(false);
  const [openModalConclusaoInstalacao, setOpenModalConclusaoInstalacao] =
    useState(false);
  const [openModalPagamentoInstalacao, setOpenModalPagamentoInstalacao] =
    useState(false);
  const [
    openVisualizaAgendamentoManutencao,
    setOpenVisualizaAgendamentoManutencao,
  ] = useState(false);
  const [openPreapuracao, setOpenPreapuracao] = useState(false);
  const [openPendenciaCompras, setOpenPendenciaCompras] = useState(false);
  const [openFinalizacaoVenda, setOpenFinalizacaoVenda] = useState(false);
  const [openPendenciaEngenharia1, setOpenPendenciaEngenharia1] =
    useState(false);
  const [openPendenciaEngenharia2, setOpenPendenciaEngenharia2] =
    useState(false);
  const [openEntregaKit, setOpenEntregaKit] = useState(false);

  const [openVisualizaCompraMaterial, setOpenVisualizaCompraMaterial] =
    useState(false);
  const [openVisualizaFaturamento, setOpenVisualizaFaturamento] =
    useState(false);
  const [
    openVisualizaPendenciaEngenharia,
    setOpenVisualizaPendenciaEngenharia,
  ] = useState(false);

  const [openVisualizaEntregaKit, setOpenVisualizaEntregaKit] = useState(false);
  const [openModalGeracaoOS, setOpenModalGeracaoOS] = useState(false);

  const [openModalVisualizarOrdemServico, setOpenModalVisualizarOrdemServico] =
    useState(false);

  const [usuariosResponsaveis, setUsuariosResponsaveis] = useState<any[]>([]);
  const [indicadores, setIndicadores] = useState<any[]>([]);

  const { isMobile } = useScreenContext();
  const [etiquetas, setEtiquetas] = useState([]);

  const [dadosPerfil, setDadosPerfil] = useState<Perfil | null>(null);

  const [tiposServicos, setTiposServicos] = useState<any[]>([]);
  const [isLoaded, setIsLoaded] = useState(false);

  const salvarCamposPersonalizados = async (data: any, pendencia?: any) => {
    const dados = {
      data,
      coleta_id: dadosCard.id_coleta_cliente,
      id_card: dadosCard.id,
      cliente: cliente.id_cliente,
      id_pendencia: pendencia,
      id_usuario,
    };

    return gravarCamposPersonalizados(dados);
  };
  const { filterCamposPersonalizados } = useCamposPersonalizados(
    dadosCard.id_coleta_cliente
  );
  const [preApuracaoValues, setPreApuracaoValues] = useState<any>({});
  const [
    openPendenciaPesquisaSatisfacao1,
    setOpenPendenciaPesquisaSatisfacao1,
  ] = useState<any>(false);
  const [
    openPendenciaPesquisaSatisfacao2,
    setOpenPendenciaPesquisaSatisfacao2,
  ] = useState<any>(false);
  const idColeta = dadosCard && dadosCard?.id_coleta_cliente;

  const [cardLocks, setCardLocks] = useState<any[]>([]);
  const [activeTab, setActiveTab] = useState<[string, string | null]>(
    kanbanId != 0 ? ["1", ""] : ["11", ""]
  );

  const {
    locks,
    dadosFunil,
    categoriasAnexos,
    locksRetrocesso,
    documentosPersonalizados,
    lists,
    resetMenu,
    cardsState,
    setCardsState,
  } = useKanbanContext();

  const noFluxoPerdas = isFluxoPerdas(
    dadosFunil,
    kanbanId,
    dadosCard?.status_coleta
  );

  async function reListarDadosKanban() {
    return listarCardInfo({ id_card: dadosCard.id }).then((res) => {
      setDadosCard((prev: any) => ({ ...prev, ...res }));
    });
  }

  const [activeStep, setActiveStep] = useState<number>(1);

  const [stepsTemp, setStepsTemp] = useState<any[]>([]);

  const podePendencia = (
    idPendencia: string | number,
    acao: AcaoPendencia
  ): boolean =>
    podeExecutarPendencia(dadosPerfil || perfil, stepsTemp, idPendencia, acao);

  const validarPendencia = (
    idPendencia: string | number,
    acao: AcaoPendencia
  ): boolean =>
    validarPermissaoPendencia(
      dadosPerfil || perfil,
      stepsTemp,
      idPendencia,
      acao
    );

  const [valorComissaoVendedor, setValorComissaoVendedor] = useState(0);
  const [valorComissaoPreVendedor, setValorComissaoPreVendedor] = useState(0);
  const [valorComissaoGerente, setValorComissaoGerente] = useState(0);
  const [valorComissaoIndicador, setValorComissaoIndicador] = useState(0);
  const [valorComissaoSupervisor, setValorComissaoSupervisor] = useState(0);
  const [valorProposta, setValorProposta] = useState(0);
  const formPagamento = GetForm();
  const formPreApuracao = GetForm();
  const { handleSubmit: handleSubmitPagamento, ...form2 } = GetForm();
  const { handleSubmit: handleSubmitPreApuracao, ...formPre } = GetForm();

  const [etapas, setEtapas] = useState<any[]>([]);
  const [tipoNegocio, setTipoNegocio] = useState<any>([]);
  const [erroDataPagamento, setErroDataPagamento] = useState(false);
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [openModalVisualizaPagamento, setOpenModalVisualizaPagamento] =
    useState(false);
  const [
    openModalVisualizaFinalizacaoVenda,
    setOpenModalVisualizaFinalizacaoVenda,
  ] = useState(false);
  const [dadosNegocio, setDadosNegocio] = useState<any>({});
  const [responsaveisInativos, setResponsaveisInativos] = useState<any>([]);

  const [condicoesPagamento, setCondicoesPagamento] = useState<any[]>([]);
  const [formasPagamento, setFormasPagamento] = useState<any[]>([]);
  const [contasBancariasLojas, setContasBancariasLojas] = useState<any[]>([]);
  const [etapasFunil, setEtapasFunil] = useState<any>([]);

  const [camposPersonalizadosBd, setCamposPersonalizadosBd] = useState<any>([]);
  const [camposPersonalizadosGravacao, setCamposPersonalizadosGravacao] =
    useState<any>();

  const [locks_responsaveis, setLocks_responsaveis] = useState<any[]>([]);

  const [openModalBaixarOrdemServico, setOpenModalBaixarOrdemServico] =
    useState(false);
  const [openModalCustosOrdemServico, setOpenModalCustosOrdemServico] =
    useState(false);
  const [
    openModalPagamentoCobrancaTerceiro,
    setOpenModalPagamentoCobrancaTerceiro,
  ] = useState(false);
  const [ordemServicoSelecionada, setOrdemServicoSelecionada] = useState<any>();
  const [openModalValidacaoOrdemServico, setOpenModalValidacaoOrdemServico] =
    useState(false);
  const [
    openModalVisualizacaoValidacaoOrdemServico,
    setOpenModalVisualizacaoValidacaoOrdemServico,
  ] = useState(false);

  const [openModalContatoCliente, setOpenModalContatoCliente] = useState(false);
  const formPendenciaEngenharia = GetForm();
  const [openModalCancelamento, setOpenModalCancelamento] = useState(false);

  useEffect(() => {
    const arrLocks = [];

    if (dadosCard?.propostas.length) arrLocks.push("5");
    if (dadosCard?.contratos.length) arrLocks.push("7");
    if (dadosCard?.cpfcnpj_cliente) arrLocks.push("1");
    if (dadosCard?.email_cliente) arrLocks.push("2");
    if (dadosCard?.rua_cliente) arrLocks.push("3");
    if (dadosCard?.agendamentos) arrLocks.push("9");
    if (dadosCard?.latitude && dadosCard?.longitude) arrLocks.push("8");

    if (dadosCard?.id_lista_card == "1") arrLocks.push("*");

    setCardLocks(arrLocks);

    listarPreApuracoes().then((res) => {
      const filteredApuracao: any = res.find(
        (apuracao: any) => apuracao.cod_negocio_pre_apuracao == idColeta
      );
      setPreApuracaoValues(filteredApuracao);
    });
    listarCamposPersonalizados().then((res) =>
      setCamposPersonalizadosBd(
        res.filter((a: any) => a.status_campo_personalizado == "1")
      )
    );
    listarCamposGravados().then(setCamposPersonalizadosGravacao);

    listarLocksResponsaveis().then(setLocks_responsaveis);
  }, [dadosCard]);

  // useEffect(() => {
  //   setDadosCard((prev: any) => ({
  //     ...prev,
  //     propostas,
  //     contratos: coletaContratos,
  //   }));
  // }, [propostas, coletaContratos]);

  useEffect(() => {
    listarFunisEtapasCard({ id_coleta: dadosCard?.id_coleta_cliente }).then(
      (filteredFunisEtapas) => {
        setEtapasFunil(filteredFunisEtapas);
      }
    );
  }, [dadosCard]);
  const [ucsColeta, setUcsColeta] = useState([]);
  useEffect(() => {
    if (perfil) {
      Promise.all([
        buscaCliente().then((res) => {
          return res;
        }),
        listarTodosUsuarios().then(setTodosUsuarios),
        listarUcsColeta(dadosCard.id_coleta_cliente).then(setUcsColeta),
        listarDocumentosGerados().then(setDocsPersonalizadosGerados),
        listarUsuarios().then((res) => {
          setUsuariosResponsaveis(res);
          const responsaveis = dadosCard?.responsaveis || {};
          const idsResponsaveis = Object.entries(responsaveis)
            .filter(([cargo]) => cargo !== "Criador") // Remove o criador da validação dos inativos
            .map(([_, id]) => id)
            .filter((id) => id !== null);

          const invalido = res.filter((usuario: any) => {
            return (
              idsResponsaveis.includes(usuario.id_usuario) &&
              usuario.status_usuario != "1"
            );
          });
          const usuariosInativosComCargo = invalido.map((usuario: any) => {
            const cargo = Object.entries(responsaveis).find(
              ([_, id]) => id === usuario.id_usuario
            )?.[0];
            return { cargo, nome: usuario.nome_usuario };
          });

          // O criador pode estar inativo e não é alterável no card.
          // Só alertamos para inativos que podem ser corrigidos.
          const usuariosInativosEditaveis = usuariosInativosComCargo.filter(
            (usuario: any) => usuario.cargo !== "Criador"
          );

          if (usuariosInativosEditaveis.length > 0) {
            // setBlockEditCard(true);
            Swal.fire({
              icon: "warning",
              title: "Atenção!",
              html: `Existem Responsáveis Inativos <br><br>Os responsáveis inativos são: ${usuariosInativosEditaveis
                .map((usuario: any) => `<br> ${usuario.cargo}: ${usuario.nome}`)
                .join(", ")}`,
            });
            setResponsaveisInativos(usuariosInativosEditaveis);
          }

          return res;
        }),
        listarIndicadores().then((res) => {
          setIndicadores(res);
          return res;
        }),
      ]).then(() => {
        setLoading(false);
      });
    }
  }, [perfil]);

  const actionMap: Record<string, () => void> = {
    "1": () => {
      setActiveTab(["3", ""]);
      toast.warning("Informe o endereço de instalação");
    },
    "2": () => {
      setActiveTab(["4", ""]);
      toast.warning(
        "Informe os dados da Fatura para habilitar a geração de propostas"
      );
    },
    "3": () => {
      setActiveTab(["5", ""]);
      toast.warning(
        "Gere uma proposta a partir da 'Etapa configurada para GERAR PROPOSTA'"
      );
    },
    "4": () => {
      setActiveTab(["5", ""]);
      toast.warning("Aprove uma proposta");
    },
    "5": () => {
      const falhasDeValidacao: any[] = [];
      let camposObrigatorios: any[] = [];
      if (cliente.tipoPessoa_cliente == "F") {
        camposObrigatorios = [
          { valor: "cpfcnpj_cliente", nome: "CPF/CNPJ" },
          {
            valor: "dataNascimento_cliente",
            nome: "Data de Nascimento",
          },
          {
            valor: "estadoCivil_cliente",
            nome: "Estado Civil",
          },
          { valor: "profissao_cliente", nome: "Profissão" },
          { valor: "cep_cliente", nome: "CEP" },
          { valor: "bairro_cliente", nome: "Bairro" },
          { valor: "rua_cliente", nome: "Rua" },
          { valor: "nro_cliente", nome: "Número de endereço" },
          { valor: "cidade_cliente", nome: "Cidade" },
          { valor: "estado_cliente", nome: "Estado" },
          { valor: "nome_cliente", nome: "Nome" },
        ];
      } else {
        camposObrigatorios = [
          { valor: "cpfcnpj_cliente", nome: "CPF/CNPJ" },
          { valor: "nomeEmpresa_cliente", nome: "Razão Social" },
          {
            valor: "nomeResponsavelFisico_cliente",
            nome: "Nome Responsável Legal",
          },
          {
            valor: "data_aberturaEmpresa_cliente",
            nome: "Data  de Abertura",
          },
          {
            valor: "ie_cliente",
            nome: "IE",
          },
          { valor: "cepEmpresa_cliente", nome: "CEP" },
          {
            valor: "logradouroEmpresa_cliente",
            nome: "Logradouro",
          },
          { valor: "numeroEmpresa", nome: "Número de endereço" },
          { valor: "bairroEmpresa_cliente", nome: "Bairro" },
          { valor: "cidadeEmpresa_cliente", nome: "Cidade" },
          { valor: "ufEmpresa_cliente", nome: "Estado" },
        ];
      }

      for (const campoObrigatorio of camposObrigatorios) {
        if (!cliente[campoObrigatorio.valor]) {
          falhasDeValidacao.push(campoObrigatorio.nome);
        }
      }
      if (falhasDeValidacao.length > 0) {
        return toast.warning(
          `Informações do cliente incompletas, é necessário informar: ${falhasDeValidacao.join(", ")} do Cliente`
        );
      }
      setActiveTab(["6", ""]);
      toast.warning(`Gere um contrato em "Novo Contrato"!`);
    },
    "6": () => {
      setActiveTab(["6", ""]);
      toast.warning("Assine/Aprove um contrato");
    },
    "7": () => {
      if (validarPendencia("7", "realizar")) {
        setOpenModalPagamento(true);
        toast.warning(`Aprove o pagamento do negócio`);
      }
    },
    "8": async () => {
      if (!validarPendencia("8", "realizar")) return;
      if (
        dadosCard &&
        createAction(compareActiveStep("Finalização da Venda", "=="))
      ) {
        toast.warning(`Finalize a venda`);
        const agoraDateTime = new Date()
          .toLocaleString("sv-SE", {
            timeZone: "America/Sao_Paulo",
            hour12: false,
          })
          .replace(" ", "T")
          .slice(0, 16);

        const contratosAtualizados = await listarContratosPorColeta(
          dadosCard?.id_coleta_cliente
        ).catch(() => dadosCard?.contratos || []);

        // Valida pela data de geração do contrato, não pela data de
        // aprovação — contrato gerado no fim do mês e aprovado só no mês
        // seguinte barrava a finalização no mês correto.
        const limiteData =
          obterDataMinimaFinalizacaoVenda(contratosAtualizados);

        const dataMinimaFinalizacao = limiteData?.data
          ? String(limiteData.data).replace(" ", "T").slice(0, 16)
          : "";

        const dataMinimaFinalizacaoLabel = dataMinimaFinalizacao
          ? new Date(dataMinimaFinalizacao).toLocaleString("pt-BR")
          : "Não informada";

        const motivoLabel =
          limiteData?.motivo || "a data de geração do contrato";

        const inputAttributes: Record<string, string> = {};
        if (dataMinimaFinalizacao) {
          inputAttributes.min = dataMinimaFinalizacao;
        }

        // Sugestão do campo = data de GERAÇÃO do contrato, não o "agora" (que na
        // prática era a data de aprovação, já que a finalização acontece logo
        // depois de aprovar). Continua editável, respeitando o mínimo acima.
        const dataGeracaoContrato =
          obterDataGeracaoContrato(contratosAtualizados);
        const dataSugerida = dataGeracaoContrato
          ? String(dataGeracaoContrato).replace(" ", "T").slice(0, 16)
          : agoraDateTime;

        const result = await Swal.fire({
          icon: "question",
          title: "Finalização da Venda",
          html: `Data de referência (${motivoLabel}): <b>${dataMinimaFinalizacaoLabel}</b><br/>Informe a Data da Finalização da Venda`,
          input: "datetime-local",
          inputValue: dataSugerida,
          inputAttributes,
          showDenyButton: true,
          confirmButtonText: "Confirmar",
          confirmButtonColor: "#4CAF50",
          denyButtonText: "Cancelar",
          denyButtonColor: "#FF0000",
          customClass: {
            popup: "dark:bg-form-strokedark dark:text-white",
          },
          inputValidator: (value) => {
            if (!value) return "Informe a data da finalização";
            if (dataMinimaFinalizacao) {
              const valueDateOnly = value.split("T")[0];
              const dataMinimaFinalizacaoDateOnly =
                dataMinimaFinalizacao.split("T")[0];
              if (valueDateOnly < dataMinimaFinalizacaoDateOnly) {
                return `Data não pode ser menor que ${motivoLabel}`;
              }
            }
            return null;
          },
        });

        if (result.isConfirmed) {
          finalizarVenda(result.value, dataMinimaFinalizacao, motivoLabel);
        }
      }
    },
    "9": () => {
      if (validarPendencia("9", "realizar")) {
        setOpenPendenciaCompras(true);
      }
    },
    "10": () => {
      if (validarPendencia("10", "realizar")) {
        setOpenPendenciaEngenharia1(true);
      }
    },
    "11": () => {
      if (validarPendencia("11", "realizar")) {
        setOpenModalAgendamento(true);
        toast.warning(`Agende a instalação`);
      }
    },
    "12": () => {
      if (validarPendencia("12", "realizar")) {
        setOpenPreapuracao(true);
        toast.warning("Informe a pré-apuração de comissão");
      }
    },
    "13": () => {
      if (validarPendencia("13", "realizar")) {
        setOpenModalConclusaoInstalacao(true);
        toast.warning(`Conclua a Instalação`);
      }
    },
    "14": () => {
      if (validarPendencia("14", "realizar")) {
        setOpenModalPagamentoInstalacao(true);
        toast.warning(`Pague a Instalação`);
      }
    },
    "15": () => {
      if (validarPendencia("15", "realizar")) {
        setOpenEntregaKit(true);
        toast.warning("Efetue a entrega do kit");
      }
    },
    "16": () => {
      if (validarPendencia("16", "realizar")) {
        setOpenPendenciaFaturmento(true);
      }
    },
    "17": () => {
      if (validarPendencia("17", "realizar")) {
        setOpenPendenciaPesquisaSatisfacao1(true);
      }
    },
    "18": () => {
      if (validarPendencia("18", "realizar")) {
        setOpenPendenciaPesquisaSatisfacao2(true);
      }
    },
    "19": () => {
      if (validarPendencia("19", "realizar")) {
        setOpenPendenciaEngenharia2(true);
      }
    },
    "20": () => {
      if (validarPendencia("20", "realizar")) {
        handleSweetAlert(
          {
            icon: "question",
            title: "Deseja concluir o projeto?",
            input: "checkbox",
            inputValue: 0,
            inputPlaceholder: `<span style="font-size: 14px; line-height: 4px">Estou ciente que estou concluindo o projeto, e as edições ficarão bloqueadas. </span>`,
            inputValidator: (result: any) => {
              return !result && "Você precisa concordar para finalizar!";
            },
          },
          () => {
            getUcColeta(dadosCard?.id_coleta_cliente).then((uc: any) => {
              if (
                !["2", "4"].includes(dadosCard?.tipoNegocio_coleta) &&
                !uc.numero_uc_coleta
              ) {
                return toast.error(
                  "Insira um numero de UC para concluir projeto!"
                );
              }
              getUcColeta(dadosCard?.id_coleta_cliente).then((uc: any) => {});
              getUcColeta(dadosCard?.id_coleta_cliente).then((uc: any) => {});
              addConclusaoPendencia({
                id_coleta: dadosCard?.id_coleta_cliente,
                id_etapa: dadosCard?.id_lista,
                id_pendencia: "20",
              }).then(() => {
                // activestepFunction(1);
                atualizaPendenciaAtual({
                  id_coleta: dadosCard?.id_coleta_cliente,
                  id_pendencia: "20",
                  index_atual: 20,
                  finalizar: 1,
                  user: id_usuario,
                });
                setBlockEditCard(true);
                reListarDadosKanban();
                // setActiveStep(21);
              });
            });
          }
        );
      }
    },
    "21": () => {
      if (!validarPendencia("21", "realizar")) return;
      setOpenModalAgendamentoManutencao(true);
      toast.warning(`Agende a Manutenção`);
    },
    "22": () => {
      if (!validarPendencia("22", "realizar")) return;
      setOpenModalGeracaoOS(true);
      toast.warning(`Gere a OS`);
      setActiveTab(["14", ""]);
    },
    "23": () => {
      if (!validarPendencia("23", "realizar")) return;
      toast.warning(`Realize a baixa da OS`);
      setActiveTab(["14", ""]);
      const ordemServico = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "0"
      );
      if (ordemServico) {
        setOrdemServicoSelecionada(ordemServico);
        setOpenModalBaixarOrdemServico(true);
        setActiveTab(["14", ""]);
      }
    },
    "30": () => {
      if (!validarPendencia("30", "realizar")) return;
      const ordemServico = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "1"
      );
      if (ordemServico) {
        setOrdemServicoSelecionada(ordemServico);
        setOpenModalCustosOrdemServico(true);
        setActiveTab(["14", ""]);
      }
    },
    "24": () => {
      if (!validarPendencia("24", "realizar")) return;
      const ordemServico = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "1"
      );
      if (ordemServico) {
        setOrdemServicoSelecionada(ordemServico);
        setOpenModalValidacaoOrdemServico(true);
        // setActiveTab(["14", ""]);
      }
    },
    "26": () => {
      if (validarPendencia("26", "realizar")) {
        setOpenPendenciaFaturmento(true);
      }
    },
    "27": () => {
      if (validarPendencia("27", "realizar")) {
        setOpenModalPagamentoInstalacao(true);
        toast.warning(`Pague a Instalação`);
      }
    },
    "28": () => {
      if (validarPendencia("28", "realizar")) {
        setOpenPendenciaPesquisaSatisfacao1(true);
      }
    },
    "31": () => {
      if (!validarPendencia("31", "realizar")) return;
      setOpenModalContatoCliente(true);
    },
    "29": () => {
      setActiveTab(["4", ""]);
      toast.warning(
        "Informe os técnicos para habilitar a geração de propostas"
      );
    },
    "33": () => {
      const ordemServico = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "1"
      );
      if (ordemServico) {
        setOrdemServicoSelecionada(ordemServico);
        setOpenModalPagamentoCobrancaTerceiro(true);
      }
    },
  };

  const remanenceActionMap: Record<string, () => void> = {
    "23": () => {
      const ordemServico = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "1"
      );
      if (ordemServico) {
        setOrdemServicoSelecionada(ordemServico);
        setOpenModalBaixarOrdemServico(true);
        setActiveTab(["14", ""]);
      }
    },
    "30": () => {
      if ([null, 0, "0"].includes(ordensServico[0]?.is_externo_usuario)) {
        handleSweetAlert({
          icon: "success",
          title: `Pendência concluída`,
          html: `<span>Pendência Concluída Automaticamente pois o instalador é interno</span>`,
          showDenyButton: false,
          confirmButtonText: "Ok",
        });
      }
    },
    "26": () => {
      const ordemServico = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "1"
      );
      if (ordemServico?.cod_respfin_validacao_execucao_servico != "3") {
        handleSweetAlert({
          icon: "success",
          title: `Pendência concluída`,
          html: `<span>Pendência Concluída Automaticamente pois a responsabilidade financeira não é do cliente</span>`,
          showDenyButton: false,
          confirmButtonText: "Ok",
        });
      }
    },
  };

  // useEffect(() => {
  //   setRemanenceActionMap({
  //     ...{
  //       "23": () => {
  //         console.log(
  //           "cade",
  //           ordensServico,
  //           ordensServico?.find(
  //             (ordemServico) => ordemServico?.status_pvos == "1"
  //           )
  //         );
  //         setOrdemServicoSelecionada(
  //           ordensServico?.find(
  //             (ordemServico) => ordemServico?.status_pvos == "1"
  //           )
  //         );
  //         // setOpenModalBaixarOrdemServico(true);
  //       },
  //       "30": () => {
  //         if (ordensServico[0]?.codExecutor_pvos === "0") {
  //           handleSweetAlert({
  //             icon: "success",
  //             title: `Pendência concluída`,
  //             html: `<span>Pendência Concluída Automaticamente por motivo do instalador ser interno</span>`,
  //             showDenyButton: false,
  //             confirmButtonText: "Ok",
  //           });
  //         }
  //       },
  //     },
  //   });
  // }, [ordensServico]);

  useEffect(() => {
    if (autoExecuteAction && actionMap[autoExecuteAction]) {
      if (!loading && Object.keys(cliente).length > 0) {
        actionMap[autoExecuteAction](); // executa automaticamente
      }
    }
  }, [autoExecuteAction, cliente, loading]);

  const isStepBlocked = (step: any) => {
    // Aqui faz busca pra ver se foi comprado ou não
    const ID = Number(step.id);
    return ID === 1030 || ID === 1031;
  };
  const createAction = useCallback(
    (setActiveTabFunc: () => any) => () => {
      setActiveTabFunc();
    },
    [activeStep, cliente, dadosCard, perfil, usuario, stepsTemp]
  );

  useEffect(() => {
    if (!perfil || !cliente || !dadosCard) {
      setStepsTemp((prev) => []);
    }
    if (dadosCard && stepsTemp?.length == 0) {
      listarLinhaPendenciasEtapas(dadosCard?.sequenciaPendencias_coleta).then(
        (res) => {
          setStepsTemp([
            { label: "Negócio Criado", index: 0 },
            ...res.map((item: any, i: number) => ({
              ...item,
              id: item.id_pendencia,
              label: item.nome_pendencia,
              index: i + 1,
              action: actionMap[item.id_pendencia] || (() => {}),
            })),
          ]);
        }
      );
    }
  }, [cliente, dadosCard, perfil, usuario]);
  // const [completedSteps, setCompletedSteps] = useState<any[]>([]);
  const activestepFunction = useCallback(
    async (finaliza?: number) => {
      // Se o projeto está concluído, não alterar o activeStep
      if (dadosCard?.todasPendencias_concluidas_coleta == "1") {
        return;
      }

      let newActiveStep = activeStep;

      const completedSteps = await listarPendenciasColeta(
        dadosCard?.id_coleta_cliente
      );

      if (
        isNextIndex(
          stepsTemp.findIndex((a) => a.label === "Pré-apuração de Comissão"),
          newActiveStep
        )
      ) {
        await listarPreApuracoes().then((res) => {
          const filteredApuracao: any = res.find(
            (apuracao: any) => apuracao.cod_negocio_pre_apuracao == idColeta
          );
          if (
            filteredApuracao?.status_apuracao === "0" ||
            filteredApuracao?.status_apuracao === "1"
          ) {
            concluirAcaoPreApuracao(dadosCard?.id_coleta_cliente);
          }
        });
      }

      // Verifica se o passo atual já foi concluído
      const haveCompletedStep = completedSteps.some(
        (pend: any) =>
          pend.id_pendencia_pendencias_conclusao ===
          stepsTemp[newActiveStep]?.id
      );
      let indexPendencia = stepsTemp[newActiveStep]?.index;

      const nextStep = stepsTemp.find(
        (pendencia: any, i) =>
          i != 0 &&
          completedSteps.every(
            (p: any) => p.id_pendencia_pendencias_conclusao != pendencia.id
          )
        // !completedSteps.some((p: any, i: number) => {
        //   return (
        //     i != 0 && p.id_pendencia_pendencias_conclusao == pendencia.id
        //   );
        // })
      );

      if (nextStep) {
        if (activeStep != nextStep?.index) {
          setActiveStep(nextStep.index);
          await atualizaPendenciaAtual({
            id_coleta: dadosCard?.id_coleta_cliente,
            id_pendencia: nextStep.id,
            index_atual: nextStep.index,
            finalizar: finaliza,
            user: id_usuario,
          });
        }
      }

      // // Se o passo atual foi concluído, avança para o próximo
      // const finalStep = haveCompletedStep ? newActiveStep + 1 : newActiveStep;

      // // Atualiza o activeStep apenas se necessário
      // if (finalStep !== activeStep) setActiveStep(finalStep);

      // // Se houver mais passos, atualiza a pendência
      // if (stepsTemp[finalStep]) {
      //   const id_pendencia = pendenciasList.find(
      //     (pendencia: any) => pendencia.id_pendencia === stepsTemp[finalStep].id
      //   )?.id_pendencia;

      //   if (id_pendencia) {
      //     await atualizaPendenciaAtual({
      //       id_coleta: dadosCard?.id_coleta_cliente,
      //       id_pendencia,
      //       index_atual: indexPendencia,
      //       finalizar: finaliza,
      //       user: id_usuario,
      //     });
      //   }
      // }
    },
    [activeStep, dadosCard, stepsTemp, pendenciasList]
  );

  // Carrega as pendências só uma vez
  useEffect(() => {
    listarPendencias().then(setPendenciasList);
    // listarPendenciasColeta(dadosCard?.id_coleta_cliente).then(
    //   setCompletedSteps
    // );
    if (dadosCard?.caminho_imagem_endereco_coleta && !dadosCard?.mapImage) {
      baixarAwsBase64(dadosCard?.caminho_imagem_endereco_coleta).then(
        (result) => {
          const resultObject =
            typeof result === "string" ? JSON.parse(result) : result;
          const base64Content = resultObject.base64;
          // setMapImage(`data:image/png;base64,${base64Content}`);
          // setIsLoadingMapImage(false);
          setDadosCard((prev: any) => ({
            ...prev,
            mapImage: `data:image/png;base64,${base64Content}`,
          }));
        }
      );
    }
    listarCondicoesPagamento().then(setCondicoesPagamento);
    listarFormasPagamento().then(setFormasPagamento);
    listarContasBancariasLojas().then(setContasBancariasLojas);

    if (["2", "4"].includes(dadosCard?.tipoNegocio_coleta)) {
      listarServicos()
        .then((res) =>
          setTiposServicos(
            res.filter((tipo: any) => tipo.categoria_tipo_servico == "1")
          )
        )
        .finally(() => setIsLoaded(true));
    } else {
      setIsLoaded(true);
    }
  }, []);

  useEffect(() => {
    if (dadosCard?.todasPendencias_concluidas_coleta === "1") {
      setActiveStep(
        stepsTemp.findLastIndex((a) => a.label === "Projeto Concluído") + 1
      );
      return;
    }
    setActiveStep(+dadosCard?.indexAtual_coleta);
  }, [dadosCard]);

  let canEstornarPreApuracao = false;

  const removePendencie = (pendencia: string) => {
    if (canEstornarPreApuracao) {
      const data = {
        id_coleta: dadosCard?.id_coleta_cliente,
        idPreApuracao: dadosCard?.pre_apuracao_comissao_loja || null,
        id_card: dadosCard?.id,
        id_usuario: usuario.id_usuario,
      };
      estornarPreApuracao(data);
    }
    remConclusaoPendencia({
      id_coleta: dadosCard?.id_coleta_cliente,
      id_etapa: dadosCard?.id_lista,
      id_pendencia: pendencia,
      id_usuario: usuario.id_usuario, // Passar id_usuario para registrar no histórico
    }).then(() => reListarDadosKanban());
  };

  const canEstornar = async (id: string): Promise<boolean> => {
    const currentIndex = stepsTemp.findIndex((item) => item.id == id);
    const targetIndex = stepsTemp.findIndex(
      (a) => a.label === "Pré-apuração de Comissão"
    );
    const objectiveStep = targetIndex + 1;

    try {
      const res = await listarPreApuracoes();

      const filteredApuracao: any = res.find(
        (apuracao: any) => apuracao.cod_negocio_pre_apuracao == idColeta
      );

      if (currentIndex === objectiveStep && filteredApuracao?.status_apuracao) {
        if (
          filteredApuracao.status_apuracao === "0" ||
          filteredApuracao.status_apuracao === "1"
        ) {
          canEstornarPreApuracao = true;
          return true;
        } else {
          toast.error(
            "Não é possível estornar pois a pré-apuração da comissão está na esteira de pagamento ou já foi pago!"
          );
          return false;
        }
      }

      return true;
    } catch (error) {
      console.error("Erro ao verificar estorno:", error);
      toast.error("Erro ao verificar se é possível estornar.");
      return false;
    }
  };

  useEffect(() => {
    if (
      dadosNegocio?.indexAtual_coleta &&
      (dadosNegocio?.indexAtual_coleta != dadosCard.indexAtual_coleta ||
        activeStep != dadosNegocio?.indexAtual_coleta)
    ) {
      setDadosCard((prev: any) => ({
        ...prev,
        indexAtual_coleta: Number(dadosNegocio.indexAtual_coleta),
      }));
    }
  }, [dadosNegocio]);

  const isNextIndex = (index: number, targetIndex: number) => {
    if (index === -1 || index + 2 >= stepsTemp.length) {
      return false;
    }
    return stepsTemp[index + 2].index === targetIndex;
  };

  useEffect(() => {
    if (!blockEditCard) {
      activestepFunction();
    }
  }, [dadosCard, activeStep, stepsTemp]);

  const buscaCliente = async () => {
    setLoading(true);
    return listarDadosCard(
      dadosCard?.id,
      dadosCard?.id_cliente,
      dadosCard?.id_coleta_cliente,
      dadosCard?.financiador
    )
      .then((res) => {
        setCliente(res.dados_cliente);
        setFinanciadorCliente(res.financiador);
        setEtiquetas(res.etiquetas);
        setHistorico(res.historico);
        setLogs(res.log);
        buscaPropostas();
        atualizarContratos();
        atualizarOrdensServico();
        reListarDadosKanban();
        setLoading(false);
        return res;
      })
      .finally(() => setLoading(false));
  };

  const buscaPropostas = async () => {
    const dadosAmpliacao =
      dadosCard.tipoNegocio_coleta === "3"
        ? await buscaDadosAmpliacao({ id_coleta: dadosCard.id_coleta_cliente })
        : {};

    listarCardInfo({ id_card: dadosCard?.id }).then((res) => {
      setActiveStep(Number(res?.indexAtual_coleta));

      setDadosCard((prev: any) => ({ ...prev, ...res, ...dadosAmpliacao }));
    });

    return listarPropostas(dadosCard?.id_coleta_cliente).then((res) => {
      setPropostas(res);
      res.filter((proposta: any) => {
        if (proposta.status_proposta == "1") {
          setPropostaAtiva(res);
          baixarAwsContent(
            proposta.caminho_resultadoPrecificacao_proposta
          ).then((resultadoPrecificacao_proposta) => {
            if (
              resultadoPrecificacao_proposta &&
              resultadoPrecificacao_proposta != "O arquivo não existe"
            ) {
              const resultadoPrecificacao = JSON.parse(
                resultadoPrecificacao_proposta
              );
              setValorProposta(
                resultadoPrecificacao?.preco_venda_final_sem_comissao || 0
              );
              setValorComissaoVendedor(
                (+proposta.percentual_comissao_vendedor_proposta / 100) *
                  +resultadoPrecificacao?.preco_venda_final_sem_comissao || 0
              );
              setValorComissaoGerente(
                (+proposta.percentual_comissao_gerente_proposta / 100) *
                  +resultadoPrecificacao?.preco_venda_final_sem_comissao || 0
              );
              setValorComissaoPreVendedor(
                (+proposta.percentual_comissao_pre_vendedor_proposta / 100) *
                  +resultadoPrecificacao?.preco_venda_final_sem_comissao || 0
              );
              setValorComissaoIndicador(
                (+proposta.percentual_comissao_indicador_proposta / 100) *
                  +resultadoPrecificacao?.preco_venda_final_sem_comissao || 0
              );
              setValorComissaoSupervisor(
                (+proposta.percentual_comissao_supervisor_proposta / 100) *
                  +resultadoPrecificacao?.preco_venda_final_sem_comissao || 0
              );
            }
          });
        }
      });
      // reListarDadosKanban();
      return res;
    });
  };

  async function atualizarContratos() {
    return listarContratosPorColeta(dadosCard?.id_coleta_cliente).then(
      (res) => {
        setColetaContratos(res);
        reListarDadosKanban();
      }
    );
  }

  async function atualizarOrdensServico() {
    return listarOrdensServicoPorColeta(dadosCard?.id_coleta_cliente).then(
      (res) => {
        setOrdensServico(res);
        return res;
      }
    );
  }

  const atualizaDados = () => {
    buscaCliente();
  };

  function getAprovalIndex(id: any, stepsList = stepsTemp) {
    let approvalIndex = 0;

    switch (id) {
      case "0":
        approvalIndex = stepsList.findIndex(
          (step) => step.label === "Aprovação do Contrato"
        );
        break;

      case "1":
        approvalIndex = stepsList.findIndex(
          (step) => step.label === "Aprovação de Crédito"
        );
        break;

      case "2":
        approvalIndex = stepsList.findIndex(
          (step) => step.label === "Finalização da Venda"
        );
        break;

      case "3":
        approvalIndex = stepsList.findIndex(
          (step) => step.label === "Agendamento da Instalação"
        );
        break;

      case "4":
        approvalIndex = stepsList.findIndex(
          (step) => step.label === "Conclusão da Instalação"
        );
        break;

      default:
        break;
    }
    return approvalIndex;
  }

  useEffect(() => {
    if (dadosCard) {
      listarPerfil(session.perfil_usuario).then((res) => setDadosPerfil(res));

      listarTodosKanbans().then((res) => {
        setAllFunis(res);
      });
    }
  }, [dadosCard?.responsaveis]);

  useEffect(() => {
    const funilCorrespondente = allFunis.find(
      (funil) => funil.id_funil === dadosLista.id_funil
    );

    const etapasFiltradas = funilCorrespondente?.listas_kanban.filter(
      (etapa: any) =>
        dadosLista.movimEntreEtapas ||
        dadosLista.movimEntreEtapas.length === 0 ||
        dadosLista.movimEntreEtapas.includes(etapa.id_etapa_funil)
    );

    setFunilOrigimName(funilCorrespondente?.titulo_funil);

    const etapasParaTransporte = etapasFiltradas?.map((etapa: any) => ({
      id: etapa.id_etapa_funil,
      descricao: etapa.titulo_etapa_funil,
    }));

    if (etapasParaTransporte) setEtapasDestinoMovim(etapasParaTransporte);
  }, [allFunis]);

  useEffect(() => {
    if (dadosCard) {
      listarNegocioPeloId(dadosCard?.id_coleta_cliente).then((res) => {
        setDadosNegocio(res);
      });

      listarTiposNegocios().then((res) => {
        const filtrados = res.find((negocio: any) => {
          return negocio.id_tipo_negocio == dadosCard?.tipoNegocio_coleta;
        });
        if (filtrados) {
          setTipoNegocio(filtrados);
        }
      });
      obterFluxosDoNegocio(dadosCard?.id_coleta_cliente, dadosCard?.id).then(
        (res) => {
          setCanDeleteCard(res.length > 0);
          setFluxosDoNegocio(res);
        }
      );

      // if (
      //   dadosCard?.indexAtual_coleta <= 1 &&
      //   dadosCard?.endereco_instalacao_coleta
      // ) {
      //   addConclusaoPendencia({
      //     id_coleta: dadosCard.id_coleta_cliente,
      //     id_etapa: dadosCard.id_lista,
      //     id_pendencia: "1",
      //     id_card: dadosCard.id,
      //   }).then(() => activestepFunction());
      // }
    }
  }, [dadosCard]);

  const handleModalAnexo = () => {
    setOpenModalAnexo(!openModalAnexo);
  };
  const fecharModal = () => {
    formPendenciaEngenharia.reset({});
    setOpenPendenciaEngenharia1(false);
  };

  let propostaAprovada = dadosCard?.propostas.some(
    (proposta: any) => proposta.status_proposta == "1"
  );

  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) {
      console.error("⚠️ Erros de validação:", erros);
    }

    return erros;
  }

  const handleChangeEtapaFunil = async (funil: any) => {
    const etapaDestino = allFunis
      .flatMap((e) =>
        e.id_funil == selectedFunilDestiny ? e.listas_kanban : []
      )
      .find((res: any) => res.id_etapa_funil === funil.etapa_destino);

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

    if (dadosCard?.propostas.length != 0) lockRetrocesso.push(1);

    if (
      dadosCard?.propostas.length != 0 &&
      dadosCard?.propostas.some(
        (proposta: any) => proposta.status_proposta == 1
      )
    ) {
      lockRetrocesso.push(2);
    }

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

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

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

    if (dadosCard?.agendamentos != 0) lockRetrocesso.push("7");
    if (
      dadosCard?.propostas.length != 0 &&
      dadosCard?.propostas.some(
        (proposta: any) => proposta.status_proposta != 3
      )
    )
      lockPermissions.push("5");
    if (
      dadosCard?.propostas.length != 0 &&
      dadosCard?.propostas.some(
        (proposta: any) => proposta.status_proposta == 1
      )
    )
      lockPermissions.push("6");
    if (dadosCard?.contratos.length != 0) lockPermissions.push("7");
    if (
      dadosCard?.contratos.some(
        (contrato: any) => contrato.status_contrato == 1
      )
    )
      lockPermissions.push("8");
    if (dadosCard?.cpfcnpj_cliente) lockPermissions.push("1");
    if (dadosCard?.email_cliente) lockPermissions.push("2");
    if (dadosCard?.rua_cliente) lockPermissions.push("3");
    if (dadosCard?.agendamentos != 0) lockPermissions.push("9");
    // if (dadosCard?.documentos != 0) lockPermissions.push("7");
    if (dadosCard?.latitude && dadosCard?.longitude) lockPermissions.push("4");
    if (dadosCard?.consumo_medio) lockPermissions.push("29");
    if (dadosCard?.uc_coleta) lockPermissions.push("28");
    if (dadosCard?.disjuntor_coleta) lockPermissions.push("35");
    if (dadosCard?.grupo_coleta) lockPermissions.push("27");
    if (dadosCard?.grupo_coleta) lockPermissions.push("26");
    if (dadosCard?.concessionaria_coleta) lockPermissions.push("25");
    if (dadosCard?.tipoLigacao_coleta) lockPermissions.push("24");
    if (dadosCard?.grupo_coleta) lockPermissions.push("23");
    if (dadosCard?.profissao_cliente) lockPermissions.push("22");
    if (dadosCard.disjuntor_coleta) lockPermissions.push("35");

    if (dadosCard?.estadoCivil_cliente) lockPermissions.push("21");
    // if (dadosCard?.notas.length != 0) lockPermissions.push("10");
    if (!dadosCard?.ids_follow_ups_pendentes) lockPermissions.push("10");
    if (+dadosCard?.qtd_follow_ups > 0) lockPermissions.push("11");
    if (
      dadosCard.tipoPessoa_cliente == "F" &&
      dadosCard.dataNascimento_cliente != null &&
      dadosCard.dataNascimento_cliente != "0000-00-00"
    )
      lockPermissions.push("34");
    if (
      dadosCard.tipoPessoa_cliente == "J" &&
      dadosCard.data_aberturaEmpresa_cliente != null &&
      dadosCard.data_aberturaEmpresa_cliente != "0000-00-00"
    )
      lockPermissions.push("34");

    if (dadosCard.qtd_pagamentosCliente != 0) lockPermissions.push("31");
    if (dadosCard.dataFinalizacaoVenda_coleta) lockPermissions.push("32");
    if (dadosCard.data_conclusao_instalacao) lockPermissions.push("33");

    if (dadosCard?.id_lista_card == "1") lockPermissions.push("*");

    if (dadosCard.responsaveis["Administrativo"]) locksResponsaveis.push("1");
    if (dadosCard.responsaveis["Vendedor"]) locksResponsaveis.push("2");
    if (dadosCard.responsaveis["Gerente"]) locksResponsaveis.push("3");
    if (dadosCard.responsaveis["Pré-Vendedor"]) locksResponsaveis.push("4");
    if (dadosCard.responsaveis["Instalador"]) locksResponsaveis.push("5");
    if (dadosCard.responsaveis["Técnico"]) locksResponsaveis.push("6");
    if (dadosCard.responsaveis["Supervisor"]) locksResponsaveis.push("7");

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

          if (
            dadosCard?.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, dadosCard, 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 == dadosCard.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,
      dadosCard.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,
            dadosCard.tipoNegocio_coleta
          ).includes(a) && locksCamposPermissions.push(a)
      );
    } else {
      getArr(
        etapaDestino.camposPersonalizadosLock,
        dadosCard.tipoNegocio_coleta
      ).map(
        (a: any) => !checklist.includes(a) && locksCamposPermissions.push(a)
      );
    }
    const docsGerados = docsPersonalizadosGerados.filter(
      (a: any) => a.codColeta_documento_gerado == dadosCard.id_coleta_cliente
    );
    const documentosLock = dadosCard.documentosLock || [];
    getArr(etapaDestino.documentosLock, dadosCard.tipoNegocio_coleta).forEach(
      (e: any) => {
        const hasDocument = docsGerados.some(
          (doc: any) => doc.codModelo_documento_gerado === e
        );

        if (!hasDocument) {
          locksDocumentosPermissions.push(e);
        }
      }
    );
    // const mergeArraysLocks = [
    //   ...getArr(etapaDestino?.ids_locks, "*"),
    //   ...getArr(etapaDestino.ids_locks, dadosCard.tipoNegocio_coleta),
    // ];
    const mergeArraysLocks = [
      ...getArr(etapaDestino?.locks, "*"),
      ...getArr(etapaDestino.locks, dadosCard.tipoNegocio_coleta),
    ];

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

    const anexosLock = dadosCard?.anexosLock || "";

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

    // const docsGerados = docsPersonalizadosGerados.filter(
    //   (a: any) => a.codColeta_documento_gerado == dadosCard.id_coleta_cliente,
    // );

    const documentosLocks = dadosCard?.documentosLocks || "";
    // getArr(etapaDestino?.docs_locks, dadosCard.tipoNegocio_coleta).map(
    getArr(etapaDestino?.documentosLock, dadosCard.tipoNegocio_coleta).map(
      (e: any) => {
        const hasDocument = docsGerados.some(
          (doc: any) => doc.codModelo_documento_gerado === e
        );

        if (!hasDocument) {
          locksDocumentosPermissions.push(e);
        }
      }
    );

    const commonLocks = getArr(
      // etapaDestino?.ids_locks_retrocesso,
      etapaDestino?.locks_retrocesso,
      dadosCard.tipoNegocio_coleta
    ).filter((lock: string) => lockRetrocesso.includes(lock));

    if (
      commonLocks?.length > 0 &&
      dadosLista.index_lista_kanban > etapaDestino.index_etapa_funil
    ) {
      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",
      });

      // Registrar histórico de ação do card não realizada
      logarAcaoCardNaoRealizada({
        id_card: dadosCard?.id,
        id_usuario: id_usuario,
        motivo: commonLocks
          .map(
            (lock: string) =>
              locksRetrocesso.find((e) => e.id_lock_retrocesso == lock)
                ?.nome_lock_retrocesso
          )
          .filter(Boolean)
          .join(", "),
        acao: openModalChangeFunil[1] || "Movimentação",
        etapa_destino: etapaDestino?.id_etapa_funil,
      }).catch(console.error);

      return;
    }

    const locksResponsaveisNotIn = etapaDestino.locks_responsaveis.filter(
      (lock: string) => !locksResponsaveis.includes(lock)
    );

    if (
      !isAllLocksIn ||
      lockPendencias[0] ||
      locksAnexosPermissions[0] ||
      locksDocumentosPermissions[0] ||
      locksCamposPermissions[0] ||
      locksResponsaveisNotIn[0]
    ) {
      let errorMsg = ``;
      // const locksNotIn = etapaDestino?.ids_locks.filter(
      //   (lock: string) => !lockPermissions.includes(lock),
      // );
      const locksNotIn = mergeArraysLocks.filter(
        (lock: string) => !lockPermissions.includes(lock)
      );
      if (locksNotIn != undefined && 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 ${dadosCard?.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>");
      }

      //  NÃO APAGAR

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

        errorMsg +=
          "<b>Não possui Anexos:</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("Ação não Permitida!", errorMsg, "warning");

      // Registrar histórico de ação do card não realizada
      logarAcaoCardNaoRealizada({
        id_card: dadosCard?.id,
        id_usuario: id_usuario,
        motivo: [
          ...(locksNotIn != undefined && locksNotIn[0]
            ? locksNotIn
                .map(
                  (lock: string) =>
                    locks.find((e) => e.id_lock == lock)?.nome_lock
                )
                .filter(Boolean)
            : []),
          ...(locksAnexosPermissions[0]
            ? locksAnexosPermissions
                .map(
                  (lock: string) =>
                    categoriasAnexos.find((e) => e.id_anexo_crm == lock)
                      ?.identificacao_cfg_anexo
                )
                .filter(Boolean)
            : []),
          ...(locksDocumentosPermissions[0]
            ? locksDocumentosPermissions
                .map(
                  (lock: string) =>
                    documentosPersonalizados.find(
                      (e) => e.id_documento_personalizado == lock
                    )?.nome_documento_personalizado
                )
                .filter(Boolean)
            : []),
        ].join(", "),
        acao: openModalChangeFunil[1] || "Movimentação",
        etapa_destino: etapaDestino?.id_etapa_funil,
      }).catch(console.error);
    } else {
      setIsSubmitting(true);
      if (etapaDestino.paralelizar_etapa_funil == 1) {
        const etapaParalela = await verificaEtapaParalela({
          etapaDestino: etapaDestino.id_etapa_funil,
          tipo_negocio: dadosCard.tipoNegocio_coleta,
        });

        if (etapaParalela.acao != "nenhuma" && etapaParalela) {
          const locksEtapaDestiny = getArr(
            etapaParalela?.locks,
            dadosCard.tipoNegocio_coleta
          );
          // const locksEtapaDestiny =  etapaParalela?.locks?.split(",");
          const compareLocks = locksEtapaDestiny?.every((lock: any) =>
            lockPermissions.includes(lock)
          );
          if (!compareLocks && compareLocks !== undefined) {
            let errorMsg = ``;
            const locksNotIn = locksEtapaDestiny?.filter(
              (lock: string) => !lockPermissions.includes(lock)
            );
            if (locksNotIn) {
              errorMsg +=
                "<b>Não possui:</b> <br>" +
                locksNotIn
                  .map(
                    (lock: string) =>
                      locks.find((e) => e.id_lock == lock)?.nome_lock +
                      `${lock == "10" ? ` ID ${dadosCard?.ids_follow_ups_pendentes} está pendente` : ""}`
                  )
                  .join("<br>");
            }

            // Registrar histórico de automação não realizada
            logarAutomacaoNaoRealizada({
              id_card: dadosCard?.id,
              id_usuario: id_usuario,
              motivo: locksNotIn
                ?.map(
                  (lock: string) =>
                    locks.find((e) => e.id_lock == lock)?.nome_lock
                )
                .filter(Boolean)
                .join(", "),
              etapa_destino: etapaDestino.id_etapa_funil,
            }).catch(console.error);

            Swal.fire("Automatização Não Realizada!", errorMsg, "warning");
            setIsSubmitting(false);
            return;
          } else {
            const data = {
              id_lista: dadosLista.id,
              id_card: dadosCard?.id,
              id_usuario: id_usuario,
              index_card: dadosCard?.index_card,
              funil: dadosLista.id_funil,
              etapa_destino: etapaParalela.etapaDestino,
              acao: etapaParalela.acao,
              funilDestino: etapaParalela.funilDestino,
              titulo_funil: etapaParalela.tituloFunilDestino,
              titulo_etapa_funil: etapaParalela.tituloEtapaDestino,
              id_coleta_cliente: dadosCard?.id_coleta_cliente,
            };

            const dataCopy = {
              coletaCard: dadosCard?.id_coleta_cliente,
              idCardDestino: dadosCard?.id,
              id_usuario: id_usuario,
              funilDestino: etapaParalela.funilDestino,
              etapaDestino: etapaParalela.etapaDestino,
            };

            if (openModalChangeFunil[1] == "Mover") {
              atualizarEtapaFunilNovo(data)
                .then(() => {
                  setOpenModalChangeFunil([false, ""]);
                  // Se o funil destino (da etapa paralela) for diferente do funil atual, muda a rota sem fechar o menu
                  const funilDestinoFinal =
                    etapaParalela.funilDestino || selectedFunilDestiny;
                  if (
                    funilDestinoFinal &&
                    funilDestinoFinal !== String(kanbanId) &&
                    funilDestinoFinal !== String(dadosLista.id_funil)
                  ) {
                    router.push(`CXESCRM002?funil=${funilDestinoFinal}`);
                    // Não chama closeModal() para manter o menuOnView aberto
                  } else {
                    reListarDadosKanban();
                    closeModal();
                  }
                })
                .finally(() => {
                  setIsSubmitting(false);
                });
            } else if (openModalChangeFunil[1] == "Duplicar") {
              setIsSubmitting(true);
              duplicaCard(dataCopy)
                .then(() => {
                  setOpenModalChangeFunil([false, ""]);
                  reListarDadosKanban();
                  closeModal();
                })
                .finally(() => setIsSubmitting(false));
            }
          }
          return;
        }
      }
      const data = {
        id_lista: dadosLista.id,
        id_card: dadosCard?.id,
        id_usuario: id_usuario,
        index_card: dadosCard?.index_card,
        funil: dadosLista.id_funil,
        etapa_destino: funil.etapa_destino,
        id_coleta_cliente: dadosCard?.id_coleta_cliente,
        funilDestino: selectedFunilDestiny,
      };
      const dataCopy = {
        coletaCard: dadosCard?.id_coleta_cliente,
        idCardDestino: dadosCard?.id,
        id_usuario: id_usuario,
        funilDestino: selectedFunilDestiny,
        etapaDestino: funil.etapa_destino,
      };
      if (openModalChangeFunil[1] == "Mover") {
        atualizarEtapaFunilNovo(data)
          .then(() => {
            setOpenModalChangeFunil([false, ""]);
            // Se o funil destino for diferente do funil atual, muda a rota sem fechar o menu
            if (
              selectedFunilDestiny &&
              selectedFunilDestiny !== String(kanbanId) &&
              selectedFunilDestiny !== String(dadosLista.id_funil)
            ) {
              router.push(`CXESCRM002?funil=${selectedFunilDestiny}`);
              // Não chama closeModal() para manter o menuOnView aberto
            } else {
              reListarDadosKanban();
              closeModal();
            }
          })
          .finally(() => {
            setIsSubmitting(false);
          });
      } else if (openModalChangeFunil[1] == "Duplicar") {
        setIsSubmitting(true);
        duplicaCard(dataCopy)
          .then(() => {
            setOpenModalChangeFunil([false, ""]);
            reListarDadosKanban();
            closeModal();
          })
          .finally(() => setIsSubmitting(false));
      }
    }
  };

  const handleChangeEtapa = async (funil: any) => {
    const etapaDestino = allFunis
      .flatMap((e) =>
        e.id_funil == dadosLista.id_funil ? e.listas_kanban : []
      )
      .find((res) => res.id_etapa_funil === funil.etapa_destino);

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

    if (dadosCard?.propostas.length != 0) lockRetrocesso.push("1");

    if (
      dadosCard?.propostas.length != 0 &&
      dadosCard?.propostas.some(
        (proposta: any) => proposta.status_proposta == 1
      )
    )
      lockRetrocesso.push("2");

    if (!(dadosCard.qtd_pagamentosCliente != 0)) lockRetrocesso.push(5);
    if (!dadosCard?.dataFinalizacaoVenda_coleta) lockRetrocesso.push(6);
    if (dadosCard?.status_coleta == 10) lockRetrocesso.push(8);
    if (dadosCard?.status_coleta == 11) lockRetrocesso.push(9);

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

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

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

    if (
      dadosCard?.propostas.length != 0 &&
      dadosCard?.propostas.some(
        (proposta: any) => proposta.status_proposta != 3
      )
    )
      lockPermissions.push("5");
    if (
      dadosCard?.propostas.length != 0 &&
      dadosCard?.propostas.some(
        (proposta: any) => proposta.status_proposta == 1
      )
    )
      lockPermissions.push("6");
    if (dadosCard?.contratos.length != 0) lockPermissions.push("7");
    if (dadosCard?.cpfcnpj_cliente) lockPermissions.push("1");
    if (dadosCard?.email_cliente) lockPermissions.push("2");
    if (dadosCard?.rua_cliente) lockPermissions.push("3");
    if (dadosCard?.agendamentos != 0) lockPermissions.push("9");
    // if (dadosCard?.documentos != 0) lockPermissions.push("7");
    if (dadosCard?.latitude && dadosCard?.longitude) lockPermissions.push("4");
    if (dadosCard?.consumo_medio) lockPermissions.push("29");
    if (dadosCard?.uc_coleta) lockPermissions.push("28");
    if (dadosCard?.rg_cliente) lockPermissions.push("36");
    if (dadosCard?.disjuntor_coleta) lockPermissions.push("35");

    if (dadosCard?.grupo_coleta) lockPermissions.push("27");
    if (dadosCard?.grupo_coleta) lockPermissions.push("26");
    if (dadosCard?.concessionaria_coleta) lockPermissions.push("25");
    if (dadosCard?.tipoLigacao_coleta) lockPermissions.push("24");
    if (dadosCard?.grupo_coleta) lockPermissions.push("23");
    if (dadosCard?.profissao_cliente) lockPermissions.push("22");
    if (dadosCard?.estadoCivil_cliente) lockPermissions.push("21");
    // if (dadosCard?.notas.length != 0) lockPermissions.push("10");
    if (!dadosCard?.ids_follow_ups_pendentes) lockPermissions.push("10");
    if (+dadosCard?.qtd_follow_ups > 0) lockPermissions.push("11");

    if (dadosCard.qtd_pagamentosCliente != 0) lockPermissions.push("31");
    if (dadosCard.dataFinalizacaoVenda_coleta) lockPermissions.push("32");
    if (dadosCard.data_conclusao_instalacao) lockPermissions.push("33");

    if (dadosCard?.id_lista_card == "1") lockPermissions.push("*");

    if (dadosCard.responsaveis["Administrativo"]) locksResponsaveis.push("1");
    if (dadosCard.responsaveis["Vendedor"]) locksResponsaveis.push("2");
    if (dadosCard.responsaveis["Gerente"]) locksResponsaveis.push("3");
    if (dadosCard.responsaveis["Pré-Vendedor"]) locksResponsaveis.push("4");
    if (dadosCard.responsaveis["Instalador"]) locksResponsaveis.push("5");
    if (dadosCard.responsaveis["Técnico"]) locksResponsaveis.push("6");
    if (dadosCard.responsaveis["Supervisor"]) locksResponsaveis.push("7");

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

          if (
            dadosCard?.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, dadosCard, 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 == dadosCard.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,
      dadosCard.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,
            dadosCard.tipoNegocio_coleta
          ).includes(a) && locksCamposPermissions.push(a)
      );
    } else {
      getArr(
        etapaDestino.camposPersonalizadosLock,
        dadosCard.tipoNegocio_coleta
      ).map(
        (a: any) => !checklist.includes(a) && locksCamposPermissions.push(a)
      );
    }
    const docsGerados = docsPersonalizadosGerados.filter(
      (a: any) => a.codColeta_documento_gerado == dadosCard.id_coleta_cliente
    );
    const documentosLock = dadosCard.documentosLock || [];
    getArr(etapaDestino.documentosLock, dadosCard.tipoNegocio_coleta).forEach(
      (e: any) => {
        const hasDocument = docsGerados.some(
          (doc: any) => doc.codModelo_documento_gerado === e
        );

        if (!hasDocument) {
          locksDocumentosPermissions.push(e);
        }
      }
    );
    const mergeArraysLocks = [
      // ...getArr(etapaDestino?.ids_locks, "*"),
      // ...getArr(etapaDestino.ids_locks, dadosCard.tipoNegocio_coleta),
      ...getArr(etapaDestino?.locks, "*"),
      ...getArr(etapaDestino.locks, dadosCard.tipoNegocio_coleta),
    ];

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

    const commonLocks = getArr(
      // etapaDestino?.ids_locks_retrocesso,
      etapaDestino?.locks_retrocesso,
      dadosCard.tipoNegocio_coleta
    ).filter((lock: string) => lockRetrocesso.includes(lock));

    const documentosLocks = dadosCard?.documentosLocks || "";
    // getArr(etapaDestino?.docs_locks, dadosCard.tipoNegocio_coleta).map(
    getArr(etapaDestino?.documentosLock, dadosCard.tipoNegocio_coleta).map(
      (e: any) => {
        if (!documentosLocks.split(",").some((res: any) => res == e)) {
          locksDocumentosPermissions.push(e);
        }
      }
    );

    // return;
    const anexosLock = dadosCard?.anexosLock || "";

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

    if (
      commonLocks.length > 0 &&
      dadosLista.index_lista_kanban > etapaDestino.index_etapa_funil
    ) {
      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",
      });

      // Registrar histórico de ação do card não realizada
      logarAcaoCardNaoRealizada({
        id_card: dadosCard?.id,
        id_usuario: id_usuario,
        motivo: commonLocks
          .map(
            (lock: string) =>
              locksRetrocesso.find((e) => e.id_lock_retrocesso == lock)
                ?.nome_lock_retrocesso
          )
          .filter(Boolean)
          .join(", "),
        acao: "Movimentação na Etapa",
        etapa_destino: etapaDestino?.id_etapa_funil,
      }).catch(console.error);

      return;
    }
    const locksResponsaveisNotIn = etapaDestino.locks_responsaveis.filter(
      (lock: string) => !locksResponsaveis.includes(lock)
    );

    if (
      !isAllLocksIn ||
      lockPendencias[0] ||
      locksAnexosPermissions[0] ||
      locksDocumentosPermissions[0] ||
      locksCamposPermissions[0] ||
      locksResponsaveisNotIn[0]
    ) {
      let errorMsg = ``;
      // const locksNotIn = etapaDestino.ids_locks.filter(
      //   (lock: string) => !lockPermissions.includes(lock),
      // );
      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 ${dadosCard?.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 os documento(s):</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("Ação não Permitida!", errorMsg, "warning");

      // Registrar histórico de ação do card não realizada
      logarAcaoCardNaoRealizada({
        id_card: dadosCard?.id,
        id_usuario: id_usuario,
        motivo: [
          ...(locksNotIn[0]
            ? locksNotIn
                .map(
                  (lock: string) =>
                    locks.find((e) => e.id_lock == lock)?.nome_lock
                )
                .filter(Boolean)
            : []),
          ...(locksAnexosPermissions[0]
            ? locksAnexosPermissions
                .map(
                  (lock: string) =>
                    categoriasAnexos.find((e) => e.id_anexo_crm == lock)
                      ?.identificacao_cfg_anexo
                )
                .filter(Boolean)
            : []),
          ...(locksDocumentosPermissions[0]
            ? locksDocumentosPermissions
                .map(
                  (lock: string) =>
                    documentosPersonalizados.find(
                      (e) => e.id_documento_personalizado == lock
                    )?.nome_documento_personalizado
                )
                .filter(Boolean)
            : []),
        ].join(", "),
        acao: "Movimentação na Etapa",
        etapa_destino: etapaDestino?.id_etapa_funil,
      }).catch(console.error);
    } else {
      setIsSubmitting(true);
      if (etapaDestino.paralelizar_etapa_funil == 1) {
        const etapaParalela = await verificaEtapaParalela({
          etapaDestino: etapaDestino.id_etapa_funil,
          tipo_negocio: dadosCard.tipoNegocio_coleta,
        });
        const locksEtapaDestiny = etapaParalela?.locks?.split(",");
        const compareLocks = locksEtapaDestiny?.every((lock: any) =>
          lockPermissions.includes(lock)
        );
        if (!compareLocks && compareLocks !== undefined) {
          let errorMsg = ``;
          const locksNotIn = locksEtapaDestiny?.filter(
            (lock: string) => !lockPermissions.includes(lock)
          );
          if (locksNotIn) {
            errorMsg +=
              "<b>Não possui:</b> <br>" +
              locksNotIn
                .map(
                  (lock: string) =>
                    locks.find((e) => e.id_lock == lock)?.nome_lock +
                    `${lock == "10" ? ` ID ${dadosCard?.ids_follow_ups_pendentes} está pendente` : ""}`
                )
                .join("<br>");
          }

          // Registrar histórico de automação não realizada
          logarAutomacaoNaoRealizada({
            id_card: dadosCard?.id,
            id_usuario: id_usuario,
            motivo: locksNotIn
              ?.map(
                (lock: string) =>
                  locks.find((e) => e.id_lock == lock)?.nome_lock
              )
              .filter(Boolean)
              .join(", "),
            etapa_destino: etapaDestino.id_etapa_funil,
          }).catch(console.error);

          Swal.fire("Automatização Não Realizada!", errorMsg, "warning");
          setIsSubmitting(false);
          return;
        } else {
          const data = {
            id_lista: dadosLista.id,
            id_card: dadosCard?.id,
            id_usuario: id_usuario,
            index_card: dadosCard?.index_card,
            funil: dadosLista.id_funil,
            etapa_destino: funil.etapa_destino,
            acao: etapaParalela.acao,
            funilDestino: selectedFunilDestiny,
            titulo_funil: etapaParalela.tituloFunilDestino,
            titulo_etapa_funil: etapaParalela.tituloEtapaDestino,
            id_coleta_cliente: dadosCard?.id_coleta_cliente,
          };

          atualizarEtapaFunilNovo(data)
            .then(() => {
              setOpenModalChangeFunil([false, ""]);
              reListarDadosKanban();
              closeModal();
            })
            .finally(() => setIsSubmitting(false));
        }
        return;
      }
      const data = {
        id_lista: dadosLista.id,
        id_card: dadosCard?.id,
        id_usuario: id_usuario,
        index_card: dadosCard?.index_card,
        funil: dadosLista.id_funil,
        etapa_destino: funil.etapa_destino,
        funilDestino: selectedFunilDestiny,
        id_coleta_cliente: dadosCard?.id_coleta_cliente,
      };

      atualizarEtapaFunilNovo(data)
        .then(() => {
          setOpenModalChangeFunil([false, ""]);
          reListarDadosKanban();
          closeModal();
        })
        .finally(() => setIsSubmitting(false));
    }
  };
  async function enviaCampos(pendencia: number) {
    const camposValidos = await formCamposPersonalizados.trigger();
    if (!camposValidos) return false;

    const camposData = formCamposPersonalizados.getValues();
    if (Object.keys(camposData).length > 0) {
      await salvarCamposPersonalizados(camposData, pendencia);
    }
    return true;
  }
  const pagamentoFunction = async (dados: FieldValues) => {
    setIsLoading(true);
    try {
      // Criar FormData para enviar arquivo
      const formData = new FormData();
      formData.append(
        "cod_negocio_pagamento_cliente",
        dadosCard?.id_coleta_cliente
      );
      formData.append("cod_usuario_pagamento_cliente", session?.id_usuario);
      formData.append("id_card", dadosCard?.id);
      formData.append("id_lista", dadosCard?.id_lista);
      formData.append("data_pagamento_cliente", dados.data_pagamento);
      formData.append("obs_pagamento_cliente", dados.obs_pagamento || "");
      formData.append(
        "caminho_anexo_pagamento_cliente",
        `clientes/${cliente?.pasta_cliente}/${dadosCard?.id_coleta_cliente}/PagamentoCliente/${anexoPagamento?.name || "sem_arquivo"}`
      );

      // Adicionar arquivo se existir
      if (anexoPagamento) {
        formData.append("arquivo_pagamento", anexoPagamento);
      }

      return aprovarPagamento(formData)
        .then(() => {
          addConclusaoPendencia({
            id_coleta: dadosCard?.id_coleta_cliente,
            id_etapa: dadosCard?.id_lista,
            id_pendencia: "7",
          }).then((res) => {
            setOpenModalPagamento(false);
            form2.reset();
            setAnexoPagamento(undefined);
            reListarDadosKanban();
          });
        })
        .catch((error: any) => {
          toast.error(error?.message || "Erro ao aprovar pagamento");
        });
    } catch (error: any) {
      toast.error("Erro ao processar formulário: " + error.message);
    } finally {
      setIsLoading(false);
    }
  };

  const finalizarVenda = (
    dataFinalizacaoVenda?: string,
    dataMinimaFinalizacao?: string,
    motivoDataMinima?: string
  ) => {
    const agoraDateTime = new Date()
      .toLocaleString("sv-SE", {
        timeZone: "America/Sao_Paulo",
        hour12: false,
      })
      .replace(" ", "T")
      .slice(0, 16);

    const dataFinalizacao = String(dataFinalizacaoVenda || agoraDateTime)
      .replace(" ", "T")
      .slice(0, 16);

    const dataMinima = String(dataMinimaFinalizacao || "")
      .replace(" ", "T")
      .slice(0, 16);

    if (dataMinima && dataFinalizacao < dataMinima) {
      toast.error(
        `Data de finalização inválida. Não pode ser menor que ${motivoDataMinima || "a data de geração do contrato"}.`
      );
      return;
    }

    if (dataFinalizacao > agoraDateTime) {
      toast.warn(
        "A data de finalização é maior que a data atual. O sistema vai salvar assim mesmo."
      );
    }

    const dataFinalizacaoBackend = `${dataFinalizacao.replace("T", " ")}:00`;

    const data = {
      id_lista: dadosLista.id,
      id_card: dadosCard?.id,
      id_coleta: dadosCard?.id_coleta_cliente,
      status_coleta: 8,
      dataFinalizacaoVenda_coleta: dataFinalizacaoBackend,
      userFinalizaVenda_coleta: session.id_usuario,
      id_pedenciaAtual_coleta: 9,
    };

    fecharVenda(data).then(() => {
      addConclusaoPendencia({
        id_coleta: dadosCard?.id_coleta_cliente,
        id_etapa: dadosCard?.id_lista,
        id_pendencia: "8",
      }).then((res) => {});
      // setActiveStep(activeStep + 1);

      reListarDadosKanban();
    });
  };

  const onSubmitReprovar = (data: FieldValues) => {
    data["id_card"] = dadosCard?.id;
    data["coleta_dados"] = dadosCard?.id_coleta_cliente;
    if (data["motivo_reprovacao"] != "99") {
      data["motivoOutros_proposta"] = "";
    }
    data["id_usuario"] = session.id_usuario;

    if (data?.motivo_detalhado?.length < 10) {
      return toast.error("A descrição deve ter no mínimo 10 caracteres");
    }

    desativarCardColeta(data).then((e: any) => {
      reListarDadosKanban().then(() => {
        setOpenModalRejeicao(false);
        closeModal();
        resetMenu();
      });
    });
  };

  const closeModalRejeicao = () => {
    setOpenModalRejeicao(false);
  };

  const onSubmitNewAgendamentoInstalacao = async (data: any) => {
    const valido = await enviaCampos(11);
    if (!valido) return;
    setIsLoadingAgendamentoInstalacao(true);
    data["codNegocio_instalacao"] = dadosCard?.id_coleta_cliente;
    data["id_usuario"] = session.id_usuario;
    data["instaladores_instalacao"] =
      dadosCard?.responsaveis.Instalador || data.instaladores_instalacao;
    data["id_card"] = dadosCard.id;

    return cadastrarInstalacao(data)
      .then(() => {
        addConclusaoPendencia({
          id_coleta: dadosCard?.id_coleta_cliente,
          id_etapa: dadosCard?.id_lista,
          id_pendencia: "11",
        }).then((res) => {});
        // setActiveStep(activeStep + 1);

        reListarDadosKanban();
        setOpenModalAgendamento(false);
        setOpenModalReAgendamentoInstalacao(false);
      })
      .finally(() => setIsLoadingAgendamentoInstalacao(false));
  };

  const onSubmitNewAgendamentoManutencao = async (data: any) => {
    setIsLoadingAgendamentoManutencao(true);
    data["codNegocio_manutencao"] = dadosCard?.id_coleta_cliente;
    data["id_usuario"] = session.id_usuario;
    // data["instaladores_instalacao"] =
    //   dadosCard?.responsaveis.Instalador || data.instaladores_instalacao;
    data["id_card"] = dadosCard.id;
    data["nome_instalador"] =
      data?.instaladores_manutencao == "0"
        ? "Interno"
        : usuariosResponsaveis?.find(
            (u) => u?.id_usuario == data?.instaladores_manutencao
          )?.nome_usuario || "";

    return agendarManutencao(data)
      .then(() => {
        addConclusaoPendencia({
          id_coleta: dadosCard?.id_coleta_cliente,
          id_etapa: dadosCard?.id_lista,
          id_pendencia: "21",
        }).then((res) => {});
        setActiveStep(activeStep + 1);

        reListarDadosKanban();
        setOpenModalAgendamentoManutencao(false);
      })
      .finally(() => setIsLoadingAgendamentoManutencao(false));
  };

  const onSubmitConclusaoInstalacao = async (data: FieldValues) => {
    const valido = await enviaCampos(13);
    if (!valido) return;
    setIsLoadingAgendamentoInstalacao(true);
    // const formData = new FormData();
    data = {
      ...data,
      codNegocio_conclusao_instalacao: dadosCard?.id_coleta_cliente,
      responsavel_conclusao_instalacao: session.id_usuario,
      caminhos_imagens: data.imagens.map((imagem: File) => ({
        caminho_imagem_conclusao_instalacao: `clientes/${cliente?.pasta_cliente}/${dadosCard?.id_coleta_cliente}/ConclusaoInstalacao/${imagem.name}`,
      })),
      id_card: dadosCard?.id,
    };

    return concluirInstalacao(data)
      .then(() => {
        addConclusaoPendencia({
          id_coleta: dadosCard?.id_coleta_cliente,
          id_etapa: dadosCard?.id_lista,
          id_pendencia: "13",
        }).then((res) => {});
        // activestepFunction();
        // setActiveStep(activeStep + 1);

        setOpenModalConclusaoInstalacao(false);
        reListarDadosKanban();
      })
      .finally(() => setIsLoadingAgendamentoInstalacao(false));
  };

  const onSubmitPagamentoInstalacao = async (data: FieldValues) => {
    const valido = await enviaCampos(14);
    if (!valido) return;
    setIsLoadingAgendamentoInstalacao(true);
    data = {
      ...data,
      codNegocio_pagamento_instalacao: dadosCard?.id_coleta_cliente,
      responsavel_pagamento_instalacao: session.id_usuario,
      id_card: dadosCard?.id,
      caminhos_anexos: data.anexos.map((imagem: File) => ({
        caminho_anexo_pagamento_instalacao: `clientes/${cliente?.pasta_cliente}/${dadosCard?.id_coleta_cliente}/PagamentoInstalacao/${imagem.name}`,
      })),
    };

    return pagarInstalacao(data)
      .then(() => {
        return Promise.all([
          addConclusaoPendencia({
            id_coleta: dadosCard?.id_coleta_cliente,
            id_etapa: dadosCard?.id_lista,
            id_pendencia: "14",
          }).then((res) => {}),
          addConclusaoPendencia({
            id_coleta: dadosCard?.id_coleta_cliente,
            id_etapa: dadosCard?.id_lista,
            id_pendencia: "27",
          }).then((res) => {}),
        ]).then(() => {
          setOpenModalPagamentoInstalacao(false);
          // setActiveStep(activeStep + 1);
          reListarDadosKanban();
        });
      })
      .finally(() => setIsLoadingAgendamentoInstalacao(false));
  };

  const onSubmitPendenciaCompraMaterial = async (data: any, campos: any) => {
    setIsLoading(true);

    delete data["valor_total_item"];
    salvarCamposPersonalizados(campos, 9);

    data = {
      id_card: dadosCard.id,
      id_usuario: usuario.id_usuario,
      material: data,
      id_negocio: dadosCard?.id_coleta_cliente,
    };
    return salvarPendenciaCompraMaterial(data)
      .then((dados) =>
        atualizarCompraMaterialColeta({
          id_negocio: dadosCard?.id_coleta_cliente,
          exigir_pendencia_compra_material_coleta:
            dadosCard?.exigir_pendencia_compra_material_loja_coleta,
          pendencia_compra_material_coleta: dados?.idCodCompraMaterial,
        }).then(() => {
          addConclusaoPendencia({
            id_coleta: dadosCard?.id_coleta_cliente,
            id_etapa: dadosCard?.id_lista,
            id_pendencia: "9",
          }).then((res) => {});
          // setActiveStep(activeStep + 1);

          reListarDadosKanban().then(() => setOpenPendenciaCompras(false));
        })
      )
      .finally(() => {
        setIsLoading(false);
      });
  };

  const onSubmitFaturamento = async (data: any) => {
    const valido = await enviaCampos(16);
    if (!valido) return;
    setIsLoading(true);
    data = {
      id_card: dadosCard?.id,
      id_usuario: usuario.id_usuario,
      faturamentos: data,
    };
    addConclusaoPendencia({
      id_coleta: dadosCard?.id_coleta_cliente,
      id_etapa: dadosCard?.id_lista,
      id_pendencia: "16",
    }).then((res) => {});
    addConclusaoPendencia({
      id_coleta: dadosCard?.id_coleta_cliente,
      id_etapa: dadosCard?.id_lista,
      id_pendencia: "26",
    }).then((res) => {});
    (() => {
      const ordemServicoAtual = ordensServico?.find(
        (ordemServico) => ordemServico?.status_pvos == "1"
      );
      const instaladorInterno = [null, 0, "0"].includes(
        ordemServicoAtual?.is_externo_usuario
      );
      const semTerceiro =
        !ordemServicoAtual?.cod_terceiro_respfin_validacao_execucao_servico;
      const isGarantia =
        !!ordemServicoAtual?.cod_terceiro_respfin_validacao_execucao_servico &&
        ordemServicoAtual?.cod_terceiro_respfin_validacao_execucao_servico ==
          ordemServicoAtual?.codExecutor_pvos;
      if (
        ordemServicoAtual &&
        ((instaladorInterno && semTerceiro) || isGarantia)
      ) {
        addConclusaoPendencia({
          id_coleta: dadosCard?.id_coleta_cliente,
          id_etapa: dadosCard?.id_lista,
          id_pendencia: "32",
        });
        addConclusaoPendencia({
          id_coleta: dadosCard?.id_coleta_cliente,
          id_etapa: dadosCard?.id_lista,
          id_pendencia: "33",
        });
      }
    })();
    return atualizarFaturamentoColeta({
      id_negocio: dadosCard?.id_coleta_cliente,
      exigir_faturamento_loja: dadosCard?.exigir_faturamento_loja_coleta,
      pendencia_faturamento_loja: dadosCard?.pendencia_faturamento_loja,
    })
      .then(() => {
        // setActiveStep(activeStep + 1),
        salvarFaturamento(data).then(() =>
          reListarDadosKanban().then(() => setOpenPendenciaFaturmento(false))
        );
      })
      .finally(() => {
        setIsLoading(false);
      });
  };
  const onSubmitPesquisaSatisfacao = async (data: any) => {
    data = {
      ...data,
      cod_negocio_pesquisa_satisfacao: dadosCard?.id_coleta_cliente,
      tipo_pesquisa_satisfacao: openPendenciaPesquisaSatisfacao1
        ? "1"
        : openPendenciaPesquisaSatisfacao2
          ? "2"
          : "",
    };
    const idPendencia = ["2", "4"].includes(dadosCard?.tipoNegocio_coleta)
      ? "28"
      : openPendenciaPesquisaSatisfacao1
        ? "17"
        : openPendenciaPesquisaSatisfacao2
          ? "18"
          : "";
    const valido = await enviaCampos(Number(idPendencia));
    if (!valido) return;
    await cadastrarPesquisa(data);
    openPendenciaPesquisaSatisfacao1
      ? setOpenPendenciaPesquisaSatisfacao1(false)
      : setOpenPendenciaPesquisaSatisfacao2(false);

    await addConclusaoPendencia({
      id_coleta: dadosCard?.id_coleta_cliente,
      id_etapa: dadosCard?.id_lista,
      id_pendencia: idPendencia,
    });
    // setActiveStep(activeStep + 1);
    reListarDadosKanban();
  };
  const onSubmitPendenciaEgenharia = async (data: any) => {
    // const valido = await enviaCampos(Number(openPendenciaEngenharia1 ? "10" : "19")); // await aqui
    // console.log('rer', valido)
    // if (!valido) return;
    setIsLoading(true);
    data = {
      id_coleta: dadosCard?.id_coleta_cliente,
      id_card: dadosCard.id,
      id_usuario: usuario.id_usuario,
      itensEngenharia: data,
      engenharia: openPendenciaEngenharia1
        ? "1"
        : openPendenciaEngenharia2
          ? "2"
          : "",
    };

    return atualizarEngenhariaNegocio({
      id_negocio: dadosCard?.id_coleta_cliente,
      pendencia_engenharia_coleta: dadosCard?.pendencia_engenharia_loja_coleta,
    })
      .then(() =>
        salvarPendenciaEngenhariaNegocio(data).then(
          () =>
            // reListarDadosKanban().then(() => {
            {
              addConclusaoPendencia({
                id_coleta: dadosCard?.id_coleta_cliente,
                id_etapa: dadosCard?.id_lista,
                id_pendencia: openPendenciaEngenharia1 ? "10" : "19",
              }).then(() => {
                openPendenciaEngenharia1
                  ? fecharModal()
                  : setOpenPendenciaEngenharia2(false);

                // setActiveStep(activeStep + 1);
              });
            }
          // })
        )
      )
      .finally(() => {
        reListarDadosKanban();
        setIsLoading(false);
      });
  };

  const onSubmitPendenciaEntregaKit = async (data: any) => {
    const valido = await enviaCampos(15);
    if (!valido) return;
    setIsLoading(true);
    data["id_card"] = dadosCard?.id;

    return salvarPendenciaEntregaKit(data)
      .then(() => {
        addConclusaoPendencia({
          id_coleta: dadosCard?.id_coleta_cliente,
          id_etapa: dadosCard?.id_lista,
          id_pendencia: "15",
        }).then((res) => {
          setActiveStep(activeStep + 1);

          reListarDadosKanban().then(() => {
            setOpenEntregaKit(false);
          });
        });
      })
      .finally(() => {
        setIsLoading(false);
      });
  };

  const renderTabContent = useCallback(
    (idAbaCard: string) => {
      switch (idAbaCard) {
        case "1":
          return (
            <div className="grid max-sm:flex text-sm max-sm:mb-2 lg:flex gap-4 justify-center xl:justify-between top-0 w-full h-full">
              <CardFluxos
                dadosLista={dadosLista}
                dadosCard={dadosCard}
                dadosCliente={cliente}
                etapasFunil={etapasFunil}
              />
              <FluxoInfo
                cardLocks={cardLocks}
                dadosLista={dadosLista}
                dadosCard={dadosCard}
                closeModal={closeModal}
              />
            </div>
          );
        case "2":
          return (
            <ContatoCard
              dadosCard={dadosCard}
              dadosCliente={cliente}
              closeModal={closeModal}
              blockEditCard={blockEditCard}
            />
          );
        case "3":
          return (
            <Map
              perfil={perfil}
              dadosCard={dadosCard}
              setDadosCard={setDadosCard}
              setActiveStep={setActiveStep}
              dadosCliente={cliente}
              propostas={propostas}
              idPendencia={idAbaCard}
              buscaPropostas={buscaPropostas}
              coletaContratos={coletaContratos}
              idColeta={idColeta}
              disabledMap={blockEditCard}
            />
          );
        case "4":
          return dadosCard?.tipoNegocio_coleta === "3" ? (
            <DadosTecnicos
              dadosCard={dadosCard}
              setDadosCard={setDadosCard}
              steps={stepsTemp}
              dadosCliente={cliente}
              proposta={propostas.find(
                (proposta) => proposta.status_proposta == "1"
              )}
              blockEditCard={
                blockEditCard ||
                propostas.find((proposta) => proposta.status_proposta == "1") ||
                activeStep === 1
              }
              buscaPropostas={buscaPropostas}
              setActiveStepAtual={setActiveStep}
              activeStep={activeStep}
            />
          ) : (
            <NegocioCard
              dadosCard={dadosCard}
              setDadosCard={setDadosCard}
              steps={stepsTemp}
              dadosCliente={cliente}
              proposta={propostas.find(
                (proposta) => proposta.status_proposta == "1"
              )}
              blockEditCard={blockEditCard}
              buscaPropostas={buscaPropostas}
              setActiveStepAtual={setActiveStep}
              activeStep={activeStep}
            />
          );
        case "5":
          return (
            <div
              className={blockEditCard ? "pointer-events-none select-none" : ""}
            >
              <PropostasTab
                dadosCard={dadosCard}
                dadosCliente={cliente}
                propostas={propostas}
                buscaPropostas={buscaPropostas}
                coletaContratos={coletaContratos}
                setActiveStepAtual={setActiveStep}
                activeStep={activeStep}
                setDadosCard={setDadosCard}
                condicoesPagamento={condicoesPagamento}
                formasPagamento={formasPagamento}
                contasBancariasLojas={contasBancariasLojas}
                tiposServicos={tiposServicos}
              />
            </div>
          );
        case "6":
          return (
            <div
              className={blockEditCard ? "pointer-events-none select-none" : ""}
            >
              <Contratos
                dadosCard={dadosCard}
                usuarios={usuariosResponsaveis}
                dadosCliente={financiadorCliente || cliente}
                proposta={propostas.find(
                  (proposta) => proposta.status_proposta === "1"
                )}
                ucsColeta={ucsColeta}
                stepsTemp={stepsTemp}
                setPropostas={setPropostas}
                coletaContratos={coletaContratos}
                atualizarContratosColeta={atualizarContratos}
                buscaPropostas={buscaPropostas}
                compareActiveStep={compareActiveStep}
                setActiveStepAtual={setActiveStep}
                activeStep={activeStep}
                setDadosNegocio={setDadosNegocio}
                formasPagamento={formasPagamento}
                contasBancariasLojas={contasBancariasLojas}
                condicoesPagamento={condicoesPagamento}
              />
            </div>
          );
        case "7":
          return (
            <DocumentosPersonalizados
              dadosCard={dadosCard}
              blockEditCard={blockEditCard}
              dadosProposta={propostas.find(
                (proposta) => proposta.status_proposta === "1"
              )}
              dadosCliente={cliente}
              dadosLista={dadosLista}
            />
          );
        // case "8":
        //   return (
        //     <ComplementosCard dadosCard={dadosCard} dadosCliente={cliente} />
        //   );
        case "9":
          return (
            // <NotasOnCard
            //   dadosCard={dadosCard}
            //   setNotas={setNotas}
            //   notas={notas}
            //   blockEditCard={blockEditCard}
            //   form={form}
            //   id_usuario={id_usuario}
            // />
            <FollowUpCard
              dadosCard={dadosCard}
              setNotas={setNotas}
              notas={notas}
              blockEditCard={blockEditCard}
              isFluxoPerdas={noFluxoPerdas}
              form={form}
              id_usuario={id_usuario}
            />
          );
        case "11":
          return (
            <Historico
              dadosLogs={logs}
              setLogs={setLogs}
              changeTab={activeTab[1]}
              dadosHistorico={historico}
              dataCard={dadosCard}
              selectedUsers={selectedUsers}
              setSelectedUsers={setSelectedUsers}
              selectedCategoria={selectedCategoria}
              setSelectedCategoria={setSelectedCategoria}
              dateInicio={dateInicio}
              setDateInicio={setDateInicio}
              dateFim={dateFim}
              setDateFim={setDateFim}
            />
          );
        case "12":
          return (
            <div>
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="4"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
              >
                {!blockEditCard && (
                  <Button
                    type="submit"
                    // onClick={salvarCamposPersonalizados}
                    className="px-4 xl:w-fit  w-full py-1"
                  >
                    Salvar
                  </Button>
                )}
              </CamposPersonalizados>
            </div>
          );
        case "13":
          return (
            <ObsColeta
              dadosCard={dadosCard}
              form={form}
              dadosCliente={cliente}
              blockEditCard={blockEditCard}
            />
          );
        case "14":
          return (
            <div
              className={blockEditCard ? "pointer-events-none select-none" : ""}
            >
              <OrdensServico
                dadosCard={dadosCard}
                usuarios={usuariosResponsaveis}
                dadosCliente={financiadorCliente || cliente}
                proposta={propostas.find(
                  (proposta) => proposta.status_proposta === "1"
                )}
                contrato={coletaContratos?.find(
                  (contrato) => contrato.status_contrato === "1"
                )}
                buscaPropostas={buscaPropostas}
                compareActiveStep={compareActiveStep}
                setActiveStepAtual={setActiveStep}
                activeStep={activeStep}
                stepsTemp={stepsTemp}
                setDadosNegocio={setDadosNegocio}
                ordensServico={ordensServico}
                atualizarOrdensServico={atualizarOrdensServico}
                openModalBaixarOrdemServico={openModalBaixarOrdemServico}
                setOpenModalBaixarOrdemServico={setOpenModalBaixarOrdemServico}
                ordemServicoSelecionada={ordemServicoSelecionada}
                setOrdemServicoSelecionada={setOrdemServicoSelecionada}
                openModalGeracaoOS={openModalGeracaoOS}
                setOpenModalGeracaoOS={setOpenModalGeracaoOS}
                openModalVisualizarOrdemServico={
                  openModalVisualizarOrdemServico
                }
                setOpenModalVisualizarOrdemServico={
                  setOpenModalVisualizarOrdemServico
                }
              />
            </div>
          );
      }
    },
    // [dadosCard, cliente, dadosLista, logs]
    [
      dadosCard,
      cliente,
      cardLocks,
      dadosLista,
      perfil,
      propostas,
      coletaContratos,
      idColeta,
      blockEditCard,
      activeStep,
      stepsTemp,
      financiadorCliente,
      notas,
      id_usuario,
      logs,
      activeTab,
      historico,
      formCamposPersonalizados,
      ordensServico,
      openModalBaixarOrdemServico,
      ordemServicoSelecionada,
    ]
  );

  function compareActiveStep(
    stepName: string,
    comparator = "==",
    stepsList = stepsTemp
  ) {
    const step = stepsList.find((step: any) => step.label === stepName);

    const stepIndex = step?.index ?? -1;

    return eval(`${activeStep} ${comparator} ${stepIndex}`);
  }

  const calcularComissao = (e: any) => {
    let porcentagem = e?.target.value.replace(",", ".");

    const valorComissao = (+porcentagem / 100) * valorProposta;

    switch (e?.target.name) {
      case "comissao_vendedor_pre_apuracao":
        setValorComissaoVendedor(valorComissao);
        break;
      case "comissao_preVendedor_pre_apuracao":
        setValorComissaoPreVendedor(valorComissao);
        break;
      case "comissao_gerente_pre_apuracao":
        setValorComissaoGerente(valorComissao);
        break;
      case "comissao_indicador_pre_apuracao":
        setValorComissaoIndicador(valorComissao);
        break;
      case "comissao_supervisor_pre_apuracao":
        setValorComissaoSupervisor(valorComissao);
      default:
        break;
    }
  };
  const totalComissao =
    valorProposta +
      valorComissaoGerente +
      valorComissaoIndicador +
      valorComissaoPreVendedor +
      valorComissaoVendedor +
      valorComissaoSupervisor +
      +propostaAtiva[0]?.valor_comissao_indicador_proposta || 0;

  const reabreProjeto = () => {
    handleSweetAlert(
      {
        icon: "question",
        title: "Deseja reabrir o projeto?",
        input: "checkbox",
        inputValue: 0,
        inputPlaceholder: `<span style="font-size: 14px; line-height: 4px">Estou ciente que estou reabrindo o projeto. </span>`,
        inputValidator: (result: any) => {
          return !result && "Você precisa concordar para reabrir!";
        },
      },
      () => {
        removePendencie("20");

        setActiveStep(activeStep - 1);
        setBlockEditCard(false);
        // reListarDadosKanban();
      }
    );
  };

  const [visualizaEngenharia, setVisualizaEngenharia] = useState(null);
  const [visualizaPesquisa, setVisualizaPesquisa] = useState(null);
  const [
    openModalVisualizaPesquisaSatisfacao,
    setOpenModalVisualizaPesquisaSatisfacao,
  ] = useState(false);

  const dataFinalizacaoVenda =
    dadosNegocio?.dataFinalizacaoVenda_coleta ||
    dadosCard?.dataFinalizacaoVenda_coleta;
  const usuarioFinalizaVendaId =
    dadosNegocio?.userFinalizaVenda_coleta ||
    dadosCard?.userFinalizaVenda_coleta;
  const usuarioFinalizaVenda =
    usuarios.find(
      (user: any) => String(user.id_usuario) === String(usuarioFinalizaVendaId)
    ) ||
    todosUsuarios.find(
      (user: any) => String(user.id_usuario) === String(usuarioFinalizaVendaId)
    );

  const dataFinalizacaoVendaFormatada = dataFinalizacaoVenda
    ? new Date(String(dataFinalizacaoVenda).replace(" ", "T")).toLocaleString(
        "pt-BR"
      )
    : "Não informada";

  const nomeUsuarioFinalizacao =
    usuarioFinalizaVenda?.nome_usuario ||
    usuarioFinalizaVenda?.nome ||
    (usuarioFinalizaVendaId ? `ID ${usuarioFinalizaVendaId}` : "Não informado");

  const podeEditarDataFinalizacaoVenda =
    session.perfil_usuario == "1000" ||
    dadosPerfil?.editar_data_finalizacao_venda_perfil == "1";
  const [editandoDataFinalizacaoVenda, setEditandoDataFinalizacaoVenda] =
    useState(false);
  const [novaDataFinalizacaoVenda, setNovaDataFinalizacaoVenda] = useState("");

  const abrirEdicaoDataFinalizacaoVenda = () => {
    setNovaDataFinalizacaoVenda(
      dataFinalizacaoVenda
        ? String(dataFinalizacaoVenda).replace(" ", "T").slice(0, 16)
        : ""
    );
    setEditandoDataFinalizacaoVenda(true);
  };

  /**
   * Data de GERAÇÃO do contrato = contratos.data_geracao_contrato (o "Data
   * Gerado" do card de contratos). NÃO usar:
   *   - data_hora_aprovacao  -> "Data Aprovação"
   *   - data_contrato        -> "Data Incluido no sistema" (só fallback, quando
   *                             o contrato antigo não tem data_geracao_contrato)
   * Contrato gerado no fim do mês e aprovado/incluído só no mês seguinte tem que
   * finalizar a venda no mês da GERAÇÃO.
   *
   * Considera SÓ o contrato aprovado/vigente (status_contrato == 1). Contrato em
   * elaboração ou substituído não pode ditar a data da venda; sem nenhum
   * aprovado, quem responde é o fallback de proposta/negócio no
   * obterDataMinimaFinalizacaoVenda.
   */
  const obterDataGeracaoContrato = (contratosOverride?: any[]) => {
    // data_geracao_contrato é gravada como data pura ("2026-07-31") pelo form de
    // geração; completa com 00:00:00 para virar datetime válido nos campos e na
    // comparação com a data de finalização.
    const dataDe = (c: any) => {
      const bruta = c?.data_geracao_contrato || c?.data_contrato;
      if (!bruta) return null;
      const texto = String(bruta).trim();
      return texto.length <= 10 ? `${texto} 00:00:00` : texto;
    };
    const aprovados = (contratosOverride ?? coletaContratos ?? []).filter(
      (c: any) => String(c?.status_contrato) === "1" && dataDe(c)
    );
    if (!aprovados.length) return null;

    const emMs = (c: any) =>
      new Date(String(dataDe(c)).replace(" ", "T")).getTime();

    return dataDe(
      [...aprovados].sort((a: any, b: any) => emMs(a) - emMs(b))[0]
    );
  };

  const obterDataMinimaFinalizacaoVenda = (contratosOverride?: any[]) => {
    const dataGeracaoContrato = obterDataGeracaoContrato(contratosOverride);
    if (dataGeracaoContrato) {
      return {
        data: dataGeracaoContrato,
        motivo: "a data de geração do contrato",
      };
    }

    const propostaAprovada = (propostas || []).find(
      (p: any) => p.status_proposta == "1" && p.data_proposta
    );
    if (propostaAprovada) {
      return {
        data: propostaAprovada.data_proposta,
        motivo: "a data de geração da proposta aprovada",
      };
    }

    const propostasComData = (propostas || []).filter(
      (p: any) => p.data_proposta
    );
    if (propostasComData.length) {
      const primeiraProposta = [...propostasComData].sort(
        (a: any, b: any) =>
          new Date(String(a.data_proposta).replace(" ", "T")).getTime() -
          new Date(String(b.data_proposta).replace(" ", "T")).getTime()
      )[0];
      return {
        data: primeiraProposta.data_proposta,
        motivo: "a data de geração da primeira proposta",
      };
    }

    if (dadosCard?.datetime_coleta) {
      return {
        data: dadosCard.datetime_coleta,
        motivo: "a data de criação do negócio",
      };
    }

    return null;
  };

  const salvarEdicaoDataFinalizacaoVenda = () => {
    if (!novaDataFinalizacaoVenda) {
      toast.error("Informe uma data válida.");
      return;
    }

    const limiteData = obterDataMinimaFinalizacaoVenda();
    if (limiteData) {
      const dataLimite = new Date(String(limiteData.data).replace(" ", "T"));
      const dataEscolhida = new Date(novaDataFinalizacaoVenda);
      if (dataEscolhida < dataLimite) {
        toast.error(
          `Data de Finalização da Venda inválida. Não pode ser menor que ${limiteData.motivo} (${dataLimite.toLocaleString("pt-BR")}).`
        );
        return;
      }
    }

    const dataFinalizacaoBackend = `${novaDataFinalizacaoVenda.replace("T", " ")}:00`;

    editarDataFinalizacaoVenda({
      id_coleta: dadosCard?.id_coleta_cliente,
      id_lista: dadosLista?.id,
      id_usuario: session.id_usuario,
      dataFinalizacaoVenda_coleta: dataFinalizacaoBackend,
    }).then(() => {
      toast.success("Data de Finalização da Venda atualizada com sucesso!");
      setEditandoDataFinalizacaoVenda(false);
      reListarDadosKanban();
    });
  };

  const stepsMap = [
    { label: "Liberação para Compras", action: setOpenVisualizaCompraMaterial },
    { label: "Faturamento", action: setOpenVisualizaFaturamento },
    {
      label: "Aprovação Engenharia 1",
      action: setOpenVisualizaPendenciaEngenharia,
      subAction: setVisualizaEngenharia,
      id: "1",
      permission: "permite_finalizar_pendencia_engenharia_perfil",
    },
    {
      label: "Aprovação Engenharia 2",
      action: setOpenVisualizaPendenciaEngenharia,
      subAction: setVisualizaEngenharia,
      id: "2",
      permission: "permite_finalizar_pendencia_engenharia_perfil2",
    },
    { label: "Entrega Efetuada", action: setOpenVisualizaEntregaKit },
    {
      label: "Agendamento da Instalação",
      action: setOpenVisualizaAgendamentosInstalacoes,
      permission: "permite_agendar_instalacoes_perfil",
    },
    {
      label: "Conclusão da Instalação",
      action: setOpenVisualizaConclusaoInstalacao,
      permission: "permite_concluir_instalacoes_perfil",
    },
    {
      label: "Liberação para Pagamento da Instalação",
      action: setOpenVisualizaPagamentoInstalacao,
      permission: "permite_pagar_instalacoes_perfil",
    },
    {
      label: "Aprovação de Crédito",
      action: setOpenModalVisualizaPagamento,
      permission: "finalizar_pagamento_perfil",
    },
    {
      label: "Finalização da Venda",
      action: setOpenModalVisualizaFinalizacaoVenda,
      permission: "finalizar_vendas_perfil",
    },
    {
      label: "Liberação para Comissão",
      action: setOpenModalVisualizaPreApuracao,
      permission: "permite_pre_apurar_comissoes_perfil",
    },
    {
      label: "Pesquisa de Satisfação 1",
      action: setOpenModalVisualizaPesquisaSatisfacao,
      subAction: setVisualizaPesquisa,
      id: "1",
      permission: "permite_realizar_pesquisa_satisfacao1",
    },
    {
      label: "Pesquisa de Satisfação",
      action: setOpenModalVisualizaPesquisaSatisfacao,
      subAction: setVisualizaPesquisa,
      id: "1",
      permission: "permite_realizar_pesquisa_satisfacao1",
    },
    {
      label: "Pesquisa de Satisfação 2",
      action: setOpenModalVisualizaPesquisaSatisfacao,
      subAction: setVisualizaPesquisa,
      id: "2",
      permission: "permite_realizar_pesquisa_satisfacao2",
    },
    {
      label: "Agendamento da Manutenção",
      action: setOpenVisualizaAgendamentoManutencao,
      permission: "permite_agendar_manutencoes_perfil",
    },
    {
      label: "Geração de OS",
      action: () => {
        const ordemServico = ordensServico[0];
        setActiveTab;
        if (ordemServico) {
          setOrdemServicoSelecionada(ordemServico);
          setOpenModalVisualizarOrdemServico(true);
        }
      },
      permission: "permite_gerar_os_perfil",
    },
    {
      label: "Baixa da OS (Instalador)",
      action: () => {
        const ordemServico = ordensServico?.find(
          (ordemServico) => ordemServico?.status_pvos == "1"
        );
        if (ordemServico) {
          setOrdemServicoSelecionada(ordemServico);
          setOpenModalBaixarOrdemServico(true);
          setActiveTab(["14", ""]);
        }
      },
      permission: "permite_baixar_os_perfil",
    },
    {
      label: "Custos do Serviço OS (Instalador)",
      action: () => {
        // setActiveTab(["14", ""]);
        const ordemServico = ordensServico?.find(
          (ordemServico) => ordemServico?.status_pvos == "1"
        );
        if (ordemServico) {
          setOrdemServicoSelecionada(ordemServico);
          setOpenModalCustosOrdemServico(true);
          // setActiveTab(["14", ""]);
        }
      },
      permission: "permite_informar_custos_os_perfil",
    },
    {
      label: "Validação da OS/Custos",
      action: () => {
        // setActiveTab(["14", ""]);
        const ordemServico = ordensServico?.find(
          (ordemServico) => ordemServico?.status_pvos == "1"
        );
        if (ordemServico) {
          setOrdemServicoSelecionada(ordemServico);
          // setOpenModalValidacaoOrdemServico(true);
          setOpenModalVisualizacaoValidacaoOrdemServico(true);
          // setActiveTab(["14", ""]);
        }
      },
      permission: "permite_validar_os_custos_perfil",
    },
    {
      label: "Liberação Pagamento do Terceirizado",
      action: () => {
        const ordemServico = ordensServico?.find(
          (ordemServico) => ordemServico?.status_pvos == "1"
        );
        Swal.fire({
          icon: "info",
          title: "Liberação Pagamento do Terceirizado",
          html: ordemServico?.data_liberacao_pagamento_execucao_servico
            ? `Liberado em: <b>${new Date(
                ordemServico.data_liberacao_pagamento_execucao_servico
              ).toLocaleDateString("pt-BR")}</b>`
            : "Ainda não liberado.",
          confirmButtonText: "Ok",
          confirmButtonColor: "#4CAF50",
        });
      },
      permission: "permite_liberar_pagamento_terceirizado",
    },
    {
      label: "Pagamento do Terceirizado",
      action: () => {
        const ordemServico = ordensServico?.find(
          (ordemServico) => ordemServico?.status_pvos == "1"
        );
        if (ordemServico) {
          setOrdemServicoSelecionada(ordemServico);
          setOpenModalPagamentoCobrancaTerceiro(true);
        }
      },
      permission: "permite_pagar_terceirizado",
    },
    {
      label: "Reabrir Projeto",
      final: 1,
      action: reabreProjeto,
      permission: "permite_reabrir_projeto_concluido",
    },
  ];

  const renderButton = ({
    label,
    action,
    permission,
    subAction,
    extraCheck,
    id,
    final,
  }: any) => {
    if (
      final !== 1 &&
      final !== 99 &&
      !stepsTemp.some((step) => step.label === label)
    )
      return null;

    const hasPermission =
      !permission ||
      session.perfil_usuario == "1000" ||
      dadosPerfil?.[permission] == "1";
    if (
      dadosCard.tipoNegocio_coleta === "3" &&
      final !== 99 &&
      !inseridoDadosAmpliacao
    )
      return null;

    if (label === "Adicionar Informações do sistema" && inseridoDadosAmpliacao)
      return null;
    if (
      label === "Reabrir Projeto" &&
      (!blockEditCard || responsaveisInativos.length > 0)
    ) {
      return null;
    }

    let isStepValid =
      compareActiveStep(label, ">") && (!extraCheck || extraCheck(dadosCard));
    if (label === "Reabrir Projeto" && blockEditCard) {
      isStepValid = true;
    }
    if (!hasPermission) return null;
    if (label === "Aprovação de Crédito") {
      label = "Aprovação de Crédito";
    }
    return (
      <div key={label}>
        <Button
          onClick={() => {
            if (final === 1 || final === 99) {
              action();
            } else {
              subAction && subAction(id);
              action(true);
            }
          }}
          className="text-xs rounded-md w-full whitespace-nowrap bg-primary disabled:bg-secondary font-normal"
          disabled={!isStepValid}
        >
          <FaInfoCircle className="mr-2" />
          {label}
        </Button>
      </div>
    );
  };

  async function onSubmitContatoCliente(data: any) {
    switch (data.feedback) {
      case "1":
        return salvarContatoClienteColeta({
          id_usuario: usuario?.id_usuario,
          id_coleta: dadosCard?.id_coleta_cliente,
          dataContato_cliente_coleta: data.dataContato_cliente_coleta,
          obsContato_cliente_coleta: data.obsContato_cliente_coleta,
        }).then(async () => {
          return addConclusaoPendencia({
            id_coleta: dadosCard?.id_coleta_cliente,
            id_etapa: dadosCard?.id_lista,
            id_pendencia: "31",
          }).then(async (res) => {
            setActiveStep(activeStep + 1);

            return reListarDadosKanban().then(() => {
              setOpenModalContatoCliente(false);
            });
          });
        });
        break;

      case "2":
        return editarDataContato({
          id_usuario: usuario?.id_usuario,
          id_coleta: dadosCard?.id_coleta_cliente,
          dataContato_coleta: data?.dataFutura,
          obsContato_cliente_coleta: data?.obsContato_cliente_coleta,
        }).then(async () => {
          return reListarDadosKanban().then(() => {
            setOpenModalContatoCliente(false);
          });
        });
        break;

      case "3":
        return setOpenModalCancelamento(true);
        break;

      default:
        break;
    }
    return;
  }

  return (
    <div style={{ scale: isMobile ? "0.99" : "1" }}>
      {loading ? (
        <div
          style={{ height: "calc(-190px + 100vh)" }}
          className="flex items-center max-sm:h-[90vh] justify-center"
        >
          <div className="max-sm:w-[90px]">
            <LoaderSun width="155" />
          </div>
        </div>
      ) : (
        <>
          {kanbanId != 0 && (
            <>
              <div className="flex items-center mb-3 p-1 ">
                <div className="flex items-center max-md:hidden flex-wrap  gap-2 rounded-md px-3 py-2 cursor-pointer text-xs justify-center text-center space-x-4 ml-2">
                  {dadosCard?.resumoIa_coleta && (
                    <Button
                      onClick={() => {
                        setOpenModalVisualizaResumoIA(true);
                      }}
                      className="text-xs rounded-md gap-3 flex items-center bg-primary disabled:bg-secondary font-normal"
                    >
                      Resumo IA <Sparkles size={15} />
                    </Button>
                  )}
                  {perfil.visualiza_pendencias_realizadas_perfil == "1" &&
                    [...stepsMap]
                      .sort((a, b) => {
                        const indexA =
                          stepsTemp.find((s) => s.label === a.label)?.index ??
                          0;
                        const indexB =
                          stepsTemp.find((s) => s.label === b.label)?.index ??
                          0;

                        return indexA - indexB;
                      })
                      .map(renderButton)}
                  <ModalComponente
                    defaultW="w-[600px]"
                    header="Informações da Aprovação de Crédito"
                    onClose={() =>
                      setOpenModalVisualizaPagamento(
                        !openModalVisualizaPagamento
                      )
                    }
                    hasSaveButton={false}
                    hasForm={false}
                    opened={openModalVisualizaPagamento}
                  >
                    <InformacoesPagamentoCliente dadosNegocio={dadosNegocio} />
                    <CamposPersonalizados
                      formulario={formCamposPersonalizados}
                      dataCard={dadosCard}
                      // handleSubmit={handleSubmit}
                      blockEditCard={blockEditCard}
                      onSubmitFunction={salvarCamposPersonalizados}
                      localCampo="5"
                      idLoja={dadosCard?.id_loja_coleta}
                      tipoNegocio={dadosCard?.tipoNegocio_coleta}
                      pendenciaID={7}
                    />
                  </ModalComponente>

                  <ModalComponente
                    defaultW="w-[900px]"
                    header="Informações Pré-apuração"
                    onClose={() =>
                      setOpenModalVisualizaPreApuracao(
                        !openModalVisualizaPreApuracao
                      )
                    }
                    hasSaveButton={false}
                    hasForm={false}
                    opened={openModalVisualizaPreApuracao}
                  >
                    <InformacoesPreApuracao
                      usuariosResponsaveis={usuariosResponsaveis}
                      preApuracaoValues={preApuracaoValues}
                      indicadores={indicadores}
                    />
                  </ModalComponente>

                  <ModalComponente
                    defaultW="w-[600px]"
                    header="Informações da Finalização da Venda"
                    onClose={() =>
                      setOpenModalVisualizaFinalizacaoVenda(
                        !openModalVisualizaFinalizacaoVenda
                      )
                    }
                    hasSaveButton={false}
                    hasForm={false}
                    opened={openModalVisualizaFinalizacaoVenda}
                  >
                    <div className="flex flex-col gap-3">
                      <div className="text-lg font-semibold">
                        Finalização da Venda
                      </div>

                      <div className="border rounded-md p-3 bg-gray-50">
                        <div className="flex items-center justify-between">
                          <div className="text-sm text-gray-500">Data</div>
                          {podeEditarDataFinalizacaoVenda &&
                            !editandoDataFinalizacaoVenda && (
                              <button
                                type="button"
                                title="Editar Data"
                                onClick={abrirEdicaoDataFinalizacaoVenda}
                                className="text-blue-600 hover:text-blue-800 text-sm underline"
                              >
                                Editar
                              </button>
                            )}
                        </div>
                        {editandoDataFinalizacaoVenda ? (
                          <div className="flex flex-col gap-2 mt-1">
                            <input
                              type="datetime-local"
                              value={novaDataFinalizacaoVenda}
                              onChange={(e) =>
                                setNovaDataFinalizacaoVenda(e.target.value)
                              }
                              className="border rounded p-1"
                            />
                            <div className="flex gap-2 justify-end">
                              <Button
                                type="button"
                                className="bg-meta-1 py-1 px-2 text-sm"
                                onClick={() =>
                                  setEditandoDataFinalizacaoVenda(false)
                                }
                              >
                                Cancelar
                              </Button>
                              <Button
                                type="button"
                                className="py-1 px-2 text-sm"
                                onClick={salvarEdicaoDataFinalizacaoVenda}
                              >
                                Salvar
                              </Button>
                            </div>
                          </div>
                        ) : (
                          <div className="font-medium">
                            {dataFinalizacaoVendaFormatada}
                          </div>
                        )}
                      </div>

                      <div className="border rounded-md p-3 bg-gray-50">
                        <div className="text-sm text-gray-500">Usuário</div>
                        <div className="font-medium">
                          {nomeUsuarioFinalizacao}
                        </div>
                      </div>
                    </div>
                  </ModalComponente>
                  <ModalComponente
                    defaultW="w-[800px]"
                    header="Resumo IA"
                    onClose={() => setOpenModalVisualizaResumoIA(false)}
                    hasSaveButton={false}
                    hasForm={false}
                    opened={openModalVisualizaResumoIA}
                  >
                    <div className="relative flex flex-col gap-4 p-1">
                      {/* Sparkles animados */}
                      <div className="pointer-events-none absolute inset-0 overflow-hidden">
                        {[...Array(6)].map((_, i) => (
                          <span
                            key={i}
                            className="absolute animate-ping text-black opacity-70"
                            style={{
                              fontSize: [
                                "10px",
                                "8px",
                                "12px",
                                "9px",
                                "11px",
                                "8px",
                              ][i],
                              top: ["8%", "20%", "5%", "70%", "85%", "50%"][i],
                              left: ["5%", "90%", "50%", "8%", "88%", "95%"][i],
                              animationDuration: [
                                "2s",
                                "2.5s",
                                "3s",
                                "2.2s",
                                "2.8s",
                                "3.2s",
                              ][i],
                              animationDelay: [
                                "0s",
                                "0.5s",
                                "1s",
                                "1.5s",
                                "0.8s",
                                "0.3s",
                              ][i],
                            }}
                          >
                            ✦
                          </span>
                        ))}
                      </div>

                      <div className="flex items-center gap-2 rounded-xl border border-purple-200 bg-gradient-to-r from-purple-50 to-indigo-50 px-4 py-3">
                        <div className="flex h-8 w-8 items-center justify-center rounded-full bg-gradient-to-br from-purple-500 to-indigo-600 shadow-sm">
                          <svg
                            className="h-4 w-4 text-white"
                            fill="none"
                            viewBox="0 0 24 24"
                            stroke="currentColor"
                            strokeWidth={2}
                          >
                            <path
                              strokeLinecap="round"
                              strokeLinejoin="round"
                              d="M9.813 15.904L9 18.75l-.813-2.846a4.5 4.5 0 00-3.09-3.09L2.25 12l2.846-.813a4.5 4.5 0 003.09-3.09L9 5.25l.813 2.846a4.5 4.5 0 003.09 3.09L15.75 12l-2.846.813a4.5 4.5 0 00-3.09 3.09z"
                            />
                          </svg>
                        </div>
                        <div>
                          <p className="text-sm font-medium text-purple-700">
                            Gerado por Inteligência Artificial
                          </p>
                          <p className="text-[13px] text-purple-400">
                            Análise automática dos dados coletados
                          </p>
                        </div>
                      </div>

                      <div className="relative rounded-xl border border-gray-100 bg-white px-5 py-4 shadow-sm">
                        <div className="absolute left-0 top-4 bottom-4 w-1 rounded-full bg-gradient-to-b from-purple-400 to-indigo-500" />

                        <p className="pl-3   leading-relaxed text-black whitespace-pre-wrap">
                          {dadosCard.resumoIa_coleta}
                        </p>
                      </div>

                      <p className="text-center text-[13px] text-black">
                        ✦ Este resumo foi gerado automaticamente
                      </p>
                    </div>
                  </ModalComponente>
                  <DropdownsEditCard
                    dadosCard={dadosCard}
                    closeModal={closeModal}
                    dadosLista={dadosLista}
                    blockEditCard={blockEditCard}
                    kanbanId={kanbanId}
                    dadosFunil={dadosFunil}
                    setOpenPendenciaFaturmento={setOpenPendenciaFaturmento}
                    removePendencie={removePendencie}
                    compareActiveStep={compareActiveStep}
                    dadosPerfil={dadosPerfil}
                    tipoNegocio={tipoNegocio}
                    fluxosDoNegocio={fluxosDoNegocio}
                    dadosNegocio={dadosNegocio}
                    finalizarVenda={finalizarVenda}
                    setIsLoading={setIsLoading}
                    canEstornar={canEstornar}
                    propostaAprovada={propostaAprovada}
                    setOpenModalChangeEtapa={setOpenModalChangeEtapa}
                    getAprovalIndex={getAprovalIndex}
                    setOpenModalChangeFunil={setOpenModalChangeFunil}
                    setOpenModalPagamentoInstalacao={
                      setOpenModalPagamentoInstalacao
                    }
                    setOpenModalPagamento={setOpenModalPagamento}
                    canDeleteCard={canDeleteCard}
                    setOpenModalDeleteCard={setOpenModalDeleteCard}
                    setOpenPendenciaEngenharia={setOpenPendenciaEngenharia1}
                    setOpenPreapuracao={setOpenPreapuracao}
                    setOpenModalRejeicao={setOpenModalRejeicao}
                    setOpenModalConclusaoInstalacao={
                      setOpenModalConclusaoInstalacao
                    }
                    setOpenModalAgendamento={setOpenModalAgendamento}
                    setOpenModalReAgendamentoInstalacao={
                      setOpenModalReAgendamentoInstalacao
                    }
                    setOpenPendenciaCompras={setOpenPendenciaCompras}
                    setOpenModalAgendamentoManutencao={
                      setOpenModalAgendamentoManutencao
                    }
                    atualizarOrdensServico={atualizarOrdensServico}
                    ordemServico={ordensServico?.find(
                      (ordemServico) => ordemServico?.status_pvos == "1"
                    )}
                    stepsTemp={stepsTemp}
                    setOrdemServicoSelecionada={setOrdemServicoSelecionada}
                    setOpenModalPagamentoCobrancaTerceiro={
                      setOpenModalPagamentoCobrancaTerceiro
                    }
                  />
                </div>
              </div>
              <div className="mb-2 lg:h-[15rem] !text-xs">
                <CardInfoCliente
                  closeModal={closeModal}
                  dadosEtiquetas={etiquetas}
                  blockEditCard={blockEditCard}
                  responsaveisInativos={responsaveisInativos}
                  updateDados={atualizaDados}
                  dadosCard={dadosCard}
                  setNovoNomeNegocio={changeNomeNegocio}
                  dadosCliente={cliente}
                  reListarDadosKanban={reListarDadosKanban}
                  tiposServicos={tiposServicos}
                  isLoaded={isLoaded}
                />
              </div>
              <div
                className={`mt-2 max-sm:mt-1 max-sm:pt-2 mb-2 bg-white rounded-lg ${isMobile ? "overflow-x-auto mt-5" : ""}`}
              >
                <div className="relative flex justify-center items-center w-full">
                  <h2 className="text-sm font-bold">Linha das Pendências</h2>
                </div>
                <div className="bg-gray-100 p-1 rounded-md overflow-auto">
                  <div className={isMobile ? "min-w-[300px]" : ""}>
                    {stepsTemp.length > 12 && activeStep == null ? (
                      <div className="flex justify-center items-center">
                        <LoadingIcon />
                      </div>
                    ) : (
                      <>
                        <Stepper
                          activeStep={activeStep}
                          alternativeLabel
                          key={activeStep}
                        >
                          {stepsTemp?.map((step, index) => {
                            const blocked = isStepBlocked(step);

                            const remanenceAction =
                              remanenceActionMap[step?.id];

                            step.action = actionMap[step?.id] || (() => {});
                            return (
                              <Step
                                key={index}
                                disabled={blocked}
                                onClick={() => {
                                  if (blocked) {
                                    toast.warn(
                                      "Este passo está bloqueado por regra de negócio."
                                    );
                                    return;
                                  }
                                  if (blockEditCard) {
                                    toast.warn(
                                      "O projeto já está concluído e não pode ser editado!"
                                    );
                                    return;
                                  }
                                  if (index === activeStep) {
                                    step.action?.();
                                  }
                                  if (index < activeStep) {
                                    // remanenceActionMap[step?.id_pendencia]?.();
                                    remanenceAction?.();
                                  }
                                }}
                                className={`${(index === activeStep || (index < activeStep && !!remanenceAction)) && "cursor-pointer"}`}
                                sx={{
                                  "& .MuiStepLabel-label": {
                                    fontSize: "0.66rem",
                                  },
                                  "& .MuiStepLabel-iconContainer": {
                                    transform: "scale(0.75)",
                                  },
                                  "& .MuiStepConnector-line": {
                                    transform: "scaleY(0.75)",
                                  },
                                  ".Mui-completed": {
                                    color: "green !important",
                                  },
                                  ".Mui-active": {
                                    color: "orange !important",
                                  },
                                }}
                              >
                                <StepLabel
                                  error={blocked}
                                  sx={{ fontSize: "0.875rem !important" }}
                                >
                                  {step.label}
                                </StepLabel>
                              </Step>
                            );
                          })}
                        </Stepper>
                      </>
                    )}
                  </div>
                </div>
              </div>
            </>
          )}

          {kanbanId == 0 && (
            <>
              <div className="mb-2 rounded-md border border-warning/40 bg-warning/10 px-3 py-2 text-xs text-black">
                Negócio no Fluxo de Perdas — <b>somente visualização</b>.
                Nenhuma alteração pode ser feita por aqui.
              </div>
              <div className="mb-2 lg:h-[15rem] !text-xs">
                <CardInfoCliente
                  closeModal={closeModal}
                  dadosEtiquetas={etiquetas}
                  blockEditCard={true}
                  responsaveisInativos={responsaveisInativos}
                  updateDados={atualizaDados}
                  dadosCard={dadosCard}
                  setNovoNomeNegocio={changeNomeNegocio}
                  dadosCliente={cliente}
                  reListarDadosKanban={reListarDadosKanban}
                  tiposServicos={tiposServicos}
                  isLoaded={isLoaded}
                />
              </div>
            </>
          )}

          <TabsCard
            activeTab={activeTab}
            kanbanId={kanbanId}
            dadosCard={dadosCard}
            setActiveTab={setActiveTab}
            handleModalAnexo={handleModalAnexo}
            dadosFunil={dadosFunil}
            renderTabContent={renderTabContent}
            somenteLeitura={isFluxoPerdas}
          />

          {blockEditCard && (
            <div>
              <div>
                {responsaveisInativos.length > 0 && (
                  <div className="bg-warning p-4 rounded-md text-sm text-black">
                    {responsaveisInativos.map(
                      (responsavel: any, index: number) => (
                        <p key={index} className="mb-2">
                          O Responsável <b>{responsavel.nome}</b>, no cargo{" "}
                          <b>{responsavel.cargo}</b> está inativo. Para
                          conseguir movimentar este projeto, será necessário que
                          ele esteja ativo ou que os projetos dele sejam
                          transferidos para outro responsável ativo. Para isso,
                          utilize o programa{" "}
                          <button
                            className="bg-secondaryMenu text-white px-4 py-2 rounded-md hover:bg-primary transition duration-200"
                            onClick={() => router.push("/CXESCFG001")}
                          >
                            Transferência de Projeto
                          </button>
                          . Caso você não tenha permissão para acessar este
                          programa, entre em contato com o{" "}
                          <b>Administrador do Sistema</b>.
                        </p>
                      )
                    )}
                  </div>
                )}
              </div>
            </div>
          )}

          <div className="transition-all z-9999999 w-full xl:w-min grid gap-2">
            <ModalComponente
              size="lg"
              header="Aprovação de Crédito"
              onClose={() => setOpenModalPagamento(!openModalPagamento)}
              hasSaveButton={false}
              hasForm={false}
              opened={openModalPagamento}
            >
              <form
                onSubmit={handleSubmitPagamento(pagamentoFunction)}
                key={formPagamento.key}
              >
                <div className="flex flex-row gap-5 items-center justify-center">
                  <div>
                    <Input
                      formulario={form2}
                      name="data_pagamento"
                      label="Data"
                      type="date"
                      error="Preencha a data do pagamento!"
                      required
                      onChange={(event: any) => {
                        event.target.value >
                        new Date().toISOString().split("T")[0]
                          ? setErroDataPagamento(true)
                          : setErroDataPagamento(false);
                      }}
                    />
                    <span className="text-red-500 text-sm">
                      {erroDataPagamento &&
                        "Data não pode ser maior que o dia de hoje"}
                    </span>
                    <Input
                      formulario={form2}
                      name="obs_pagamento"
                      label="Observação"
                      type="textarea"
                    />
                  </div>
                  <div>
                    <Input
                      formulario={form2}
                      className="w-[200px] h-[2px]"
                      name="anexo_pagamento"
                      label="Anexo"
                      type="file"
                      typeFile="*"
                      onInputProp={(event: any) => {
                        const inputElement = event.target as HTMLInputElement;

                        if (
                          inputElement.files &&
                          inputElement.files.length > 0
                        ) {
                          const file = inputElement.files[0];
                          setAnexoPagamento(file);
                        }
                        return 1;
                      }}
                    />
                  </div>
                </div>
                <div className="w-full flex justify-center gap-3 mt-5">
                  <Button
                    type="submit"
                    loading={isLoading}
                    disabled={erroDataPagamento}
                  >
                    Aprovar
                  </Button>
                </div>
              </form>
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenModalDeleteCard(false)}
              size={"md"}
              className="overflow-hidden bg-stroke dark:bg-black"
              opened={openModalDeleteCard}
              hasForm={false}
            >
              <div>
                <div className="text-center">
                  <div className="font-bold text-base ">
                    Ao realizar esta ação o negócio apenas deixará de existir
                    neste fluxo.
                  </div>
                  <div>
                    Ainda estará presente no
                    {fluxosDoNegocio.length > 1 ? "s Fluxos" : " Fluxo"}:{" "}
                    {fluxosDoNegocio.join(", ")}
                  </div>
                </div>
                <div className="flex flex-row gap-2 justify-end">
                  <Button loading={isLoading} type="button" onClick={() => {}}>
                    Salvar
                  </Button>
                  <Button
                    className="bg-error"
                    type="button"
                    onClick={() => setOpenModalDeleteCard(false)}
                  >
                    Cancelar
                  </Button>
                </div>
              </div>
            </ModalComponente>
            <ModalComponente // Pendencia 12
              hasSaveButton={false}
              header={`Liberação para o Pagamento da Comissão - ${dadosCard?.id_coleta_cliente} - ${dadosCard?.nome_negocio_coleta}`}
              onClose={() => {
                setOpenPreapuracao(false);
              }}
              className="overflow-auto bg-stroke md:overflow-auto dark:bg-black md:w-[80%] lg:w-[90%] xl:w-[60%] 2xl:w-[50%] w-[100%]"
              opened={openPreapuracao}
              hasForm={false}
            >
              {dadosCard && usuariosResponsaveis ? (
                <PreApuracaoComissao
                  handleSubmitPreApuracao={handleSubmitPreApuracao}
                  setActiveStepAtual={setActiveStep}
                  setIsSubmitting={setIsSubmitting}
                  propostaAtiva={propostaAtiva}
                  indicadores={indicadores}
                  usuariosResponsaveis={usuariosResponsaveis}
                  dadosCard={dadosCard}
                  valorProposta={valorProposta}
                  valorComissaoGerente={valorComissaoGerente}
                  valorComissaoIndicador={valorComissaoIndicador}
                  activeStep={activeStep}
                  valorComissaoPreVendedor={valorComissaoPreVendedor}
                  valorComissaoVendedor={valorComissaoVendedor}
                  valorComissaoSupervisor={valorComissaoSupervisor}
                  isSubmitting={isSubmitting}
                  getAprovalIndex={getAprovalIndex}
                  totalComissao={totalComissao}
                  formPreApuracao={formPreApuracao}
                  setOpenPreapuracao={setOpenPreapuracao}
                  setPreApuracaoValues={setPreApuracaoValues}
                  formPre={formPre}
                  calcularComissao={calcularComissao}
                />
              ) : (
                <div>
                  <LoaderSun />
                </div>
              )}
              {/* <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={12}
              /> */}
            </ModalComponente>
            <ModalComponente
              isSubmitting={isSubmitting}
              saved={formDados.handleSubmit(handleChangeEtapaFunil)}
              onClose={() => setOpenModalChangeFunil([false, ""])}
              size="md"
              className="overflow-hidden bg-white"
              opened={openModalChangeFunil[0] as boolean}
              hasForm={false}
            >
              <div className="pb-3 w-115">
                <p className="text-black pb-3 text-lg text-left">
                  Selecione o <b>Fluxo Destino</b> e a <b>Etapa Destino</b> para{" "}
                  {openModalChangeFunil[1]} o card:
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Cliente: `}
                  <br />
                  <b>{`${dadosCard?.nome_cliente}`}</b>
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Negócio: `}
                  <br />
                  <b>{`${dadosCard?.id_coleta_cliente} - ${dadosCard?.nome_negocio_coleta}`}</b>
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Fluxo Origem: `}
                  <br />
                  <b>{`${funilOriginName}`}</b>
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Etapa Origem: `}
                  <br />
                  <b>{`${dadosLista.title}`}</b>
                </p>
                <div className="relative">
                  <div className="flex items-center mt-3 mb-3 p-3 bg-blue-50 border border-blue-200 rounded-md">
                    <FaInfoCircle
                      className="text-blue-500 mr-2 flex-shrink-0"
                      size={16}
                    />
                    <span className="text-sm text-blue-700">
                      <strong>Informação:</strong> Alguns fluxos podem não
                      aparecer na lista por dois motivos: <br />
                      1. Este negócio já possui um card ativo naquele fluxo (não
                      é possível ter o mesmo negócio duplicado no mesmo fluxo)
                      <br />
                      2. O tipo de negócio deste card não é compatível com os
                      tipos aceitos pelo fluxo
                    </span>
                  </div>

                  <InputSelectComponent
                    name="funil_destino"
                    required
                    formulario={formDados}
                    error="Selecione um fluxo!"
                    label="Fluxo Destino"
                    onChange={(e: any) => {
                      setSelectedFunilDestiny(String(e.value));
                      setEtapas([
                        ...allFunis.map((funil) => funil.listas_kanban).flat(),
                      ]);
                    }}
                    //     {
                    //         "id_funil": "1",
                    //         "titulo_funil": "01-FLUXO DE VENDAS",
                    //         "titulo_etapa_funil": "GERAR PROPOSTA",
                    //         "id_coleta_card": "21",
                    //         "cor_etapa_funil": "#f79256",
                    //         "cor_funil": "#f79256"
                    //     },
                    //     {
                    //         "id_funil": "2",
                    //         "titulo_funil": "03-FLUXO DE CONTRATOS",
                    //         "titulo_etapa_funil": "Revisão da assinatura",
                    //         "id_coleta_card": "21",
                    //         "cor_etapa_funil": "#ed678d",
                    //         "cor_funil": "#6c7395"
                    //     },
                    //     {
                    //         "id_funil": "4",
                    //         "titulo_funil": "08-FLUXO DE INSTALAÇÕES",
                    //         "titulo_etapa_funil": "VISTORIA TÉCNICA",
                    //         "id_coleta_card": "21",
                    //         "cor_etapa_funil": "#f79256",
                    //         "cor_funil": "#000000"
                    //     }
                    // ] // etapasFunil vem assim
                    options={allFunis
                      .filter(
                        (e) =>
                          e.id_funil !== dadosLista.id_funil &&
                          e.id_funil !== "0" &&
                          !etapasFunil.some(
                            (etapa: any) => etapa.id_funil === e.id_funil
                          ) &&
                          // Verificar se o tipo de negócio do card é compatível com o tipo de negócio do funil
                          (() => {
                            const tipoNegocioCard =
                              dadosCard?.tipoNegocio_coleta;
                            const tipoNegocioFunil = e.tipo_negocio_funil;
                            // Se o funil não tem tipo específico (vazio ou null), aceita qualquer tipo
                            if (
                              !tipoNegocioFunil ||
                              tipoNegocioFunil === "" ||
                              tipoNegocioFunil === "*"
                            ) {
                              return true;
                            }

                            // Verificar se o tipo do card está na lista de tipos aceitos pelo funil
                            // tipo_negocio_funil pode ser uma string com valores separados por vírgula
                            const tiposAceitos = tipoNegocioFunil
                              .split(",")
                              .map((tipo: string) => tipo.trim());
                            return tiposAceitos.includes(
                              String(tipoNegocioCard)
                            );
                          })()
                      )
                      .sort((a: any, b: any) =>
                        a.titulo_funil.localeCompare(
                          b.titulo_funil,
                          undefined,
                          {
                            numeric: true,
                          }
                        )
                      )
                      .map(
                        (res: any): IValueLabel => ({
                          label: res.titulo_funil,
                          value: res.id_funil,
                        })
                      )}
                  />

                  <InputSelectComponent
                    name="etapa_destino"
                    required
                    formulario={formDados}
                    error="Selecione uma etapa!"
                    label="Etapa Destino"
                    options={etapas
                      .filter(
                        (etapa: any) =>
                          etapa.grupo_etapa_funil == selectedFunilDestiny
                      )
                      .sort((a: any, b: any) => {
                        return String(a.index_etapa_funil).localeCompare(
                          String(b.index_etapa_funil),
                          undefined,
                          { numeric: true }
                        );
                      })

                      .map((etapa: any) => ({
                        value: String(etapa.id_etapa_funil),
                        label: etapa.titulo_etapa_funil,
                      }))}
                  />
                </div>
              </div>
            </ModalComponente>
            <ModalComponente
              isSubmitting={isSubmitting}
              saved={formTrocaEtapa.handleSubmit(handleChangeEtapa)}
              onClose={() => {
                setOpenModalChangeEtapa(false);
              }}
              size="md"
              className="overflow-hidden bg-white"
              opened={openModalChangeEtapa as boolean}
              hasForm={false}
            >
              <div className="pb-3 w-115">
                <p className="text-black pb-3 text-lg text-Left">
                  Selecione a <b>Etapa Destino</b> para Mover o card:
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Cliente: `}
                  <br />
                  <b>{`${dadosCard?.nome_cliente}`}</b>
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Negócio: `}
                  <br />
                  <b>{`${dadosCard?.id_coleta_cliente} - ${dadosCard?.nome_negocio_coleta}`}</b>
                </p>
                <p className="text-black pb-3 text-lg text-Left">
                  {`Etapa Origem: `}
                  <br />
                  <b>{`${dadosLista.title}`}</b>
                </p>
                <InputSelectComponent
                  name="etapa_destino"
                  required
                  formulario={formTrocaEtapa}
                  error="Selecione uma etapa!"
                  label="Etapa Destino"
                  options={etapasDestinoMovim.map((etapa: IEtapaProps) => ({
                    value: String(etapa.id),
                    label: etapa.descricao,
                  }))}
                />
              </div>
            </ModalComponente>
            {openModalRejeicao && (
              <ModalRejeicao
                isColeta={true}
                onSubmitReprovar={onSubmitReprovar}
                openModalRejeitar={openModalRejeicao}
                closeFuncion={closeModalRejeicao}
              />
            )}

            <ModalComponente // Pendencia 11
              onClose={() => setOpenModalAgendamento(false)}
              className="overflow-hidden bg-white"
              opened={openModalAgendamento}
              hasForm={false}
              header={`${"Agendamento"}`}
              hasSaveButton={false}
            >
              <FormAgendamento
                usuarios={usuariosResponsaveis}
                onSubmitFunction={onSubmitNewAgendamentoInstalacao}
                dadosCard={dadosCard}
              >
                <CamposPersonalizados
                  formulario={formCamposPersonalizados}
                  dataCard={dadosCard}
                  // handleSubmit={handleSubmit}
                  blockEditCard={blockEditCard}
                  onSubmitFunction={salvarCamposPersonalizados}
                  localCampo="5"
                  idLoja={dadosCard?.id_loja_coleta}
                  tipoNegocio={dadosCard?.tipoNegocio_coleta}
                  pendenciaID={11}
                />
                <div className="flex w-full justify-end">
                  <Button
                    loading={isLoadingAgendamentoInstalacao}
                    className=" bg-success mt-5 rounded-md py-2 px-4"
                  >
                    Salvar
                  </Button>
                </div>
              </FormAgendamento>
            </ModalComponente>

            <ModalComponente // Pendencia 11
              onClose={() => setOpenModalReAgendamentoInstalacao(false)}
              className="overflow-hidden bg-white"
              opened={openModalReAgendamentoInstalacao}
              hasForm={false}
              header={`${"Reagendamento da Instalação"}`}
              hasSaveButton={false}
            >
              <FormAgendamento
                usuarios={usuariosResponsaveis}
                onSubmitFunction={onSubmitNewAgendamentoInstalacao}
                dadosCard={dadosCard}
              >
                <CamposPersonalizados
                  formulario={formCamposPersonalizados}
                  dataCard={dadosCard}
                  // handleSubmit={handleSubmit}
                  blockEditCard={blockEditCard}
                  onSubmitFunction={salvarCamposPersonalizados}
                  localCampo="5"
                  idLoja={dadosCard?.id_loja_coleta}
                  tipoNegocio={dadosCard?.tipoNegocio_coleta}
                  pendenciaID={11}
                />
                <div className="flex w-full justify-end">
                  <Button
                    loading={isLoadingAgendamentoInstalacao}
                    className=" bg-success mt-5 rounded-md py-2 px-4"
                  >
                    Salvar
                  </Button>
                </div>
              </FormAgendamento>
            </ModalComponente>

            <ModalComponente
              onClose={() => setOpenModalAgendamentoManutencao(false)}
              className="overflow-hidden bg-white"
              opened={openModalAgendamentoManutencao}
              hasForm={false}
              header={`${"Agendamento da Manutenção"}`}
              hasSaveButton={false}
            >
              <FormAgendamentoManutencao
                usuarios={usuariosResponsaveis}
                onSubmitFunction={onSubmitNewAgendamentoManutencao}
                dadosCard={dadosCard}
              >
                <div className="flex w-full justify-end">
                  <Button
                    loading={isLoadingAgendamentoManutencao}
                    className=" bg-success mt-5 rounded-md py-2 px-4"
                  >
                    Salvar
                  </Button>
                </div>
              </FormAgendamentoManutencao>
            </ModalComponente>

            {/* <ModalComponente
              onClose={() => setOpenModalGeracaoOS(false)}
              className="overflow-hidden bg-white"
              opened={openModalGeracaoOS}
              hasForm={false}
              header={`${"Geração de OS"}`}
              hasSaveButton={false}
            >
              <FormGeracaoOS
                dadosCard={dadosCard}
                setActiveStepAtual={function (value: any): void {
                  throw new Error("Function not implemented.");
                }}
                usuarios={usuariosResponsaveis}
                // defaultValues={defaultValues}
                dadosCliente={financiadorCliente || cliente}
                proposta={propostas.find(
                  (proposta) => proposta.status_proposta === "1"
                )}
                contrato={coletaContratos?.find(
                  (contrato) => contrato.status_contrato === "1"
                )}
                // atualizarContratosColeta={atualizarContratosColeta}
                buscaPropostas={buscaPropostas}
                compareActiveStep={compareActiveStep}
                setActiveStepAtual={() => {}}
                activeStep={activeStep}
                stepsTemp={stepsTemp}
                setDadosNegocio={setDadosNegocio}
                ordensServico={ordensServico}
              >
                <Button
                  loading={isLoadingAgendamentoManutencao}
                  className=" bg-success mt-5 rounded-md py-2 px-4"
                >
                  Salvar
                </Button>
              </FormGeracaoOS>
            </ModalComponente> */}

            <ModalComponente
              onClose={() => setOpenModalAgendamentoManutencao(false)}
              className="overflow-hidden bg-white"
              opened={openModalAgendamentoManutencao}
              hasForm={false}
              header={`${"Agendamento da Manutenção"}`}
              hasSaveButton={false}
            >
              <FormAgendamentoManutencao
                usuarios={usuariosResponsaveis}
                onSubmitFunction={onSubmitNewAgendamentoManutencao}
                dadosCard={dadosCard}
              >
                <div className="flex w-full justify-end">
                  <Button
                    loading={isLoadingAgendamentoManutencao}
                    className=" bg-success mt-5 rounded-md py-2 px-4"
                  >
                    Salvar
                  </Button>
                </div>
              </FormAgendamentoManutencao>
            </ModalComponente>

            {/* <ModalComponente
              onClose={() => setOpenModalGeracaoOS(false)}
              className="overflow-hidden bg-white"
              opened={openModalGeracaoOS}
              hasForm={false}
              header={`${"Geração de OS"}`}
              hasSaveButton={false}
            >
              <FormGeracaoOS
                dadosCard={dadosCard}
                usuarios={usuariosResponsaveis}
                // defaultValues={defaultValues}
                dadosCliente={financiadorCliente || cliente}
                proposta={propostas.find(
                  (proposta) => proposta.status_proposta === "1"
                )}
                contrato={coletaContratos?.find(
                  (contrato) => contrato.status_contrato === "1"
                )}
                // atualizarContratosColeta={atualizarContratosColeta}
                buscaPropostas={buscaPropostas}
                compareActiveStep={compareActiveStep}
                setActiveStepAtual={() => {}}
                activeStep={activeStep}
                stepsTemp={stepsTemp}
                setDadosNegocio={setDadosNegocio}
                ordensServico={ordensServico}
              >
                <Button
                  loading={isLoadingAgendamentoManutencao}
                  className=" bg-success mt-5 rounded-md py-2 px-4"
                >
                  Salvar
                </Button>
              </FormGeracaoOS>
            </ModalComponente> */}

            <ModalComponente // Pendencia 11 Visualiza
              onClose={() => setOpenVisualizaAgendamentosInstalacoes(false)}
              className="overflow-hidden bg-white"
              opened={openVisualizaAgendamentosInstalacoes}
              hasForm={false}
              header={`${"Agendamento"}`}
              hasSaveButton={false}
              defaultW="w-[40%]"
            >
              <AgendamentosInstalacaoNegocio dadosCard={dadosCard} />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={11}
              />
            </ModalComponente>
            <ModalComponente // Pendencia 13 Visualiza
              onClose={() => setOpenVisualizaConclusaoInstalacao(false)}
              className="overflow-hidden bg-white"
              opened={openVisualizaConclusaoInstalacao}
              hasForm={false}
              header={`${"Conclusão"}`}
              hasSaveButton={false}
              defaultW="w-[60%]"
            >
              <ConclusaoInstalacaoNegocio dadosCard={dadosCard} />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={13}
              />
            </ModalComponente>
            <ModalComponente // Pendencia 14 Visualiza
              onClose={() => setOpenVisualizaPagamentoInstalacao(false)}
              className="overflow-hidden bg-white"
              opened={openVisualizaPagamentoInstalacao}
              hasForm={false}
              header={`${"Dados Instalação"}`}
              hasSaveButton={false}
              defaultW="w-[60%]"
            >
              <PagamentoInstalacao dadosCard={dadosCard} />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={14}
              />
            </ModalComponente>
            <ModalComponente // Pendencia 13
              onClose={() => setOpenModalConclusaoInstalacao(false)}
              className="overflow-hidden bg-white"
              opened={openModalConclusaoInstalacao}
              hasForm={false}
              header={`${"Conclusão da Instalação"}`}
              hasSaveButton={false}
              defaultW="w-[40%]"
            >
              <FormConclusaoInsalacao
                onSubmitFunction={onSubmitConclusaoInstalacao}
                dadosCard={dadosCard}
              >
                <CamposPersonalizados
                  formulario={formCamposPersonalizados}
                  dataCard={dadosCard}
                  // handleSubmit={handleSubmit}
                  blockEditCard={blockEditCard}
                  onSubmitFunction={salvarCamposPersonalizados}
                  localCampo="5"
                  idLoja={dadosCard?.id_loja_coleta}
                  tipoNegocio={dadosCard?.tipoNegocio_coleta}
                  pendenciaID={13}
                />
                <div className="flex w-full justify-end">
                  <Button
                    loading={isLoadingAgendamentoInstalacao}
                    className=" bg-success mt-5 rounded-md py-2 px-4"
                  >
                    Salvar
                  </Button>
                </div>
              </FormConclusaoInsalacao>
            </ModalComponente>
            <ModalComponente // Pendencia 14
              onClose={() => setOpenModalPagamentoInstalacao(false)}
              className="overflow-hidden bg-white"
              opened={openModalPagamentoInstalacao}
              hasForm={false}
              header={`${"Pagamento da Instalação"}`}
              hasSaveButton={false}
              defaultW="w-[40%]"
            >
              <FormPagamentoInstalacao
                onSubmitFunction={onSubmitPagamentoInstalacao}
                dadosCard={dadosCard}
              >
                <CamposPersonalizados
                  formulario={formCamposPersonalizados}
                  dataCard={dadosCard}
                  // handleSubmit={handleSubmit}
                  blockEditCard={blockEditCard}
                  onSubmitFunction={salvarCamposPersonalizados}
                  localCampo="5"
                  idLoja={dadosCard?.id_loja_coleta}
                  tipoNegocio={dadosCard?.tipoNegocio_coleta}
                  pendenciaID={14}
                />
                <div className="flex w-full justify-end">
                  <Button
                    loading={isLoadingAgendamentoInstalacao}
                    className=" bg-success mt-5 rounded-md py-2 px-4"
                  >
                    Salvar
                  </Button>
                </div>
              </FormPagamentoInstalacao>
            </ModalComponente>
            <ModalComponente
              onClose={() => setOpenVisualizaAgendamentoManutencao(false)}
              className="overflow-hidden bg-white"
              opened={openVisualizaAgendamentoManutencao}
              hasForm={false}
              header={`${"Agendamento"}`}
              hasSaveButton={false}
              defaultW="w-[40%]"
            >
              <VisualizacaoAgendamentosManutencao dadosCard={dadosCard} />
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={handleModalAnexo}
              className={
                isMobile
                  ? "w-full h-[95vh] bg-stroke dark:bg-black" // Altura quase total em mobile
                  : "max-w-[90vw] w-[1200px] h-[85vh] bg-stroke dark:bg-black" // Tamanho máximo para desktop
              }
              opened={openModalAnexo}
              hasForm={false}
            >
              <div className="h-full p-4 overflow-y-auto">
                {" "}
                {/* Container interno com scroll */}
                <AnexosModal
                  dataCard={{ ...dadosCard, dadosCliente: { ...cliente } }}
                  isFluxoPerdas={noFluxoPerdas}
                />
              </div>
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenPendenciaCompras(false)}
              size={`${isMobile ? "md" : "xl"}`}
              className={"bg-white"}
              header={`${"Compra de Kit"}`}
              opened={openPendenciaCompras}
              hasForm={false}
            >
              <PendenciaCompraMaterial
                onSubmitFunction={onSubmitPendenciaCompraMaterial}
                dadosCard={{ ...dadosCard, cliente }}
              />
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenFinalizacaoVenda(false)}
              size={`${isMobile ? "md" : "md"}`}
              className={"bg-white"}
              header={"Finalização da venda"}
              opened={openFinalizacaoVenda}
              hasForm={false}
            >
              <div className="w-full flex flex-col items-center gap-4 py-4">
                {/* Ícone estilo SweetAlert */}
                <div className="w-20 h-20 rounded-full border-4 border-green-400 flex items-center justify-center">
                  <svg
                    className="w-10 h-10 text-green-400"
                    fill="none"
                    stroke="currentColor"
                    viewBox="0 0 24 24"
                  >
                    <path
                      strokeLinecap="round"
                      strokeLinejoin="round"
                      strokeWidth={2.5}
                      d="M5 13l4 4L19 7"
                    />
                  </svg>
                </div>

                <div className="text-center">
                  <h1 className="text-2xl font-semibold text-gray-800">
                    Deseja Finalizar a Venda?
                  </h1>
                  <span className="text-gray-500 text-sm">
                    Tem certeza que deseja finalizar a venda?
                  </span>
                </div>

                {/* Campos Personalizados */}
                <div className="w-full">
                  <CamposPersonalizados
                    formulario={formCamposPersonalizados}
                    dataCard={dadosCard}
                    blockEditCard={blockEditCard}
                    onSubmitFunction={salvarCamposPersonalizados}
                    localCampo="5"
                    idLoja={dadosCard?.id_loja_coleta}
                    tipoNegocio={dadosCard?.tipoNegocio_coleta}
                    pendenciaID={8}
                  />
                </div>

                <div className="flex gap-3 mt-2">
                  <Button
                    className="bg-green-600 hover:bg-green-700 px-6"
                    onClick={async () => {
                      const valido = await formCamposPersonalizados.trigger();
                      if (!valido) return;

                      const camposData = formCamposPersonalizados.getValues();
                      if (Object.keys(camposData).length > 0) {
                        await salvarCamposPersonalizados(camposData, 8);
                      }
                      // Sem prompt de data aqui: grava a data de GERAÇÃO do
                      // contrato (fallback: agora, dentro do finalizarVenda).
                      const limiteData = obterDataMinimaFinalizacaoVenda();
                      await finalizarVenda(
                        obterDataGeracaoContrato() ?? undefined,
                        limiteData?.data,
                        limiteData?.motivo
                      );
                      setOpenFinalizacaoVenda(false);
                    }}
                    type="button"
                  >
                    Confirmar
                  </Button>
                  <Button
                    className="bg-red-500 hover:bg-red-600 px-6"
                    onClick={() => setOpenFinalizacaoVenda(false)}
                    type="button"
                  >
                    Cancelar
                  </Button>
                </div>
              </div>
            </ModalComponente>
            {/* <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenFinalizacaoVenda(false)}
              size={`${isMobile ? "md" : "md"}`}
              className={"bg-white"}
              header={`${"Finalização da venda"}`}
              opened={openFinalizacaoVenda}
              hasForm={false}
            >
              <div className="w-full flex justify-center">
                <div className="">
                  <h1 className="text-3xl text-black">Deseja Finalizar a Venda?</h1>
                  <span className=" text-black">Tem certeza que deseja finalizar a venda?</span>
                  <div className="flex gap-4">

                    <Button className="bg-green-700" onClick={finalizarVenda} type="button">Confirmar</Button>
                    <Button className="bg-red-600" onClick={() => setOpenFinalizacaoVenda(false)} type="button">Cancelar</Button>
                  </div>
                </div>
              </div>

            </ModalComponente> */}
            <ModalComponente // Pendencia 16
              hasSaveButton={false}
              onClose={() => setOpenPendenciaFaturmento(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Faturamento"}`}
              opened={openPendenciaFaturamento}
              hasForm={false}
            >
              <PendenciaFaturamento
                onSubmitFunction={onSubmitFaturamento}
                dadosCard={{
                  ...dadosCard,
                  cliente,
                  ordemServico: ordensServico?.find(
                    (ordemServico) => ordemServico?.status_pvos == "1"
                  ),
                  // ordensServico,
                }}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={16}
              />
            </ModalComponente>

            <ModalComponente // Pendencia 10
              hasSaveButton={false}
              onClose={fecharModal}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Engenharia 1"}`}
              opened={openPendenciaEngenharia1}
              hasForm={false}
            >
              <PendenciaEngenharia
                formulario={formPendenciaEngenharia}
                onSubmitFunction={async (checklist: any) => {
                  await new Promise<void>((resolve, reject) => {
                    formPendenciaEngenharia.handleSubmit(
                      async (data: any) => {
                        try {
                          const { valido, camposVazios } =
                            validarCamposPersonalizadosObrigatorios(data);
                          if (!valido) {
                            camposVazios.forEach((campo: any) => {
                              toast.error(
                                `O campo "${nomeLegivel(campo)}" é obrigatório e não foi preenchido.`
                              );
                            });
                            return;
                          }
                          const dados = {
                            data,
                            coleta_id: dadosCard.id_coleta_cliente,
                            id_card: dadosCard.id,
                            cliente: cliente.id_cliente,
                            id_pendencia: 10,
                            id_usuario,
                          };

                          await filterCamposPersonalizados(dados);
                          await onSubmitPendenciaEgenharia(checklist);

                          resolve();
                        } catch {
                          reject();
                        }
                      },
                      () => {
                        toast.error(
                          "Preencha todos os campos obrigatórios antes de concluir."
                        );
                        reject();
                      }
                    )();
                  });
                }}
                dadosCard={{ ...dadosCard, cliente }}
                engenharia="1"
              >
                <CamposPersonalizados
                  formulario={formPendenciaEngenharia}
                  dataCard={dadosCard}
                  showBorderContainer
                  blockEditCard={blockEditCard}
                  localCampo="5"
                  idLoja={dadosCard?.id_loja_coleta}
                  tipoNegocio={dadosCard?.tipoNegocio_coleta}
                  pendenciaID={10}
                />
              </PendenciaEngenharia>
            </ModalComponente>
            <ModalComponente // Pendencia 19
              hasSaveButton={false}
              onClose={() => setOpenPendenciaEngenharia2(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Engenharia 2"}`}
              opened={openPendenciaEngenharia2}
              hasForm={false}
            >
              <PendenciaEngenharia
                onSubmitFunction={onSubmitPendenciaEgenharia}
                dadosCard={{ ...dadosCard, cliente }}
                engenharia={"2"}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={19}
              />
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenVisualizaCompraMaterial(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização da Compra de Materiais"}`}
              opened={openVisualizaCompraMaterial}
              hasForm={false}
            >
              <VisualizacaoCompraMaterial
                dadosCard={{ ...dadosCard, perfil }}
              />
            </ModalComponente>
            <ModalComponente // Pendencia 16 Visualiza
              hasSaveButton={false}
              onClose={() => setOpenVisualizaFaturamento(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização do Faturamento"}`}
              opened={openVisualizaFaturamento}
              hasForm={false}
            >
              <VisualizacaoFaturamento dadosCard={dadosCard} />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={16}
              />
            </ModalComponente>
            <ModalComponente // Pendencia 17
              hasSaveButton={false}
              onClose={() => setOpenPendenciaPesquisaSatisfacao1(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização da Pesquisa de Satisfação 1"}`}
              opened={openPendenciaPesquisaSatisfacao1}
              hasForm={false}
            >
              <PesquisaSatisfacao
                form={form}
                handleSubmit={handleSubmit}
                onSubmitFunction={onSubmitPesquisaSatisfacao}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={17}
              />
            </ModalComponente>
            <ModalComponente // Pendencia 18
              hasSaveButton={false}
              onClose={() => setOpenPendenciaPesquisaSatisfacao2(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização da Pesquisa de Satisfação 2"}`}
              opened={openPendenciaPesquisaSatisfacao2}
              hasForm={false}
            >
              <PesquisaSatisfacao
                form={form}
                handleSubmit={handleSubmit}
                onSubmitFunction={onSubmitPesquisaSatisfacao}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={18}
              />
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenVisualizaPendenciaEngenharia(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização da Pendência de Engenharia "} ${visualizaEngenharia}`}
              opened={openVisualizaPendenciaEngenharia}
              hasForm={false}
            >
              <VisualizacaoPendenciaEngenharia
                engenharia={visualizaEngenharia}
                dadosCard={dadosCard}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={Number(visualizaEngenharia == 1 ? "10" : "19")}
              />
            </ModalComponente>
            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenModalVisualizaPesquisaSatisfacao(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização da Pendência de Pesquisa de Satisfação "} ${visualizaPesquisa}`}
              opened={openModalVisualizaPesquisaSatisfacao}
              hasForm={false}
            >
              <VisualizacaoPendenciaPesquisa
                pesquisa={visualizaPesquisa}
                dadosCard={dadosCard}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={18}
              />
            </ModalComponente>

            <ModalComponente // Pendencia 15
              hasSaveButton={false}
              onClose={() => setOpenEntregaKit(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Entrega do Kit"}`}
              opened={openEntregaKit}
              hasForm={false}
            >
              <PendenciaEntregaKit
                dadosCard={{ ...dadosCard, cliente }}
                onSubmitFunction={onSubmitPendenciaEntregaKit}
              />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard={blockEditCard}
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={15}
              />
            </ModalComponente>

            <ModalComponente
              hasSaveButton={false}
              onClose={() => setOpenVisualizaEntregaKit(false)}
              size={`${isMobile ? "md" : "lg"}`}
              className={"bg-white"}
              header={`${"Visualização da Entrega de Kits"}`}
              opened={openVisualizaEntregaKit}
              hasForm={false}
            >
              <VisualizacaoEntregaKit dadosCard={dadosCard} />
              <CamposPersonalizados
                formulario={formCamposPersonalizados}
                dataCard={dadosCard}
                // handleSubmit={handleSubmit}
                blockEditCard
                onSubmitFunction={salvarCamposPersonalizados}
                localCampo="5"
                idLoja={dadosCard?.id_loja_coleta}
                tipoNegocio={dadosCard?.tipoNegocio_coleta}
                pendenciaID={15}
              />
            </ModalComponente>

            {openModalCustosOrdemServico && (
              <ModalComponente
                hasSaveButton={false}
                onClose={() => setOpenModalCustosOrdemServico(false)}
                // size={`${isMobile ? "md" : "lg"}`}
                // className={"bg-white"}
                header={`${"Informações de Custos ou Serviços (Informado pelo Instalador)"}`}
                opened={openModalCustosOrdemServico}
                hasForm={false}
              >
                <FormCustosOS
                  ordemServico={ordemServicoSelecionada}
                  defaultValues={ordemServicoSelecionada}
                  dadosCard={dadosCard}
                  dadosCliente={financiadorCliente || cliente}
                  usuario={usuario}
                  setActiveStepAtual={setActiveStep}
                  setOpenModalCustosOrdemServico={
                    setOpenModalCustosOrdemServico
                  }
                  atualizarOrdensServico={atualizarOrdensServico}
                  isDisabled={
                    activeStep >
                      stepsTemp.findIndex((step: any) => step.id === "30") ||
                    !podePendencia("30", "realizar")
                  }
                />
              </ModalComponente>
            )}

            {openModalValidacaoOrdemServico && (
              <ModalComponente
                hasSaveButton={false}
                onClose={() => setOpenModalValidacaoOrdemServico(false)}
                // size={`${isMobile ? "md" : "lg"}`}
                // className={"bg-white"}
                header={`${"Validação da OS/Custos"}`}
                opened={openModalValidacaoOrdemServico}
                hasForm={false}
              >
                <FormValidacaoOS
                  ordemServico={ordemServicoSelecionada}
                  defaultValues={ordemServicoSelecionada}
                  dadosCard={dadosCard}
                  dadosCliente={financiadorCliente || cliente}
                  usuario={usuario}
                  setActiveStepAtual={setActiveStep}
                  setOpenModalCustosOrdemServico={
                    setOpenModalCustosOrdemServico
                  }
                  setOpenModalBaixarOrdemServico={
                    setOpenModalBaixarOrdemServico
                  }
                  setActiveTab={setActiveTab}
                  usuarios={usuarios}
                  proposta={propostas.find(
                    (proposta) => proposta.status_proposta === "1"
                  )}
                  contrato={coletaContratos?.find(
                    (contrato) => contrato.status_contrato === "1"
                  )}
                  setOpenModalValidacaoOrdemServico={
                    setOpenModalValidacaoOrdemServico
                  }
                  atualizarOrdensServico={atualizarOrdensServico}
                  isDisabled={
                    activeStep >
                      stepsTemp.findIndex((step: any) => step.id === "24") ||
                    !podePendencia("24", "realizar")
                  }
                />
              </ModalComponente>
            )}

            {openModalVisualizacaoValidacaoOrdemServico && (
              <ModalComponente
                hasSaveButton={false}
                onClose={() =>
                  setOpenModalVisualizacaoValidacaoOrdemServico(false)
                }
                // size={`${isMobile ? "md" : "lg"}`}
                // className={"bg-white"}
                header={`${"Validação da OS/Custos"}`}
                opened={openModalVisualizacaoValidacaoOrdemServico}
                hasForm={false}
              >
                <VisualizacaoValidacaoOS
                  ordemServico={ordemServicoSelecionada}
                  defaultValues={ordemServicoSelecionada}
                  dadosCard={dadosCard}
                  dadosCliente={financiadorCliente || cliente}
                  usuario={usuario}
                  setActiveStepAtual={setActiveStep}
                  setOpenModalCustosOrdemServico={
                    setOpenModalCustosOrdemServico
                  }
                  setOpenModalBaixarOrdemServico={
                    setOpenModalBaixarOrdemServico
                  }
                  setActiveTab={setActiveTab}
                  usuarios={usuarios}
                  proposta={propostas.find(
                    (proposta) => proposta.status_proposta === "1"
                  )}
                  contrato={coletaContratos?.find(
                    (contrato) => contrato.status_contrato === "1"
                  )}
                  setOpenModalVisualizacaoValidacaoOrdemServico={
                    setOpenModalVisualizacaoValidacaoOrdemServico
                  }
                  atualizarOrdensServico={atualizarOrdensServico}
                  isDisabled={
                    activeStep >
                      stepsTemp.findIndex((step: any) => step.id === "24") ||
                    !podePendencia("24", "realizar")
                  }
                />
              </ModalComponente>
            )}

            {openModalContatoCliente && (
              <ModalComponente
                hasSaveButton={false}
                onClose={() => setOpenModalContatoCliente(false)}
                // size={`${isMobile ? "md" : "lg"}`}
                // className={"bg-white"}
                header={`${"Contato"}`}
                opened={openModalContatoCliente}
                hasForm={false}
              >
                <ContatoCliente onSubmitFunction={onSubmitContatoCliente} />
              </ModalComponente>
            )}

            {openModalCancelamento && (
              <ModalComponente
                hasSaveButton={false}
                onClose={() => setOpenModalCancelamento(false)}
                // size={`${isMobile ? "md" : "lg"}`}
                // className={"bg-white"}
                defaultW="w-[400px]"
                header={`${"Cancelamento"}`}
                opened={openModalCancelamento}
                hasForm={false}
              >
                <FormCancelamento onSubmitFunction={onSubmitReprovar} />
              </ModalComponente>
            )}
          </div>
        </>
      )}
    </div>
  );
};

export default EditCard;