import LoaderSun from "@/components/common/Loader/LoaderSun";
import Button from "@/components/Forms/Button";
import Container from "@/components/Forms/Container";
import ModalComponente from "@/components/Modal/ModalComponente";
import { listarCategoriasTelhados } from "@/requests/CRUD/CategoriasTelhado/listarCategoriaTelhado";
import { buscaTensaoProjetoOrigem } from "@/requests/CRUD/ColetaDados/editarColeta";
import { listarItensKitsPorTipo } from "@/requests/CRUD/ColetaDados/listarItenskitsDiversos";
import { listarLojas } from "@/requests/CRUD/Lojas/listarLojas";
import { listarTiposTelhados } from "@/requests/CRUD/TiposTelhados/listarTiposTelhados";
import { useAuth } from "@/src/contexts/authContext";
import { useScreenContext } from "@/src/contexts/ScreenContext";
import { formatarValor, FormatFields } from "@/utils";
import { calcTotalConsumo } from "@/utils/calcules";
import {
  buscarInversorCatalogo,
  componenteDistribuidorDiferenteDoKit,
  criarComponenteTabelaPreco,
  isComponenteTabelaPreco,
  listarLinhasTabelaPrecoParaSelecao,
  mesclarComponentesTabelaPrecoAutomaticos,
  normalizarIdFiltroTabelaPreco,
  normalizarListaComponentesTabelaPreco,
  normalizarPotenciaSistema,
  resolverMatchesTabelaPreco,
  resolverSiglaTelhadoProposta,
} from "@/utils/tabelaPrecos";
import { Typography } from "@material-tailwind/react";
import katex from "katex";
import "katex/dist/katex.min.css";
import { InfoIcon, Plus, Zap } from "lucide-react";
import { useEffect, useMemo, useState } from "react";
import { BsLightningChargeFill } from "react-icons/bs";
import { RiErrorWarningFill } from "react-icons/ri";
import { toast } from "react-toastify";
import Swal from "sweetalert2";
import { obterCustosExtras } from "../CXESSIM002";
import ItemComponenteProposta from "./ItemComponenteProposta";
import NewItemComponentePropostaForm from "./NewItemComponentePropostaForm";

const ComponentesProposta = ({
  form,
  blockNextStep,
  ucs,
  stepInicializado,
  defaultValues,
  dadosAmpliacao,
  parametros,
  dadosCliente,
  perdasMedias,
  valorColeta,
  setStepInicializado,
  itensComp,
  itensCompostos,
  tabelasPrecos = [],
  itensKitTabelaPreco,
  lastProposalInfo,
  dadosCard,
  camposPersonalizados,
  setNextStepAction,
  camposPersonalizadosData,
  inversoresBD = [],
}: any) => {
  const [keyComponentes, setKeyComponentes] = useState(0);
  const avisosTipo =
    parametros?.avisos?.[String(dadosCard?.tipoNegocio_coleta ?? "")] || {};
  const [isLoading, setIsLoading] = useState(false);
  const [isOpenNewItem, setIsOpenNewItem] = useState(false);
  const [has_overload, setHas_overload] = useState("");
  const [hasAllComponents, setHasAllComponents] = useState(false);
  const [tempList, setTempList] = useState<any[]>([]);
  const [overload, setOverload] = useState<any>({
    overLoadValue: 0,
    overloadReferenceMax: 0,
    overloadReferenceMin: 0,
  });
  const [ultrapassouPotenciaMaxSistema, setUltrapassouPotenciaMaxSistema] =
    useState("");
  const [modulosLimit, setModulosLimit] = useState<any>({
    minModulos: 0,
    maxModulos: 0,
  });
  const [tensaoPadraoOrigem, setTensaoPadraoOrigem] = useState<string>("");
  const { isMobile } = useScreenContext();
  const [itensCompostosTemp, setItensCompostosTemp] = useState<any[]>([]);
  const ORDEM_COMPONENTES = [
    "9",
    "8",
    "7",
    "2",
    "5",
    "3",
    "4",
    "16",
    "13",
    "17",
  ];

  const ordenarComponentesKit = (lista: any[] = []) =>
    [...lista]
      .map((item, index) => ({ item, index }))
      .sort((a, b) => {
        const ordemA = ORDEM_COMPONENTES.indexOf(
          String(a.item?.tipo_item ?? a.item?.id_tipo_item)
        );
        const ordemB = ORDEM_COMPONENTES.indexOf(
          String(b.item?.tipo_item ?? b.item?.id_tipo_item)
        );

        const posA = ordemA === -1 ? Number.MAX_SAFE_INTEGER : ordemA;
        const posB = ordemB === -1 ? Number.MAX_SAFE_INTEGER : ordemB;

        if (posA !== posB) return posA - posB;

        return a.index - b.index;
      })
      .map(({ item }) => item);

  const [componentesKit, setComponentesKit] = useState<any[]>(
    ordenarComponentesKit(form?.control?._formValues?.componentesKit || [])
  );

  useEffect(() => {
    form.setValue("componentesKit", componentesKit);
  }, [componentesKit]);

  const [diffMsg, setDiffMsg] = useState("");
  const [hasDiffDistribuitor, setHasDiffDistributor] = useState<any[]>([]);


  const [inversoresUsados, setInversoresUsados] = useState([]); // Novo state para armazenar os inversores usados
  const [telhadosCatalogo, setTelhadosCatalogo] = useState<any[]>([]);
  const [categoriasTelhadoCatalogo, setCategoriasTelhadoCatalogo] = useState<
    any[]
  >([]);

  useEffect(() => {
    listarTiposTelhados().then((res: any) => setTelhadosCatalogo(res || []));
    listarCategoriasTelhados().then((res: any) =>
      setCategoriasTelhadoCatalogo(res || [])
    );
  }, []);

  const insertComponentRespectingOrder = (componente: any) => {
    setComponentesKit((prev) => {
      return ordenarComponentesKit([...prev, componente]);
    });
  };

  // "Faixas por Potência do Inversor" (cadastro do Item Composto) — quando
  // marcado, a faixa de/até compara contra a potência de UM inversor do kit
  // (kW), não a potência total do sistema (kWp). Sem isso, um item cadastrado
  // pra faixa de inversor validava contra o sistema inteiro — certo só por
  // coincidência quando os dois números caem no mesmo range.
  const itemCompostoUsaPotenciaPorInversor = (item: any) =>
    item?.potenciaPorInversor_item === "1" ||
    item?.potenciaPorInversor_item === 1 ||
    item?.potenciaPorInversor_item === true;

  const faixaAtendeCriterioPotencia = (
    faixa: any,
    usaPotenciaPorInversor: boolean,
    potenciaSistema: number,
    inversoresParaCriterio: any[]
  ) => {
    const potenciaDe = Number(faixa?.potenciaDe_item ?? 0);
    const potenciaAte = Number(faixa?.potenciaAte_item ?? 0);

    if (usaPotenciaPorInversor) {
      if (!inversoresParaCriterio.length) return false;
      return inversoresParaCriterio.some((inversor: any) => {
        const potenciaInversor = Number(inversor?.potencia_item ?? 0);
        return potenciaInversor >= potenciaDe && potenciaInversor <= potenciaAte;
      });
    }

    return potenciaDe <= potenciaSistema && potenciaAte >= potenciaSistema;
  };

  const getInversoresAtuaisDoKit = () =>
    componentesKit.filter((componente: any) => String(componente.tipo_item) === "8");

  const getItensCompostosDaFaixa = (
    potenciaSistema = potenciaKwp,
    inversoresAtuais: any[] = getInversoresAtuaisDoKit()
  ) => {
    // const potencia = normalizarPotenciaSistema(potenciaSistema);
    const idDistribuidorKit = kitManual
      ? (distribuidor?.id_distribuidor ?? distribuidor?.value)
      : kitEscolhido?.distribuidor;

    return (itensCompostos || []).filter((item: any) => {
      // Item Composto cadastrado pra um distribuidor específico (ex.: Belenus)
      // só pode ser puxado automaticamente quando o kit é DESSE distribuidor —
      // antes só filtrava por potência, deixando puxar em kit de qualquer
      // distribuidor. Campo do cadastro vem ora como codDistribuidor_item,
      // ora como distribuidor_item (mesmo fallback usado ao montar o
      // componente em criarItemComposto).
      const codDistribuidorItemComposto =
        item?.codDistribuidor_item ?? item?.distribuidor_item;
      if (
        componenteDistribuidorDiferenteDoKit(
          { codDistribuidor_item: codDistribuidorItemComposto },
          idDistribuidorKit
        )
      ) {
        return false;
      }

      const usaPotenciaPorInversor = itemCompostoUsaPotenciaPorInversor(item);

      if (Array.isArray(item?.faixas) && item.faixas.length > 0) {
        return item.faixas.some((faixa: any) =>
          faixaAtendeCriterioPotencia(
            faixa,
            usaPotenciaPorInversor,
            potenciaSistema,
            inversoresAtuais
          )
        );
      }

      return faixaAtendeCriterioPotencia(
        item,
        usaPotenciaPorInversor,
        potenciaSistema,
        inversoresAtuais
      );
    });
  };

  const getIdItemComposto = (item: any) =>
    String(
      item?.id_item_composto ?? item?.id_item ?? item?.cod_item_composto ?? ""
    );

  const getFaixaAtivaItemComposto = (
    itemComposto: any,
    potenciaSistema = potenciaKwp,
    inversoresAtuais: any[] = getInversoresAtuaisDoKit()
  ) => {
    const usaPotenciaPorInversor =
      itemCompostoUsaPotenciaPorInversor(itemComposto);

    if (Array.isArray(itemComposto?.faixas) && itemComposto.faixas.length > 0) {
      return (
        itemComposto.faixas.find((faixa: any) =>
          faixaAtendeCriterioPotencia(
            faixa,
            usaPotenciaPorInversor,
            potenciaSistema,
            inversoresAtuais
          )
        ) || itemComposto.faixas[0]
      );
    }

    return itemComposto;
  };

  const criarItemComposto = (
    itemComposto: any,
    origemInversorId?: any,
    inversorOrigemObjeto?: any
  ) => {
    // Se a inclusão veio de um inversor específico, a faixa/preço aplicada
    // tem que ser resolvida contra ESSE inversor — não "qualquer um do kit" —
    // senão um kit com inversores de potências diferentes pode escolher a
    // faixa errada pro item que acabou de entrar por causa de outro inversor.
    // Prioriza o objeto explícito (`inversorOrigemObjeto`) porque, no momento
    // desta chamada, o inversor recém-adicionado ainda pode não estar no
    // `componentesKit` (o setComponentesKit que o inclui roda depois) — buscar
    // só pelo id no estado atual não acharia nada nesse caso.
    const inversorOrigem =
      inversorOrigemObjeto ??
      (origemInversorId
        ? getInversoresAtuaisDoKit().find(
          (inv: any) => String(inv.id_item) === String(origemInversorId)
        )
        : undefined);
    const faixaAtiva = getFaixaAtivaItemComposto(
      itemComposto,
      potenciaKwp,
      inversorOrigem ? [inversorOrigem] : undefined
    );
    const descricaoBase =
      itemComposto.descricao_item_composto || itemComposto.descricao_item;
    const descricaoFaixa = faixaAtiva?.desc_faixa || faixaAtiva?.desc;
    const descricaoCompleta = [descricaoBase, descricaoFaixa]
      .filter(Boolean)
      .join(" - ");
    return {
      id_item: itemComposto.id_item_composto || itemComposto.id_item,
      nome_tipo_item: "Item Composto",
      descricao_item: descricaoCompleta,
      tipo_item: "",
      id_tipo_item: "",
      qtd_item: "1",
      status_item: "1",
      itens_itemComposto: itemComposto.itens,
      item_composto: "1",
      precoUnitario_item:
        faixaAtiva?.precoUnitario_item ||
        itemComposto.total_preco_itens ||
        itemComposto.precoUnitario_item ||
        "0",
      automatico:
        Boolean(Number(itemComposto.mostrarAut_item_composto)) ||
        Boolean(Number(itemComposto.mostrarAut_item)),
      origem_inversor_item: origemInversorId ? String(origemInversorId) : "",
      origensAutomaticas: origemInversorId
        ? [
          {
            id_inversor: String(origemInversorId),
            qtd: 1,
          },
        ]
        : [],
      id_item_composto: itemComposto.id_item_composto || itemComposto.id_item,
      codDistribuidor_item:
        itemComposto.codDistribuidor_item || itemComposto.distribuidor_item,
      potenciaDe_item: itemComposto.potenciaDe_item,
      potenciaAte_item: itemComposto.potenciaAte_item,
      faixas: itemComposto.faixas,
    };
  };

  const carregarStringboxesDoInversor = async (inversor: any) => {
    const distribuidorAtual = kitManual
      ? distribuidor?.id_distribuidor
      : kitEscolhido?.distribuidor;

    if (!distribuidorAtual) return [];

    const stringboxesData = await listarItensKitsPorTipo("13");

    return (stringboxesData || [])
      .filter(
        (stringbox: any) =>
          Boolean(Number(stringbox.mostrarAut_item)) &&
          ((String(stringbox.id_item) === String(inversor?.idStringCA_item) &&
            String(stringbox.tipoString_item) === "0") ||
            (String(stringbox.id_item) === String(inversor?.idStringCC_item) &&
              String(stringbox.tipoString_item) === "1"))
      )
      .map((stringbox: any) => ({
        ...stringbox,
        nome_tipo_item: "Stringbox",
        item_composto: "1",
        automatico: true,
        origem_inversor_item: String(inversor?.id_item || ""),
        qtd_item:
          String(stringbox.tipoString_item) === "1"
            ? inversor?.qtdStringCC_item || "1"
            : inversor?.qtdStringCA_item || "1",
        potencia_item: inversor?.potencia_item,
        origensAutomaticas: [
          {
            id_inversor: String(inversor?.id_item || ""),
            qtd:
              Number(
                String(stringbox.tipoString_item) === "1"
                  ? inversor?.qtdStringCC_item || "1"
                  : inversor?.qtdStringCA_item || "1"
              ) || 1,
          },
        ],
      }));
  };

  const carregarBateriasDoInversor = async (inversor: any) => {
    const distribuidorAtual = kitManual
      ? distribuidor?.id_distribuidor
      : kitEscolhido?.distribuidor;

    if (!distribuidorAtual) return [];

    const bateriasData = await listarItensKitsPorTipo("16");

    return (bateriasData || [])
      .filter(
        (bateria: any) =>
          String(bateria.id_item) === String(inversor?.idBateriaLitio_item) ||
          String(bateria.id_item) === String(inversor?.idBateriaChumbo_item)
      )
      .map((bateria: any) => {
        const qtdBase =
          String(bateria.id_item) === String(inversor?.idBateriaChumbo_item)
            ? inversor?.qtdBateriasChumboAcido_item || "1"
            : inversor?.qtdBateriasLitio_item || "1";

        return {
          ...bateria,
          nome_tipo_item: "Bateria",
          item_composto: "1",
          automatico: true,
          origem_inversor_item: String(inversor?.id_item || ""),
          qtd_item: String(qtdBase),
          origensAutomaticas: [
            {
              id_inversor: String(inversor?.id_item || ""),
              qtd: Number(qtdBase) || 1,
            },
          ],
        };
      });
  };

  const getChaveAutomaticaComponente = (componente: any) => {
    const tipo = String(
      componente?.nome_tipo_item || componente?.tipo_item || ""
    );

    if (tipo === "Item Composto" || String(componente?.item_composto) === "1") {
      return `item:${String(
        componente?.id_item_composto ??
        componente?.cod_item_composto ??
        componente?.id_item ??
        ""
      )}`;
    }

    if (tipo === "Stringbox") {
      return `stringbox:${String(
        componente?.id_item ?? componente?.id_item_composto ?? ""
      )}:${String(componente?.tipoString_item ?? "")}`;
    }

    return `outro:${String(
      componente?.id_item ??
      componente?.id_item_composto ??
      componente?.cod_item_composto ??
      ""
    )}:${tipo}`;
  };

  const mesclarItensAutomaticos = (
    listaBase: any[] = [],
    novosItens: any[] = []
  ) => {
    const listaAtualizada = [...listaBase];

    novosItens.forEach((novoItem: any) => {
      const indiceExistente = listaAtualizada.findIndex((item: any) => {
        return (
          getChaveAutomaticaComponente(item) ===
          getChaveAutomaticaComponente(novoItem)
        );
      });

      if (indiceExistente >= 0) {
        const itemExistente = listaAtualizada[indiceExistente];
        const qtdAtual = Number(itemExistente.qtd_item || 0);
        const qtdNova = Number(novoItem.qtd_item || 0) || 1;
        const origensExistentes = Array.isArray(
          itemExistente.origensAutomaticas
        )
          ? itemExistente.origensAutomaticas
          : [];
        const origensNovas = Array.isArray(novoItem.origensAutomaticas)
          ? novoItem.origensAutomaticas
          : novoItem.origem_inversor_item
            ? [
              {
                id_inversor: String(novoItem.origem_inversor_item),
                qtd: qtdNova,
              },
            ]
            : [];

        const origensCombinadas = [...origensExistentes];
        origensNovas.forEach((origem: any) => {
          const indiceOrigem = origensCombinadas.findIndex(
            (item: any) =>
              String(item.id_inversor) === String(origem.id_inversor)
          );
          if (indiceOrigem >= 0) {
            origensCombinadas[indiceOrigem] = {
              ...origensCombinadas[indiceOrigem],
              qtd:
                Number(origensCombinadas[indiceOrigem].qtd || 0) +
                Number(origem.qtd || 0),
            };
          } else {
            origensCombinadas.push(origem);
          }
        });

        listaAtualizada[indiceExistente] = {
          ...itemExistente,
          ...novoItem,
          qtd_item: String(qtdAtual + qtdNova),
          origensAutomaticas: origensCombinadas,
        };
        return;
      }

      listaAtualizada.push({
        ...novoItem,
        automatico: true,
        origensAutomaticas: Array.isArray(novoItem.origensAutomaticas)
          ? novoItem.origensAutomaticas
          : novoItem.origem_inversor_item
            ? [
              {
                id_inversor: String(novoItem.origem_inversor_item),
                qtd: Number(novoItem.qtd_item || 0) || 1,
              },
            ]
            : [],
      });
    });

    return listaAtualizada;
  };

  const sincronizarItensCompostosAutomaticos = (
    listaBase: any[] = [],
    manterRemovidosDaFaixa = false,
    inversorAdicionado: any = null
  ) => {
    // Deriva do `listaBase` recebido (estado fresco de quem chamou), não do
    // `componentesKit` de fora — evita ler um passo atrás em sequência rápida
    // de ações (mesmo cuidado já aplicado no match de Tabela de Preço).
    const inversoresDoKitAtual = listaBase.filter(
      (componente: any) => String(componente.tipo_item) === "8"
    );
    const itensDaFaixa = getItensCompostosDaFaixa(potenciaKwp, inversoresDoKitAtual);
    const itensAutomaticosDaFaixa = itensDaFaixa.filter((item: any) => {
      const ehAutomatico = Boolean(
        Number(item.mostrarAut_item_composto || item.mostrarAut_item)
      );

      // Se um inversor foi adicionado, validar se o composto pertence a esse inversor
      if (item.codInversor_item != "*") {
        if (inversorAdicionado && ehAutomatico) {
          const codInversorItem = item.codInversor_item;
          const codInversorAdicionado = inversorAdicionado.id_item;
          // Se ambos têm código de inversor, devem coincidir
          console.log(
            "Item composto tem restrição de inversor. Validando códigos..."
          );
          if (codInversorItem && codInversorAdicionado) {
            return codInversorItem === codInversorAdicionado;
          }
          // Se não tem restrição de inversor, incluir automaticamente
          return !codInversorItem;
        }
      }
      return ehAutomatico;
    });
    if (itensAutomaticosDaFaixa.length === 0) {
      return {
        lista: ordenarComponentesKit(listaBase),
        removidos: [] as any[],
      };
    }

    const idsAutomaticosDaFaixa = itensAutomaticosDaFaixa.map((item: any) =>
      getIdItemComposto(item)
    );
    const removidosAtuais =
      form.getValues("componentesCompostosRemovidos") || [];
    const removidosAtualizados = manterRemovidosDaFaixa
      ? removidosAtuais.filter(
        (id: any) => !idsAutomaticosDaFaixa.includes(String(id))
      )
      : removidosAtuais;

    const idsExistentes = new Set(
      listaBase
        .filter((item: any) => String(item.item_composto) === "1")
        .map(getIdItemComposto)
        .filter(Boolean)
    );
    const novosItens = itensAutomaticosDaFaixa
      .filter((item: any) => !idsExistentes.has(getIdItemComposto(item)))
      .map((item: any) =>
        criarItemComposto(item, inversorAdicionado?.id_item, inversorAdicionado)
      );

    return {
      lista: ordenarComponentesKit([...listaBase, ...novosItens]),
      removidos: removidosAtualizados,
    };
  };

  const getFiltrosTabelaPreco = () => ({
    id_loja: normalizarIdFiltroTabelaPreco(dadosCard?.id_loja_coleta),
    id_distribuidor: normalizarIdFiltroTabelaPreco(
      kitManual
        ? distribuidor?.id_distribuidor ?? distribuidor?.value
        : kitEscolhido?.distribuidor ?? distribuidor?.id_distribuidor
    ),
    id_telhado: resolverSiglaTelhadoProposta(
      form?.control?._formValues?.tipoTelhadoEscolhido ||
      form?.control?._formValues?.telhado?.value ||
      dadosAmpliacao?.tipoTelhado_ampliacao ||
      lastProposalInfo?.telhado_proposta,
      telhadosCatalogo,
      categoriasTelhadoCatalogo
    ),
  });

  // Quando existe Tabela de Preço no kit, o preço dela já cobre módulo,
  // inversor, estrutura, cabo etc. — zera o preço dos itens do kit pra não
  // contar o custo em dobro. Quando ela deixa de existir (removida junto do
  // inversor, ou por não bater mais a quantidade), restaura o preço original
  // guardado em precoUnitario_original_item. Chamado sempre que a lista de
  // componentes ganha ou perde uma Tabela de Preço, não só pelo sync
  // automático por potência.
  const aplicarPrecosConformeTabelaPreco = (
    lista: any[] = [],
    tabelaPrecoAtivaOverride?: boolean
  ) => {
    const tabelaPrecoAtiva =
      tabelaPrecoAtivaOverride ??
      lista.some((componente: any) => String(componente.tabela_preco) === "1");

    return lista.map((componente: any) => {
      if (String(componente.tabela_preco) === "1") return componente;

      if (tabelaPrecoAtiva) {
        // Inversor materializado a partir da linha de Tabela de Preço já
        // nasce com precoUnitario_item = 0 — o check de "já é 0" logo abaixo
        // já cobre isso sem precisar de um caso especial aqui. Um caso
        // especial que SEMPRE pulava esse componente (independente do preço
        // atual) impedia re-zerar depois que o preço dele já tivesse sido
        // restaurado uma vez (ciclo: tabela sai → restaura preço original →
        // tabela volta → deveria zerar de novo e não zerava).
        // Item Composto e Stringbox não entram no preço da Tabela — são
        // materiais comprados à parte, em outro fornecedor — então não
        // podem ser zerados junto com módulo/estrutura/cabo.
        const tipoComponente = String(componente.nome_tipo_item || "");
        if (tipoComponente === "Item Composto" || tipoComponente === "Stringbox") {
          return componente;
        }
        if (Number(componente.precoUnitario_item) === 0) return componente;
        return {
          ...componente,
          precoUnitario_original_item:
            componente.precoUnitario_original_item ??
            componente.precoUnitario_item,
          precoUnitario_item: 0,
        };
      }

      if (
        componente.precoUnitario_original_item != null &&
        Number(componente.precoUnitario_item) === 0
      ) {
        return {
          ...componente,
          precoUnitario_item: componente.precoUnitario_original_item,
        };
      }
      return componente;
    });
  };

  const sincronizarTabelasPrecosAutomaticos = (listaBase: any[] = []) => {
    const potencia = normalizarPotenciaSistema(potenciaKwp);
    const modulos = Number(totalModulos || 0) || undefined;
    const catalogoKit = itensKitTabelaPreco ?? [];
    const tabelas = tabelasPrecos ?? [];
    const moduloAtualSync = listaBase.find(
      (componente: any) => String(componente.tipo_item) === "9"
    );
    const idModuloAtualSync = moduloAtualSync?.id_item ?? modulo?.id_item ?? null;
    const novosComponentes = resolverMatchesTabelaPreco(
      catalogoKit,
      tabelas,
      potencia,
      modulos,
      getFiltrosTabelaPreco(),
      undefined,
      idModuloAtualSync
    );

    // A Tabela de Preço já embute o inversor certo no preço do kit — se ela
    // casou, remove inversores avulsos incompatíveis adicionados por outro
    // fluxo (ex.: Kit escolhido por potência), pra não divergir do preço.
    // Casa por id OU descrição (tolerante) — depender só de id_item apagaria
    // o inversor todo se a linha antiga não tiver o id resolvido.
    const identificadoresInversorTabelaPreco = new Set<string>();
    for (const componente of novosComponentes) {
      for (const inv of componente.inversores || []) {
        if (inv?.id_item != null && inv.id_item !== "") {
          identificadoresInversorTabelaPreco.add(`id:${String(inv.id_item)}`);
        }
        const descricaoInv = String(inv?.descricao ?? inv?.label ?? "")
          .trim()
          .toLowerCase();
        if (descricaoInv) {
          identificadoresInversorTabelaPreco.add(`desc:${descricaoInv}`);
        }
      }
    }

    const listaSemInversorDivergente = identificadoresInversorTabelaPreco.size
      ? listaBase.filter((componente: any) => {
        if (String(componente.tipo_item) !== "8") return true;
        if (String(componente.tabela_preco) === "1") return true;
        const idChave =
          componente.id_item != null ? `id:${String(componente.id_item)}` : null;
        const descChave = String(componente.descricao_item || "")
          .trim()
          .toLowerCase();
        return (
          (idChave && identificadoresInversorTabelaPreco.has(idChave)) ||
          (descChave &&
            identificadoresInversorTabelaPreco.has(`desc:${descChave}`))
        );
      })
      : listaBase;

    // Materializa o(s) inversor(es) embutidos na linha da Tabela de Preço que
    // casou como componente(s) de verdade (tipo Inversor) — sem isso o
    // inversor some da lista de Componentes e os cálculos de overload/MPPT
    // ficam sem inversor pra considerar. Sempre recriado a partir do zero pra
    // não ficar com quantidade/descrição desatualizada entre sincronizações.
    const listaSemInversoresDaTabelaAnteriores = listaSemInversorDivergente.filter(
      (componente: any) => !componente.origem_tabela_preco_inversor
    );

    const inversoresDaTabelaPreco = novosComponentes.flatMap(
      (componente: any) => {
        const idTabela = componente.id_tabela_preco;
        const idLinha = componente.id_linha_tabela_preco;
        return (componente.inversores || [])
          .map((inv: any) => {
            const catalogoInversor = buscarInversorCatalogo(
              inversoresBD,
              inv?.descricao ?? inv?.label,
              inv?.id_item
            );
            if (!catalogoInversor) return null;
            const qtd = Math.max(
              1,
              parseInt(String(inv?.qtd ?? inv?.quantidade ?? 1), 10) || 1
            );
            return {
              ...catalogoInversor,
              tipo_item: "8",
              id_tipo_item: "8",
              nome_tipo_item: "Inversores",
              qtd_item: String(qtd),
              item_composto: false,
              precoUnitario_item: 0,
              precoUnitario_original_item:
                catalogoInversor.precoUnitario_item ?? "0",
              automatico: true,
              origem_tabela_preco_inversor: idTabela,
              id_tabela_preco_origem_inversor: idTabela,
              id_linha_tabela_preco_origem_inversor: idLinha,
            };
          })
          .filter(Boolean);
      }
    );

    // novosComponentes ainda não está mesclado na lista nesse ponto (isso só
    // acontece no merge logo abaixo) — passa explícito se a Tabela de Preço
    // vai existir, em vez de deixar o helper detectar pela lista atual.
    const tabelaPrecoAtiva = novosComponentes.length > 0;
    const listaComPrecosAjustados = aplicarPrecosConformeTabelaPreco(
      [...listaSemInversoresDaTabelaAnteriores, ...inversoresDaTabelaPreco],
      tabelaPrecoAtiva
    );

    return ordenarComponentesKit(
      mesclarComponentesTabelaPrecoAutomaticos(
        listaComPrecosAjustados,
        novosComponentes,
        catalogoKit,
        tabelas
      )
    );
  };

  const sincronizarComponentesAutomaticos = (
    listaBase: any[] = [],
    manterRemovidosDaFaixa = false,
    inversorAdicionado: any = null
  ) => {
    const { lista } = sincronizarItensCompostosAutomaticos(
      listaBase,
      manterRemovidosDaFaixa,
      inversorAdicionado
    );
    return sincronizarTabelasPrecosAutomaticos(lista);
  };

  const classes = "p-4 max-sm:p-2 border-b dark:border-boxdark border-blue-gray-50";
  const {
    kitEscolhido,
    kitProprio,
    kitManual,
    modulo,
    consumoAmpliacao_cliente,
    // fabricante,
    consumoTotal,
    distribuidor,
    distribuidores,
    distribuicaoDosModulos,
    potenciaKwp,
    quantidade_modulos_ampliacao,
    totalModulos,
    media_irradiacao_mensal,
    tipo_string_inversor,
    precoTotal_tarifa,
    preco_aplicacao_tarifa,
    calculo_capacidade_modulos_parametro,
    dadosDistribuidoresCredenciais,
  } = form.control._formValues;
  const { porcent_calculo_capacidade_modulos_parametro } = defaultValues;
  // const [itemCompostos, setItemCompostos] = useState<any[]>([]);
  const [valorTotalComposto, setValorTotalComposto] = useState(0);

  const [canEditKit, setCanEditKit] = useState(kitManual);

  const calculoCaboParametro =
    defaultValues?.calculo_cabo_parametro ??
    parametros?.calculo_cabo_parametro ??
    "0";
  const caboPorModuloParametro = Number(
    defaultValues?.qtd_cabo_por_modulo_parametro ??
    parametros?.qtd_cabo_por_modulo_parametro ??
    0
  );
  const qtdStringsInversor = useMemo(() => {
    const inversores = (componentesKit || []).filter(
      (componente: any) => String(componente.tipo_item) === "8"
    );

    if (!inversores.length) return 1;

    const totalStrings = inversores.reduce((acc: number, inversor: any) => {
      const strings = Number(inversor?.strings_item || 1);
      const qtdInversor = Number(inversor?.qtd_item || 1);
      return acc + strings * qtdInversor;
    }, 0);

    return totalStrings > 0 ? totalStrings : 1;
  }, [componentesKit]);
  function convertName(name: string) {
    return (
      name
        .normalize("NFD")
        .replace(/[\u0300-\u036f]/g, "")
        .replace(/\s+/g, "_") + "_cp"
    );
  }
  useEffect(() => {
    if (!setNextStepAction || !form?.trigger) return;

    setNextStepAction(() => async () => {
      const values = form.getValues();

      // Validar apenas os campos personalizados obrigatórios do step atual
      const camposCpObrigatoriosDoStep = (camposPersonalizadosData || [])
        .filter((campo: any) => campo.obrigatorio_campo_personalizado === "1")
        .map((campo: any) => convertName(campo.nome_campo_personalizado));

      // Se não houver campos personalizados obrigatórios neste step, validação passa
      if (camposCpObrigatoriosDoStep.length === 0) {
        return true;
      }

      const isValid = await form.trigger(camposCpObrigatoriosDoStep);
      return isValid;
    });
  }, [JSON.stringify(camposPersonalizadosData)]);
  const abrirInfoFormulaCabos = () => {
    const formulaSelecionada =
      calculoCaboParametro === "1"
        ? "Q_{cabos}=Q_{cabo/mod}\\times Q_{modulos}\\times Q_{strings}"
        : "Q_{cabos}=Q_{cabo/mod}\\times Q_{modulos}";

    const qtdCabosBase =
      Number(caboPorModuloParametro || 0) * Number(totalModulos || 0);
    const qtdCabosCalculada =
      calculoCaboParametro === "1"
        ? qtdCabosBase * Number(qtdStringsInversor || 1)
        : qtdCabosBase;

    const calculoDetalhado =
      calculoCaboParametro === "1"
        ? `${caboPorModuloParametro || 0}\\times ${totalModulos || 0}\\times ${qtdStringsInversor} = ${qtdCabosCalculada}`
        : `${caboPorModuloParametro || 0}\\times ${totalModulos || 0} = ${qtdCabosCalculada}`;

    Swal.fire({
      icon: "info",
      title: "Fórmula de Cabos",
      html: `
        <div style="display:flex; flex-direction:column; align-items:center; gap:12px; font-size:14px;">
          <div>${katex.renderToString(formulaSelecionada, { throwOnError: false })}</div>
          <div>${katex.renderToString(`Q_{cabos}=${calculoDetalhado}`, { throwOnError: false })}</div>
          <div style="text-align:left; width:100%;">
            <strong>Legenda:</strong><br/>
            Q_{cabo/mod}: quantidade de cabo por módulo<br/>
            Q_{modulos}: quantidade de módulos<br/>
            Q_{strings}: quantidade total de strings dos inversores
          </div>
        </div>
      `,
      showConfirmButton: false,
    });
  };

  // Busca a tensão do projeto de origem
  useEffect(() => {
    if (dadosCard?.projetoRef_coleta) {
      buscaTensaoProjetoOrigem({
        projetoRef_coleta: dadosCard.projetoRef_coleta,
      })
        .then((res) => {
          if (res?.tensao_padrao) {
            setTensaoPadraoOrigem(res.tensao_padrao);
          }
        })
        .catch(() => {
          setTensaoPadraoOrigem("");
        });
    }
  }, [dadosCard?.projetoRef_coleta]);

  // Watch da tensão selecionada
  const tensaoSelecionada = form.watch("tensoes" as never);

  // Aviso quando tensão selecionada é diferente da tensão do projeto de origem
  useEffect(() => {
    if (tensaoSelecionada && tensaoPadraoOrigem) {
      const tensoesSelecionadas = Array.isArray(tensaoSelecionada)
        ? tensaoSelecionada.map((t: any) => t.value).join(",")
        : tensaoSelecionada?.value;
      if (
        tensoesSelecionadas &&
        !tensoesSelecionadas.includes("*") &&
        !tensoesSelecionadas.includes(tensaoPadraoOrigem)
      ) {
        toast.warning(
          `⚠️ A tensão selecionada (${tensoesSelecionadas}V) é diferente da tensão do projeto origem (${tensaoPadraoOrigem}V)`
        );
      }
    }
  }, [tensaoSelecionada, tensaoPadraoOrigem]);

  useEffect(() => {
    setCanEditKit(kitManual);
  }, [kitManual]);

  const { perfil, usuario } = useAuth();
  // let loja = form.control._formValues?.loja;
  // if (!loja) {
  //   listarLojas().then((lojas) => {
  //     loja = lojas.find((loj: any) => loj.id_loja == dadosCard?.id_loja_coleta);
  //     form.setValue("loja", loja);
  //   });
  // }

  async function obterCustosExtrasProposta() {
    let loja = form.control._formValues?.loja;
    if (!loja) {
      await listarLojas().then((lojas) => {
        loja = lojas.find(
          (loj: any) => loj.id_loja == dadosCard?.id_loja_coleta
        );
        form.setValue("loja", loja);
      });
    }

    const potenciaInversor =
      dadosCard?.tipoNegocio_coleta === "3"
        ? form?.control?._formValues?.potencia_inversores
          ? Number(form?.control?._formValues?.potencia_inversores)
          : Number(lastProposalInfo.potenciaSistema_proposta)
        : form?.control?._formValues?.potencia_inversores
          ? Number(form?.control?._formValues?.potencia_inversores)
          : Number(
            form?.control?._formValues?.componentesKit
              ? form?.control?._formValues?.componentesKit?.find(
                (componente: any) => componente.tipo_item == "8"
              )?.potencia_item
              : 0
          );
    const qtdModulos =
      (dadosCard?.tipoNegocio_coleta === "3"
        ? form?.control?._formValues?.quantidade_modulos_ampliacao
        : form?.control?._formValues?.totalModulos) || "0";
    const novosParametrosPrecificacao: any = {
      origem_contato: dadosCliente?.origem_cliente,
      tipo_negocio: dadosCard?.tipoNegocio_coleta,
      tipo_telhado: "1",
      distribuidor: form?.control?._formValues?.distribuidor?.id_distribuidor
        ? form?.control?._formValues?.distribuidor?.id_distribuidor
        : form?.control?._formValues?.kitEscolhido?.distribuidor
          ? Number(form?.control?._formValues?.kitEscolhido?.distribuidor)
          : "0",
      valor_kit: valorColeta,
      potencia_sistema: form?.control?._formValues?.potenciaKwp || "0",
      qtd_modulos: qtdModulos || "0",
      qtd_ucs: form?.control?._formValues?.ucs?.length,
      potencia_modulo: form?.control?._formValues?.potencia_modulo,
      usuario_logado: usuario?.id_usuario,
      vendedor: dadosCard?.responsaveis["Vendedor"],
      loja: dadosCard?.id_loja_coleta,
      comissao_preVendedor_loja: dadosCard?.comissao_preVendedor_loja,
      comissao_gerente_loja: dadosCard?.comissao_gerente_loja,
      comissao_indicacao_loja: dadosCard?.comissao_indicacao_loja,
      potencia_inversor: Number(potenciaInversor),
    };

    const parametrosPrecificacao =
      form.control._formValues?.parametrosPrecificacao || {};
    //
    if (
      Object.keys(novosParametrosPrecificacao).some(
        (chaveParametro) =>
          parametrosPrecificacao[chaveParametro] !=
          novosParametrosPrecificacao[chaveParametro]
      )
    ) {
      function setarPoliticaPrecoProposta(politica_preco: any) {
        form.setValue("politicaPreco", politica_preco);
      }

      return obterCustosExtras(
        {
          ...{
            ...novosParametrosPrecificacao,
            responsaveis: dadosCard?.responsaveis,
          },
          loja,
        },
        setarPoliticaPrecoProposta
      );

      // .finally(() =>
      //   form.setValue("parametrosPrecificacao", novosParametrosPrecificacao)
      // );
    }
  }
  useEffect(() => {
    setComponentesKit((prev) => {
      // Sem isso, item composto entra sem origem_inversor_item/origensAutomaticas
      // e nunca é removido depois via submitDeleteItemKit ao excluir o inversor
      // (que só remove item automático cuja origem bate com o inversor excluído).
      const inversorAtual = prev.find(
        (componente: any) => String(componente.tipo_item) === "8"
      );
      return sincronizarComponentesAutomaticos(prev, true, inversorAtual);
    });
    if (dadosCard.tipoNegocio_coleta === "3") {
      if (!precoTotal_tarifa) {
        const precoTarifaAplicacaoFormatado: any =
          FormatFields.desformatarNumeros(+preco_aplicacao_tarifa);
        form.setValue(
          "precoTotal_tarifa",
          precoTarifaAplicacaoFormatado.toFixed(7).toString().replace(".", ",")
        );
      }

      const perdaMedia = perdasMedias.find(
        (perda: any) =>
          perda.cod_orientacao_solar == defaultValues.orientacao_parametro &&
          perda.cod_inclinacao_telhado == defaultValues.inclinacao_parametro
      )?.valor_perda;
      const potenciaModulo = Number(modulo?.potencia_item) || 0;
      const qtdModulos = Number(quantidade_modulos_ampliacao) || 0;
      const performanceRatio =
        Number(defaultValues?.performance_ratio_parametro) || 0;
      const irradiacaoMensal = Number(media_irradiacao_mensal) || 0;
      const sombreamento = Number(defaultValues?.sombreamento_parametro) || 0;
      const perda = Number(perdaMedia) || 0;

      const estimativa_geracao =
        (potenciaModulo *
          qtdModulos *
          (performanceRatio / 100) *
          irradiacaoMensal *
          (1 - sombreamento / 100) *
          (100 - perda)) /
        100 /
        1000;

      if (dadosCard.tipoNegocio_coleta === "3") {
        const estimativa_geracao_cliente =
          (dadosAmpliacao?.potenciaModulos_ampliacao *
            dadosAmpliacao?.qtdModulos_ampliacao *
            (performanceRatio / 100) *
            irradiacaoMensal *
            (1 - sombreamento / 100) *
            (100 - perda)) /
          100 /
          1000;
        form.setValue("estimativa_geracao_cliente", estimativa_geracao_cliente);
        const abatimento_cliente =
          (+estimativa_geracao_cliente / +calcTotalConsumo(ucs)) * 100;

        form.setValue("abatimento_cliente", abatimento_cliente.toFixed(2));
      }
      const formatarNumero = FormatFields.formatarNumero;

      form.setValue("estimativa_geracao", estimativa_geracao);

      const abatimento =
        (+estimativa_geracao / +consumoAmpliacao_cliente) * 100;

      form.setValue("abatimento", abatimento.toFixed(2));

      if (
        form.getValues("tipo_ampliacao")?.value != "2" &&
        form.getValues("tipo_ampliacao")?.value != "3"
      ) {
        setComponentesKit(
          ordenarComponentesKit([
            ...form.control._formValues.componentesKit.filter(
              (componente: any) => componente.tipo_item !== "9"
            ),
            {
              ...form.control._formValues.modulo,
              qtd_item: form.control._formValues.quantidade_modulos_ampliacao,
            },
          ])
        );
      } else if (form.getValues("tipo_ampliacao")?.value === "3") {
        setComponentesKit(
          ordenarComponentesKit([
            ...form.control._formValues.componentesKit.filter(
              (componente: any) => componente.tipo_item !== "16"
            ),
            {
              ...form.control._formValues.bateria,
              qtd_item: form.control._formValues.quantidade_baterias_ampliacao,
            },
          ])
        );
      }
    }
  }, []);

  const inversor = componentesKit.find(
    (componente) => componente.tipo_item == "8"
  );

  let orientacoes =
    form.control._formValues.distribuicaoDosModulos?.length ?? 1;

  if (dadosCard.tipoNegocio_coleta === "3" && dadosCard.cod_coleta) {
    orientacoes = lastProposalInfo.ampliacao?.length;
  } else if (dadosCard.tipoNegocio_coleta === "3" && !dadosCard.cod_coleta) {
    orientacoes = dadosAmpliacao.orientacoes_integrador_ampliacao;
  }

  const [potenciaTotalInvesores, setPotenciaTotalInvesores] = useState<any>();

  useEffect(() => {
    blockNextStep(
      isLoading || (canEditKit ? has_overload || !hasAllComponents : false)
    );
    if (
      dadosCard?.tipoNegocio_coleta === "3" &&
      form.control._formValues?.tipo_ampliacao.value !== "2"
    ) {
      const formValues = form.control._formValues;
      const moduloSelecionado = formValues.modulo;
      const potenciaModulo = parseFloat(
        moduloSelecionado?.potencia_item || "0"
      );
      const potenciaAmpliacao = parseFloat(
        dadosAmpliacao?.potenciaModulos_ampliacao || "0"
      );

      if (
        formValues.tipo_ampliacao.value != "3" &&
        formValues.tipo_ampliacao.value != "2" &&
        potenciaModulo !== potenciaAmpliacao
      ) {
        if (formValues.tipo_ampliacao.value === "0") {
          blockNextStep(true);
        }
        adicionarAviso(
          "potencia_diferente",
          "ATENÇÃO! A potência do módulo selecionado é diferente do projeto de venda"
        );
      } else {
        removerAvisoPorChave("potencia_diferente");
        // blockNextStep(
        //   isLoading || (canEditKit ? has_overload || !hasAllComponents : false)
        // );
      }
    }

    if (inversor && dadosCard.tipoNegocio_coleta !== "3" && kitManual) {
      if (inversor.strings_item < orientacoes) {
        adicionarAviso(
          "diff",
          "A quantidade de orientações informada é maior que a quantidade de strings do inversor cadastrada."
        );
      } else {
        removerAvisoPorChave("diff");
      }
    }
  }, [isLoading, has_overload, hasAllComponents]);
  const tipoNegocioAtual = String(dadosCard?.tipoNegocio_coleta ?? "");
  const temConfigItensObrigatorios = Object.prototype.hasOwnProperty.call(
    parametros?.itens_obrigatorios || {},
    tipoNegocioAtual
  );
  const itensObrigatoriosParametro = temConfigItensObrigatorios
    ? parametros?.itens_obrigatorios?.[tipoNegocioAtual] || []
    : [];

  // Fonte da verdade: Parâmetros > Obrigatoriedade de Itens (por tipo de negócio).
  // Config vazia (ex.: Ampliação) = sem obrigatoriedade.
  // Sem config cadastrada = fallback legado (Ampliação por tipo_ampliacao; demais sem lista fixa).
  const componentesObrigatorios = temConfigItensObrigatorios
    ? (itensObrigatoriosParametro || [])
      .map((item: any) => ({
        value: String(item.id_tipo_item ?? item.value ?? ""),
        label:
          item.nome_tipo_item ?? item.label ?? `Tipo ${item.id_tipo_item}`,
      }))
      .filter((item: any) => item.value)
    : [
      ...(dadosCard.tipoNegocio_coleta === "3" &&
        form.control._formValues?.tipo_ampliacao?.value != "2" &&
        form.control._formValues?.tipo_ampliacao?.value != "3"
        ? [{ value: "9", label: "Modulos" }]
        : []),
      ...(dadosCard.tipoNegocio_coleta === "3" &&
        form.control._formValues?.tipo_ampliacao?.value === "1"
        ? [{ value: "8", label: "Inversores" }]
        : []),
      ...(dadosCard.tipoNegocio_coleta === "3" &&
        form.control._formValues?.tipo_ampliacao?.value === "3"
        ? [{ value: "16", label: "Baterias" }]
        : []),
    ];

  const [avisos, setAvisos] = useState<{ [key: string]: string }>({});

  function adicionarAviso(chave: string, mensagem: string) {
    setAvisos((prev) => ({ ...prev, [chave]: mensagem }));
    form.setValue(`avisos.${chave}`, mensagem);
  }
  function removerAvisoPorChave(chave: string) {
    setAvisos((prev) => {
      const novo = { ...prev };
      delete novo[chave];
      return novo;
    });

    form.setValue(`avisos.${chave}`, ""); // limpa no form, se necessário
  }
  useEffect(() => {
    form.setValue("componentesKit", ordenarComponentesKit(componentesKit));

    if (!kitManual && !kitEscolhido?.id_kit) {
      setCanEditKit(true);
    }

    if (componentesKit.some((item: any) => item.tipo_item === "16")) {
      removerAvisoPorChave("sem_bateria");
    } else {
      console.log(
        "inversor",
        componentesKit.some(
          (item: any) =>
            item.tipoStringInversor_item == "inversor_off_grid" ||
            item.tipoStringInversor_item == "inversor_hibrido"
        )
      );
      if (
        componentesKit.some(
          (item: any) =>
            item.tipoStringInversor_item == "inversor_off_grid" ||
            item.tipoStringInversor_item == "inversor_hibrido"
        ) &&
        avisosTipo?.aviso_sem_baterias_parametro === "1"
      ) {
        const mensagemAviso = `ATENÇÃO!! A geração desta proposta OFF-GRID ou Híbrido, está sem baterias adicionadas. Verifique com o seu ENGENHEIRO se poderá seguir com esta proposta antes de enviar para o seu cliente.`;
        adicionarAviso("sem_bateria", mensagemAviso);
      } else {
        removerAvisoPorChave("sem_bateria");
      }
    }

    const inversoresFilter = componentesKit.filter(
      (componente) => componente.tipo_item == "8"
    );

    const potenciaTotalInversores = inversoresFilter.reduce(
      (total, componente) => {
        return total + componente.potencia_item * componente.qtd_item;
      },
      0
    );

    setPotenciaTotalInvesores(potenciaTotalInversores);
    const ligacaoValue = dadosCard.tipoLigacao_coleta === "1" ? "10" : "20";

    if (
      (dadosCard.tipoLigacao_coleta === "2" &&
        dadosCard.tipoNegocio_coleta !== "3") ||
      (dadosCard.tipoNegocio_coleta === "3" &&
        form.control._formValues?.tipo_ampliacao?.value === "1")
    ) {
      const quantidades = inversoresFilter.map((inv: any) => inv.qtd_item || 0);
      const totalInversores = quantidades.reduce((sum, qtd) => sum + qtd, 0);
      if (
        totalInversores < 2 &&
        ["1", "2"].includes(avisosTipo?.aviso_inversoresBi_parametro) &&
        dadosCard.tipoligacao_coleta === "2"
      ) {
        const mensagemAviso = `ATENÇÃO!! A geração desta proposta refere-se a um projeto bifásico. Para evitar que a concessionária rejeite o projeto, recomendamos utilizar dois inversores monofásicos, garantindo o balanceamento da rede. Em caso de dúvidas, consulte o seu ENGENHEIRO.`;
        adicionarAviso("bifasico", mensagemAviso);

        if (avisosTipo?.aviso_inversoresBi_parametro === "2") {
          blockNextStep(true);
        } else {
          blockNextStep(false);
        }
      } else {
        removerAvisoPorChave("bifasico");
      }
    }
    const tipoLigacao = dadosCard.tipoLigacao_coleta;
    if (
      form.control._formValues?.tipo_inversor?.value !== "micro_inversor" &&
      potenciaTotalInversores >= Number(ligacaoValue) &&
      tipoLigacao != "3" &&
      form.control._formValues?.tipo_inversor?.value != "micro_inversor" &&
      ((tipoLigacao === "1" && avisosTipo?.aviso_monofasico_parametro) ||
        (tipoLigacao === "2" && avisosTipo?.aviso_bifasico_parametro))
    ) {
      const ligacaoName = tipoLigacao === "1" ? "MONOFÁSICO" : "BIFÁSICO";

      const msg = `ATENÇÃO!!! A geração desta proposta está como ${ligacaoName} e com inversor maior ou igual a ${ligacaoValue}k, e a Concessionária poderá reprovar o projeto, 
      verifique com seu ENGENHEIRO se poderá seguir com esta proposta antes de enviar para o seu CLIENTE`;
      adicionarAviso("ligacao", msg);
    } else {
      removerAvisoPorChave("ligacao");
    }

    // const moduloComponente = componentesKit.find(
    //   (componente) => componente.id_tipo_item == "9"
    // );
    const lastProposalModuloPotency =
      lastProposalInfo?.potencia_modulo_proposta ??
      lastProposalInfo?.potenciaModulos_ampliacao;
    if (
      (modulo || lastProposalModuloPotency) &&
      dadosCard.tipoNegocio_coleta === "3"
    ) {
      if (modulo?.altura_item && modulo?.largura_item) {
        form.setValue(
          "area_ocupada",
          +modulo.altura_item *
          +modulo.largura_item *
          form.control._formValues?.quantidade_modulos_ampliacao
        );
        form.setValue(
          "area_modulo",
          +modulo.altura_item * +modulo.largura_item
        );
      }

      const potencia_modulo =
        modulo?.potencia_item ?? lastProposalModuloPotency;

      form.setValue("potencia_modulo", potencia_modulo);

      form.setValue("modulo_proposta", modulo);

      if (modulo?.garantia_item && modulo?.garantia_item != 0) {
        form.setValue("garantia_modulo", modulo?.garantia_item);
      } else {
        form.setValue("garantia_modulo", undefined);
      }
      const {
        performance_ratio_parametro,
        media_irradiacao,
        media_irradiacao_mensal,
        irradiacao_mensal,
        sombreamentos_coleta,
        ucs,
      } = form.control._formValues;

      const sombreamento_coleta =
        +FormatFields.desformatarNumeros(sombreamentos_coleta);

      const estimativa_geracao_mensal = irradiacao_mensal.reduce(
        (acc: any[], curr: number) => [
          ...acc,
          +(
            (+potencia_modulo *
              +form.control._formValues?.quantidade_modulos_ampliacao *
              (defaultValues?.performance_ratio_parametro / 100) *
              curr *
              (1 - +sombreamento_coleta / 100)) /
            1000
          ).toFixed(2),
          // ).toFixed(0),
        ],
        []
      );

      form.setValue("estimativa_geracao_mensal", estimativa_geracao_mensal);
      const consumos_ucs_mensal = ucs.map((uc: any) =>
        +uc.valor == +uc.valor
          ? Array.from({ length: 12 }).map((_) => +uc.valor)
          : uc.valor.map((valor: number | string) => valor)
      );
      const media_consumos_ucs_mensal = consumos_ucs_mensal.reduce(
        (soma: number[], array: any[]) =>
          array.map(
            (valor, i, arr) =>
              soma[i] +
              (valor === ""
                ? arr.reduce(
                  (acc: any, cur: any) => acc + (parseFloat(cur) || 0),
                  0
                ) / arr.filter((val) => val !== "").length
                : Number(valor))
          ),
        Array(12).fill(0)
      );

      form.setValue(
        "media_consumos_ucs_mensal" as never,
        media_consumos_ucs_mensal as never
      );
      form.setValue(
        "totalModulos",
        form.control._formValues?.quantidade_modulos_ampliacao
      );
    }

    if (canEditKit) {
      // O valorColeta agora é atualizado automaticamente pelo useEffect que monitora custoTotalKit
      // Removido: form.setValue("valorColeta", ...)

      const mppts_kit = componentesKit.reduce((acc, curr) => {
        if (curr.tipo_item == "8") {
          acc = acc + +curr.mppts_item * +curr.qtd_item;
        }
        return acc;
      }, 0);

      const inversores = componentesKit.filter(
        (componente) => componente.tipo_item == "8"
      );

      const overLoadValue = potenciaKwp;

      const { overloadReferenceMin, overloadReferenceMax } = inversores.reduce(
        (
          acc: { overloadReferenceMax: number; overloadReferenceMin: number },
          inversor: any
        ) => {
          const potencia_min = +inversor?.potenciaNominalMinima_item || 0;
          const potencia_max = +inversor?.potenciaNominalMaxima_item || 0;
          return {
            overloadReferenceMin:
              acc.overloadReferenceMin < potencia_min
                ? acc.overloadReferenceMin
                : potencia_min,
            overloadReferenceMax:
              acc.overloadReferenceMax + potencia_max * +inversor.qtd_item,
          };
        },
        { overloadReferenceMax: 0, overloadReferenceMin: Infinity }
      );
      setOverload({
        overLoadValue,
        overloadReferenceMin,
        overloadReferenceMax,
      });

      const tipos_inversores_kit = componentesKit.reduce((acc, curr) => {
        if (curr.tipo_item == "8") {
          if (!acc[curr.tipoInversor_item]) {
            acc[curr.tipoInversor_item] = 1;
          } else {
            acc[curr.tipoInversor_item] = acc[curr.tipoInversor_item] + 1;
          }
          return acc;
        }
        return acc;
      }, {});

      const hasMicroInversorModulosOverload =
        tipo_string_inversor?.value != "inversor_string_microinversor" &&
        componentesKit.some(
          (componente) =>
            componente.tipoInversor_item == "micro_inversor" &&
            +componente.qtd_item <
            totalModulos / +componente.qtdModulos_max_item
        );

      if (
        mppts_kit < +orientacoes ||
        overLoadValue > overloadReferenceMax ||
        overLoadValue < overloadReferenceMin ||
        (Object.keys(tipos_inversores_kit).length > 1 &&
          tipo_string_inversor?.value != "inversor_string_microinversor") ||
        tipos_inversores_kit["micro_inversor"] > 1 ||
        hasMicroInversorModulosOverload
      ) {
        if (
          dadosCard.tipoNegocio_coleta === "3" &&
          form.control._formValues?.tipo_ampliacao.value === "1"
        ) {
          if (
            overLoadValue > overloadReferenceMax ||
            overLoadValue < overloadReferenceMin
          ) {
            setHas_overload("O inversor não suporta a potência do sistema");
          }
          if (Object.keys(tipos_inversores_kit).length > 1) {
            setHas_overload(
              "Não é possível utilizar inversor de parede e microinversor no mesmo kit"
            );
          }
          if (tipos_inversores_kit["micro_inversor"] > 1) {
            setHas_overload(
              "É permitido apenas um tipo de microinversor no kit"
            );
          }
          if (hasMicroInversorModulosOverload) {
            const microInversorModulosOverload = componentesKit.find(
              (componente) =>
                componente.tipoInversor_item == "micro_inversor" &&
                +componente.qtd_item <
                totalModulos / +componente.qtdModulos_max_item
            );
            setHas_overload(
              `A quantidade de microinversores é inferior a mínima. 
             A quantidade total de módulos dividido pela quantidade máxima de módulos suportada pelo microinversor é:
             ${totalModulos}(módulos) / ${microInversorModulosOverload.qtdModulos_max_item}(quanidade máxima de módulos por microinversor) = ${totalModulos / +microInversorModulosOverload.qtdModulos_max_item}(quantidade mínima de microinversores)`
            );
          }
        }
      } else {
        setHas_overload("");
      }
      const tiposPresentes = (componentesKit || []).map((componente: any) =>
        String(componente.tipo_item ?? componente.id_tipo_item ?? "")
      );
      const obrigatoriosOk = componentesObrigatorios.every(
        (componenteObrigatorio: any) =>
          tiposPresentes.includes(String(componenteObrigatorio.value))
      );
      // Com config cadastrada (mesmo vazia): só os itens configurados.
      // Sem config: mantém exigência de ao menos um componente no kit.
      setHasAllComponents(
        temConfigItensObrigatorios
          ? obrigatoriosOk
          : componentesKit.length > 0 && obrigatoriosOk
      );
    } else if (kitEscolhido?.distribuidor == "2") {
      const precoNumero = Number(
        FormatFields.desformatarNumeros(kitEscolhido?.preco_kit || "0")
      );
      form.setValue(
        "valorColeta",
        kitEscolhido?.componentes.reduce((acc: number, curr: any) => {
          const componenteExistente = componentesKit?.find(
            (componente) => componente.id_item === curr.id_item
          );

          if (!componenteExistente) {
            const preco = curr.item_composto
              ? +curr.precoUnitario_item
              : +curr.precoUnitario_item * +curr.qtd_item;
            return acc - preco;
          }

          return acc;
        }, +precoNumero) ?? 0
      );
    } else {
      const valorColeta = valorTotalComposto + (+kitEscolhido?.preco_kit || 0);

      form.setValue("valorColeta", valorColeta);
    }

    const inversores = componentesKit?.filter(
      (componente) => componente.id_tipo_item == "8"
    );
    if (
      dadosCard.tipoNegocio_coleta === "3" &&
      form.control._formValues?.tipo_ampliacao.value === "0"
    ) {
      form.setValue("minModulos", "Não definido");
      form.setValue("maxModulos", "Não definido");
      return;
    }

    if (inversores) {
      let totalMinModulos = 0;
      let totalMaxModulos = 0;

      const inversoresAtivos: any = [];
      const paramCalculo = form.getValues(
        "calculo_capacidade_modulos_parametro"
      )?.value;
      const paramPorcentCalculo = porcent_calculo_capacidade_modulos_parametro;
      inversores.forEach((inversor) => {
        const potenciaInversorW = parseFloat(inversor.potencia_item) * 1000; // Converte kW para W
        const underload = +inversor.underload_item / 100; // 70% -> 0.7
        const overload = ["1", "2"].includes(paramCalculo)
          ? 1
          : +inversor.overload_item / 100; // 150% -> 1.5
        const potenciaModulo = componentesKit.find(
          (modulo) => modulo.tipo_item == 9
        )?.potencia_item;
        const qtdItem = parseInt(inversor.qtd_item) || 1;

        let minModulos =
          (potenciaInversorW * qtdItem * underload) / potenciaModulo;

        minModulos = Math.floor(minModulos);

        let maxModulos =
          (potenciaInversorW * qtdItem * overload) / potenciaModulo;
        if (paramCalculo && paramCalculo === "2" && paramPorcentCalculo) {
          const somaPorcentCalculo =
            +maxModulos * (Number(paramPorcentCalculo) / 100);

          const newMaxModulos = maxModulos + somaPorcentCalculo;

          maxModulos = newMaxModulos;
        }

        if (inversor.tipoInversor_item == "micro_inversor") {
          maxModulos = Math.floor(
            (potenciaInversorW * overload) / potenciaModulo
          );

          maxModulos =
            maxModulos > +inversor.qtdModulos_max_item
              ? +inversor.qtdModulos_max_item
              : maxModulos;

          maxModulos = maxModulos * qtdItem;
        }

        maxModulos = Math.floor(maxModulos);

        totalMinModulos += minModulos;
        totalMaxModulos += maxModulos;

        // Adiciona o inversor processado ao array
        inversoresAtivos.push({
          ...inversor,
          minModulos,
          maxModulos,
        });
      });

      // Atualiza o state com os inversores utilizados
      setInversoresUsados(inversoresAtivos);

      // Atualiza os valores do formulário e estado
      form.setValue("minModulos", totalMinModulos);
      form.setValue("maxModulos", totalMaxModulos);
      setModulosLimit({
        minModulos: totalMinModulos,
        maxModulos: totalMaxModulos,
      });
      if (totalModulos < totalMinModulos) {
        setHas_overload("A quantidade de módulos mínima não foi atendida!");
      }
      if (totalModulos > totalMaxModulos) {
        setHas_overload(
          "A quantidade de módulos máxima suportada pelos inversores/microinversores foi excedida!"
        );
      } else {
        setHas_overload("");
      }
    }

    const potencia_inversores = inversores?.reduce(
      (acc, inversor) => (acc += Number(inversor?.potencia_item || 0)),
      0
    );

    form.setValue("potencia_inversores", potencia_inversores);

    form.setValue("inversores_proposta", inversores);

    const garantia_inversor = inversores.reduce(
      (acc, inversor) =>
        inversor.garantia_item
          ? +inversor.garantia_item < acc
            ? inversor.garantia_item
            : acc
          : acc,
      Infinity
    );
    if (
      garantia_inversor &&
      garantia_inversor != Infinity &&
      garantia_inversor != 0
    ) {
      form.setValue("garantia_inversor", garantia_inversor);
    } else {
      form.setValue("garantia_inversor", undefined);
    }

    const estruturas = componentesKit.filter(
      (componente) => componente.id_tipo_item == "7"
    );

    const garantia_estrutura = estruturas.reduce(
      (acc, estrutura) =>
        estrutura.garantia_item
          ? +estrutura.garantia_item < acc
            ? estrutura.garantia_item
            : acc
          : acc,
      Infinity
    );

    if (
      garantia_estrutura &&
      garantia_estrutura != Infinity &&
      garantia_estrutura != 0
    ) {
      form.setValue("garantia_estrutura", garantia_estrutura);
    } else {
      form.setValue("garantia_estrutura", undefined);
    }
  }, [componentesKit, canEditKit]);

  useEffect(() => {
    // if (dadosCard.tipoNegocio_coleta === "3") return;
    const modulo = componentesKit.find(
      (componente) => componente.id_tipo_item == "9"
    );

    if (modulo?.altura_item && modulo?.largura_item) {
      form.setValue(
        "area_ocupada",
        +modulo.altura_item * +modulo.largura_item * totalModulos
      );
      form.setValue("area_modulo", +modulo.altura_item * +modulo.largura_item);
    }
    const lastProposalModuloPotency =
      lastProposalInfo?.potencia_modulo_proposta ??
      lastProposalInfo?.potenciaModulos_ampliacao;
    const potencia_modulo = modulo?.potencia_item ?? lastProposalModuloPotency;

    form.setValue("potencia_modulo", potencia_modulo);

    form.setValue("modulo_proposta", modulo);

    if (modulo?.garantia_item && modulo?.garantia_item != 0) {
      form.setValue("garantia_modulo", modulo?.garantia_item);
    } else {
      form.setValue("garantia_modulo", undefined);
    }
  }, []);

  // const itemCompostosBd = itensCompostos?.filter(
  //   (a: any) =>
  //     Number(a.potenciaDe_item_composto) <= potenciaKwp &&
  //     Number(a.potenciaAte_item_composto) >= potenciaKwp
  // );

  useEffect(() => {
    // // if (parametros.carregar_itens_compostos_parametro === "0") return;
    // const componentesRemovidos =
    //   form.getValues("componentesCompostosRemovidos") || [];
    // const idsExistentes = new Set(
    //   componentesKit
    //     .filter((comp: any) => comp.item_composto === "1")
    //     .map((comp: any) => comp.id_item)
    // );

    // const novosItemCompostos = itemCompostosBd
    //   .filter(
    //     (item: any) =>
    //       !idsExistentes.has(item.id_item_composto)
    //     // &&
    //     //   !componentesRemovidos.includes(item.id_item_composto)
    //   )
    //   .map((item: any) => criarItemComposto(item));

    // setItensCompostosTemp(novosItemCompostos);
    // const itensCompostosAutomaticos = novosItemCompostos.filter((item: any) =>
    //   Boolean(item.automatico)
    // );

    if (!stepInicializado) {
      if (!form.getValues("componentesCompostosOriginais")?.length) {
        form.setValue("componentesCompostosOriginais", componentesKit);
      }
      setStepInicializado(true);
    }
  }, [potenciaKwp, componentesKit]);

  useEffect(() => {
    if (!itensKitTabelaPreco?.length && !tabelasPrecos?.length) return;

    setComponentesKit((prev) => {
      const precisaAtualizar = prev.some((item) => isComponenteTabelaPreco(item));
      if (!precisaAtualizar) return prev;

      const atualizados = ordenarComponentesKit(
        normalizarListaComponentesTabelaPreco(
          prev,
          itensKitTabelaPreco ?? [],
          tabelasPrecos ?? []
        )
      );

      const mudou = atualizados.some((item, index) => {
        const anterior = prev[index];
        return (
          String(item?.id_item) !== String(anterior?.id_item) ||
          String(item?.descricao_item) !== String(anterior?.descricao_item) ||
          String(item?.precoUnitario_item) !==
          String(anterior?.precoUnitario_item)
        );
      });

      return mudou ? atualizados : prev;
    });
  }, [itensKitTabelaPreco, tabelasPrecos]);

  useEffect(() => {
    setComponentesKit((prev) => sincronizarTabelasPrecosAutomaticos(prev));
  }, [
    potenciaKwp,
    totalModulos,
    itensKitTabelaPreco,
    tabelasPrecos,
    dadosCard?.id_loja_coleta,
    kitManual,
    distribuidor?.id_distribuidor,
    kitEscolhido?.distribuidor,
    form?.control?._formValues?.tipoTelhadoEscolhido,
    form?.control?._formValues?.telhado?.value,
    dadosAmpliacao?.tipoTelhado_ampliacao,
    lastProposalInfo?.telhado_proposta,
    telhadosCatalogo,
    categoriasTelhadoCatalogo,
  ]);

  const getMultiplicadorWEG = () => {
    if (kitEscolhido?.distribuidor !== "2") return 1;

    const dadosCredenciais = dadosDistribuidoresCredenciais?.find(
      (d: any) => d.codDistribuidor_credencial == kitEscolhido?.distribuidor
    );

    if (!dadosCredenciais) return 1;

    const fator = parseFloat(
      dadosCredenciais.fatorPrecificacaoWEG_credencial
        ?.toString()
        .replace(",", ".") ?? "1"
    );
    const frete = parseFloat(
      dadosCredenciais.modalidadeFreteWEG_credencial?.toString() ?? "1"
    );

    if (isNaN(fator) || isNaN(frete)) return 1;
    return fator * frete;
  };
  //fix custototalkit
  const custoTotalKit = useMemo(() => {
    const baseValue = canEditKit
      ? (componentesKit?.reduce((acc, curr) => {
        // const preco = curr.item_composto
        //   ? +curr.precoUnitario_item
        //   : +curr.precoUnitario_item * +curr.qtd_item;
        const preco = +curr.precoUnitario_item * (+curr.qtd_item || 1);

        return acc + preco;
      }, 0) ?? 0)
      : kitEscolhido?.distribuidor == "2"
        ? (kitEscolhido?.componentes.reduce((acc: number, curr: any) => {
          const componenteExistente = componentesKit?.find(
            (componente) => componente.id_item === curr.id_item
          );

          if (!componenteExistente) {
            const preco = curr.item_composto
              ? +curr.precoUnitario_item
              : +curr.precoUnitario_item *
              getMultiplicadorWEG() *
              +curr.qtd_item;
            return acc - preco;
          }

          return acc;
        }, +kitEscolhido?.preco_kit) ?? 0)
        : valorTotalComposto + (+kitEscolhido?.preco_kit || 0);

    // const multiplicador = getMultiplicadorWEG();

    // return baseValue * multiplicador;
    return baseValue;
  }, [canEditKit, componentesKit, kitEscolhido, valorTotalComposto]);
  //fix custototalkit

  // Sincroniza o custoTotalKit com o valorColeta do formulário
  useEffect(() => {
    form.setValue("valorColeta", custoTotalKit);
  }, [custoTotalKit]);

  async function submitEditItemKit(data: {
    id_item: number;
    [x: string]: any;
  }) {
    setIsLoading(true);
    if (data.qtd_item == 0) {
      return submitDeleteItemKit(data);
    }

    // Mudar a quantidade de um inversor pode fazer o kit passar a bater (ou
    // deixar de bater) com uma linha de Tabela de Preço diferente — reavalia
    // sempre em cima do conjunto de inversores já atualizado (ver
    // reconciliarTabelaPrecoDosInversores).
    const ehInversor = data.tipo_item == "8";

    return new Promise((resolve, reject) => {
      setComponentesKit((prev) => {
        const newComponentesKit = prev.map((componente: any) =>
          componente.id_item == data.id_item
            ? { ...componente, ...data }
            : componente
        );

        return ordenarComponentesKit(
          ehInversor
            ? reconciliarTabelaPrecoDosInversores(newComponentesKit)
            : aplicarPrecosConformeTabelaPreco(newComponentesKit)
        );
      });

      // Marca edição manual de inversor para evitar redimensionamento automático em etapas anteriores.
      if (data.tipo_item == "8") {
        form.setValue("inversorAlteracao", true);
      }

      // Se estiver alterando um inversor ele altera a quantidade de conectores de acordo com a quantidade de strings
      if (data.tipo_item == "8") {
        if (
          +data.qtd_item > 1 ||
          componentesKit.filter((componente) => componente.tipo_item == "8")
            .length > 1
        ) {
          const qtdStrings = componentesKit
            .filter((componente) => componente.tipo_item == "8")
            ?.reduce((acc: number, curr: any) => {
              acc = acc + +curr.strings_item * +curr.qtd_item;
              return acc;
            }, 0);
          setComponentesKit((prev) => {
            const newComponentesKit = [...prev].map((componente) => {
              if (componente.tipo_item == "3") {
                componente["qtd_item"] = qtdStrings;
              }
              return componente;
            });

            return ordenarComponentesKit(newComponentesKit);
          });
        }
      }
      setKeyComponentes(keyComponentes + 1);
      resolve("Editado!");
    }).finally(() => {
      setIsLoading(false);
      setIsOpenNewItem(false);
    });
  }

  async function submitDeleteItemKit(data: { id_item: number }) {
    setIsLoading(true);
    return new Promise((resolve, reject) => {
      setComponentesKit((prev) => {
        const itemRemovido = prev.find(
          (componente) => String(componente.id_item) === String(data.id_item)
        );
        if (String(itemRemovido?.tipo_item) === "8") {
          form.setValue("inversorAlteracao", true);
        }

        const isInversor = String(itemRemovido?.tipo_item) === "8";

        const newComponentesKit = [...prev].filter((componente) => {
          const isMesmoItem =
            String(componente.id_item) === String(data.id_item);

          if (isMesmoItem) {
            return false;
          }

          return true;
        });

        const itemDeletado = prev.find((i) => i.id_item === data.id_item);

        if (isInversor) {
          const idInversorRemovido = String(data.id_item);
          // Cadastro com codInversor_item = "*" (vale pra qualquer inversor) ou
          // item automático de proposta antiga/montada sem essa origem gravada
          // não tem como casar por id_inversor específico. Sem outro inversor
          // sobrando no kit, esse item ficou órfão de qualquer forma — remove
          // junto mesmo sem o match exato.
          const nenhumInversorRestante = !newComponentesKit.some(
            (componente: any) => String(componente.tipo_item) === "8"
          );
          const TIPOS_DEPENDENTES_DE_INVERSOR = [
            "Item Composto",
            "Stringbox",
            "Bateria",
          ];
          const componentesAjustados = newComponentesKit.reduce(
            (acc: any[], componente: any) => {
              if (!componente.automatico) {
                acc.push(componente);
                return acc;
              }

              const origensAutomaticas = Array.isArray(
                componente.origensAutomaticas
              )
                ? componente.origensAutomaticas
                : componente.origem_inversor_item
                  ? [
                    {
                      id_inversor: String(componente.origem_inversor_item),
                      qtd: Number(componente.qtd_item || 0) || 1,
                    },
                  ]
                  : [];

              const origemRemovida = origensAutomaticas.find(
                (origem: any) =>
                  String(origem.id_inversor) === idInversorRemovido
              );

              if (!origemRemovida) {
                const dependeDeInversor = TIPOS_DEPENDENTES_DE_INVERSOR.includes(
                  String(componente.nome_tipo_item)
                );
                if (dependeDeInversor && nenhumInversorRestante) {
                  return acc;
                }
                acc.push(componente);
                return acc;
              }

              const qtdAtual = Number(componente.qtd_item || 0);
              const qtdRemover =
                String(componente.nome_tipo_item) === "Item Composto"
                  ? 1
                  : Number(origemRemovida.qtd || 0) || 1;
              const qtdRestante = qtdAtual - qtdRemover;
              const origensRestantes = origensAutomaticas.filter(
                (origem: any) =>
                  String(origem.id_inversor) !== idInversorRemovido
              );

              if (qtdRestante > 0) {
                acc.push({
                  ...componente,
                  qtd_item: String(qtdRestante),
                  origensAutomaticas: origensRestantes,
                });
              }

              return acc;
            },
            []
          );

          // Remover um inversor pode mudar (ou zerar) o conjunto que ainda
          // bate com alguma linha de Tabela de Preço — reavalia sempre em
          // cima do conjunto de inversores restante, mesmo quando ainda
          // sobra algum outro inversor no kit.
          return ordenarComponentesKit(
            reconciliarTabelaPrecoDosInversores(componentesAjustados)
          );
        }

        return ordenarComponentesKit(
          aplicarPrecosConformeTabelaPreco([...newComponentesKit])
        );
      });
      setKeyComponentes(keyComponentes + 1);
      resolve("Deletado!");
    }).finally(() => {
      setIsLoading(false);
      setIsOpenNewItem(false);
    });
  }

  // Acha a linha de Tabela de Preço certa, respeitando a ordem das specs:
  // 1) Distribuidor/loja/telhado (já filtrado por
  //    listarLinhasTabelaPrecoParaSelecao via getFiltrosTabelaPreco);
  // 2) Módulo (mesma potência) e Qtd de Módulos do sistema atual;
  // 3) só então valida o(s) inversor(es) — precisa bater o conjunto EXATO
  //    (mesmo(s) modelo(s), mesma(s) quantidade(s)).
  // Sem essa ordem, uma tabela com várias linhas usando o mesmo inversor em
  // qtds de módulos diferentes casava com a linha errada (só olhava o
  // inversor, ignorando pra qual módulo/qtd aquele preço vale).
  // Usa `tabelasPrecos` (só as com mostrarAut = "1"), NÃO `todasTabelasPrecos`
  // — essa flag existe pra controlar o que entra em fluxo automático; usar a
  // lista completa aqui deixava puxar tabela que só devia aparecer no picker
  // manual, e como as outras telas (olho, sync por potência) só conhecem
  // `tabelasPrecos`, a linha resolvida ficava ilegível ("não foi possível
  // carregar os dados da linha").
  // Único ponto de reconciliação da Tabela de Preço com o(s) inversor(es)
  // atuais do kit — chamado sempre que um inversor é adicionado, editado ou
  // removido em Componentes (submitAddItemKit/submitEditItemKit/
  // submitDeleteItemKit). Sempre reconstrói do zero: remove qualquer Tabela
  // de Preço automática já presente e adiciona de novo só se o conjunto
  // atual de inversores ainda bater com alguma linha — nunca soma
  // quantidade. mesclarItensAutomaticos (usada pra stringbox/bateria/item
  // composto, que de fato empilham por inversor) causava duplicação de
  // valor aqui se a remoção da linha antiga falhasse por qualquer motivo.
  const reconciliarTabelaPrecoDosInversores = (listaAtual: any[]) => {
    const inversoresAtuais = listaAtual.filter(
      (componente: any) => String(componente.tipo_item) === "8"
    );
    const par = encontrarParTabelaPrecoParaInversores(inversoresAtuais, listaAtual);
    const novoComponente = par
      ? {
        ...criarComponenteTabelaPreco(
          par.tabela,
          par.linha,
          undefined,
          itensKitTabelaPreco ?? [],
          getFiltrosTabelaPreco()?.id_telhado
        ),
        automatico: true,
      }
      : null;

    return aplicarPrecosConformeTabelaPreco(
      mesclarComponentesTabelaPrecoAutomaticos(
        listaAtual,
        novoComponente ? [novoComponente] : [],
        itensKitTabelaPreco ?? [],
        tabelasPrecos ?? []
      )
    );
  };

  const encontrarParTabelaPrecoParaInversores = (
    inversoresAtuais: any[],
    listaAtual: any[] = componentesKit
  ) => {
    const chaveInversor = (idItem: any, descricao: any) => {
      if (idItem != null && idItem !== "") return `id:${String(idItem)}`;
      const desc = String(descricao || "").trim().toLowerCase();
      return desc ? `desc:${desc}` : null;
    };
    const multisetKit = new Map<string, number>();
    inversoresAtuais.forEach((inv: any) => {
      const chave = chaveInversor(inv.id_item, inv.descricao_item ?? inv.descricao);
      if (!chave) return;
      const qtd = Number(inv.qtd_item ?? inv.qtd ?? 1) || 1;
      multisetKit.set(chave, (multisetKit.get(chave) || 0) + qtd);
    });
    if (!multisetKit.size) return null;

    const filtros = getFiltrosTabelaPreco();
    // totalModulos (form) pode não refletir a qtd real do componente Módulos
    // no kit (ex.: dimensionamento original vs. quantidade ajustada depois
    // na lista de Componentes) — usa a quantidade que está de fato lá.
    // Lê de `listaAtual` (o estado recém-calculado passado por quem chamou),
    // não do `componentesKit` de fora — esse ainda é o da última renderização
    // e, num remove-e-readiciona-inversor em sequência rápida, podia estar
    // um passo atrás do que acabou de ser montado.
    const moduloAtual = (listaAtual || componentesKit)?.find(
      (item: any) => String(item.tipo_item) === "9"
    );
    const qtdModulosAtual = Number(
      moduloAtual?.qtd_item ?? totalModulos ?? 0
    );
    const potenciaModuloAtual = Number(
      moduloAtual?.potencia_item ?? modulo?.potencia_item ?? 0
    );
    const idModuloAtual = moduloAtual?.id_item ?? modulo?.id_item ?? null;
    // Mesma resolução do aviso "Componentes com distribuidor diferente do
    // kit" (useEffect logo abaixo) — reaproveita pra nunca puxar
    // automaticamente uma tabela que esse próprio aviso considera de outro
    // distribuidor, mesmo que o filtro de cadastro acima não tenha barrado.
    const idDistribuidorKit = kitManual
      ? distribuidor?.id_distribuidor ?? distribuidor?.value
      : kitEscolhido?.distribuidor;

    return (
      listarLinhasTabelaPrecoParaSelecao(tabelasPrecos, filtros).find(
        ({ tabela, linha }: any) => {
          if (
            componenteDistribuidorDiferenteDoKit(
              { codDistribuidor_item: tabela?.codDistribuidor_tabela_preco },
              idDistribuidorKit
            )
          ) {
            return false;
          }

          // Tabela cadastrada com um módulo específico (idModulo_tabela_preco)
          // tem que bater o MESMO módulo, não só a potência — dois módulos de
          // fabricantes diferentes podem ter a mesma potência e não são
          // intercambiáveis pro preço dessa tabela.
          if (tabela?.idModulo_tabela_preco) {
            if (
              idModuloAtual == null ||
              idModuloAtual === "" ||
              String(tabela.idModulo_tabela_preco) !== String(idModuloAtual)
            ) {
              return false;
            }
          } else {
            const potenciaModuloLinha = Number(
              linha.potencia_modulo_linha ?? linha.potencia_modulo ?? 0
            );
            if (
              potenciaModuloAtual > 0 &&
              potenciaModuloLinha > 0 &&
              Math.abs(potenciaModuloLinha - potenciaModuloAtual) > 0.05
            ) {
              return false;
            }
          }

          const qtdModulosLinha = Number(
            linha.qtd_modulos_linha ?? linha.qtd_modulos ?? 0
          );
          if (qtdModulosAtual > 0 && qtdModulosLinha !== qtdModulosAtual) {
            return false;
          }

          const multisetLinha = new Map<string, number>();
          (linha.inversores || []).forEach((inv: any) => {
            const chave = chaveInversor(inv.id_item, inv.descricao ?? inv.label);
            if (!chave) return;
            const qtd = Number(inv.qtd ?? inv.quantidade ?? 1) || 1;
            multisetLinha.set(chave, (multisetLinha.get(chave) || 0) + qtd);
          });
          if (
            !multisetLinha.size ||
            multisetLinha.size !== multisetKit.size
          ) {
            return false;
          }
          for (const [chave, qtd] of multisetLinha) {
            if (multisetKit.get(chave) !== qtd) return false;
          }
          return true;
        }
      ) || null
    );
  };

  async function submitAddItemKit(componente: any) {
    const componenteNormalizado = {
      ...componente,
      qtd_item: Number(componente?.qtd_item ?? componente?.qtd ?? 1) || 1,
    };

    if (componente.nome_tipo_item == "Inversores") {
      Swal.fire({
        title: "Atenção!",
        text: "Para adicionar um inversor, é necessário que verifique a quantidade de conectores e outros dados dos componentes.",
        icon: "warning",
        showCancelButton: true,
        confirmButtonText: "Adicionar mesmo assim",
        cancelButtonText: "Cancelar",
        confirmButtonColor: "#3085d6",
        cancelButtonColor: "#d33",
      }).then(async (result) => {
        if (result.isConfirmed) {
          setIsLoading(true);
          if (
            componentesKit?.some(
              (componenteKit) => componenteKit.id_item == componente.id_item
            )
          ) {
            return submitEditItemKit({
              ...componenteNormalizado,
              id_item: componente.id_item,
              qtd_item: componenteNormalizado.qtd_item,
            });
          }
          const itensCompostosDoInversor = getItensCompostosDaFaixa(potenciaKwp, [
            componente,
          ])
            .filter(
              (item: any) =>
                Boolean(Number(item.mostrarAut_item)) &&
                (item.codInversor_item == "*" ||
                  item.codInversor_item == componente.id_item)
            )
            .map((item: any) =>
              criarItemComposto(item, componente.id_item, componente)
            );
          const stringboxesDoInversor =
            await carregarStringboxesDoInversor(componente);
          const bateriasDoInversor =
            await carregarBateriasDoInversor(componente);

          return new Promise((resolve, reject) => {
            setComponentesKit((prev) => {
              const novosItens = [
                componenteNormalizado,
                ...itensCompostosDoInversor,
                ...stringboxesDoInversor,
                ...bateriasDoInversor,
              ];

              // Reconcilia a Tabela de Preço em cima do conjunto de
              // inversores já com o novo incluído — se bater EXATAMENTE com
              // o de alguma linha de alguma Tabela de Preço ativa, ela entra
              // (ou é atualizada) automaticamente.
              return ordenarComponentesKit(
                reconciliarTabelaPrecoDosInversores(
                  mesclarItensAutomaticos(prev, novosItens)
                )
              );
            });

            setKeyComponentes(keyComponentes + 1);
            resolve("Adicionado!");
          }).finally(() => {
            setIsLoading(false);
            setIsOpenNewItem(false);
          });
        }
      });
    } else {
      setIsLoading(true);
      if (
        componentesKit?.some(
          (componenteKit) => componenteKit.id_item == componente.id_item
        )
      ) {
        return submitEditItemKit({
          ...componenteNormalizado,
          id_item: componente.id_item,
          qtd_item: componenteNormalizado.qtd_item,
        });
      }

      // Tabela de Preço escolhida manualmente no picker também fica presa ao
      // inversor atual do kit — igual item composto/stringbox/bateria: some
      // se esse inversor for removido depois.
      const ehTabelaPreco = String(componente.tabela_preco) === "1";
      const inversorAtual = ehTabelaPreco
        ? componentesKit?.find(
          (item: any) => String(item.tipo_item) === "8"
        )
        : null;
      const componenteParaAdicionar = inversorAtual
        ? {
          ...componenteNormalizado,
          automatico: true,
          origem_inversor_item: String(inversorAtual.id_item),
          origensAutomaticas: [
            { id_inversor: String(inversorAtual.id_item), qtd: 1 },
          ],
        }
        : componenteNormalizado;

      return new Promise((resolve, reject) => {
        setComponentesKit((prev) => {
          const novosComponentes = [...prev, componenteParaAdicionar];
          if (String(componente.tipo_item) !== "8") {
            return ordenarComponentesKit(
              aplicarPrecosConformeTabelaPreco(novosComponentes)
            );
          }

          const sincronizado = sincronizarItensCompostosAutomaticos(
            novosComponentes,
            true,
            componente
          );
          form.setValue(
            "componentesCompostosRemovidos",
            sincronizado.removidos
          );
          return sincronizarTabelasPrecosAutomaticos(sincronizado.lista);
        });

        setKeyComponentes(keyComponentes + 1);
        resolve("Adicionado!");
      }).finally(() => {
        setIsLoading(false);
        setIsOpenNewItem(false);
      });
    }
  }

  // const overload = kitSelecionado.overload;
  // const overLoadValue = overload.value;
  // const overloadReferenceMax = overload.reference.maxT;
  // const overloadReferenceMin = overload.reference.minT;
  const { overLoadValue, overloadReferenceMax, overloadReferenceMin } =
    overload;

  const larguraTotal = 200; // mesma largura do contêiner (px)
  const valorAtual =
    ((overLoadValue - overloadReferenceMin) * 100) /
    ((calculo_capacidade_modulos_parametro
      ? calculo_capacidade_modulos_parametro?.value === "0"
        ? overloadReferenceMax
        : potenciaTotalInvesores
      : overloadReferenceMax) -
      overloadReferenceMin);

  const larguraBarra = valorAtual * 2 + "px"; // sua fórmula original
  const isSmall = parseFloat(larguraBarra) < larguraTotal / 2;

  useEffect(() => {
    if (calculo_capacidade_modulos_parametro?.value === "2") {
      const diff =
        +potenciaTotalInvesores *
        (parseFloat(porcent_calculo_capacidade_modulos_parametro) / 100);
    }
  }, []);
  useEffect(() => {
    if (kitManual) {
      const idDistribuidorKit =
        distribuidor?.id_distribuidor ?? distribuidor?.value;
      const distribuidoresDiff = componentesKit
        .filter((componente) =>
          componenteDistribuidorDiferenteDoKit(componente, idDistribuidorKit)
        )
        .map((componente) => componente.descricao_item);
      setHasDiffDistributor(distribuidoresDiff);
      form.setValue("distribuidorDiff", distribuidoresDiff);
    } else if (kitEscolhido) {
      const distribuidoresDiff = componentesKit
        .filter((componente) =>
          componenteDistribuidorDiferenteDoKit(
            componente,
            kitEscolhido?.distribuidor
          )
        )
        .map((componente) => componente.descricao_item);
      setHasDiffDistributor(distribuidoresDiff);
      form.setValue("distribuidorDiff", distribuidoresDiff);
    } else {
      setHasDiffDistributor([]);
      form.setValue("distribuidorDiff", []);
    }
  }, [componentesKit]);

  // Cabeçalho e linhas precisam da mesma lista de colunas; as de valor seguem
  // exatamente a mesma condição usada em ItemComponenteProposta.
  const colunasTabela = [
    "Componente",
    "ID Item",
    "Descrição",
    "Quantidade",
    ...(usuario.visualiza_custo_kit_usuario == "1"
      ? ["Valor Unitário", "Total"]
      : []),
  ];

  return (
    <Container key={keyComponentes} className="max-sm:h-auto max-sm:p-2">
      <div className="text-boxdark max-sm:text-xs dark:text-white relative">
        <div>
          <div className="flex flex-row flex-wrap max-sm:flex-col justify-between gap-2">
            <div className="flex-1 min-w-0 w-full flex flex-col gap-1">
              {/* <div>Componentes</div> */}
              <div className="">
                <p className="max-sm:text-sm flex items-center gap-1">
                  Componentes do kit da{" "}
                  {kitManual
                    ? distribuidor?.nome_distribuidor
                    : distribuidores?.find(
                      (distribuidor: any) =>
                        distribuidor.id_distribuidor ==
                        kitEscolhido?.distribuidor
                    )?.nome_distribuidor}
                  <span
                    className="text-primary cursor-pointer"
                    title="Regras de Alteração/Inclusão/Exclusão dos itens nos Componentes"
                    onClick={() => {
                      Swal.fire({
                        icon: "info",
                        title:
                          "Regras de Alteração/Inclusão/Exclusão dos itens nos Componentes",
                        width: 650,
                        html: `
                          <div style="text-align:left">
                            <p><b>Baseado na Tabela de Preço por Distribuidor e módulo.</b><br/>
                            <i>(É necessário existir a Tabela de Preço para o Distribuidor e módulo para que as regras funcionem)</i></p>
                            <ol style="padding-left: 1.1em; margin: 0;">
                              <li style="margin-bottom: 10px;">
                                Quando <b>EXCLUIR</b> o item Tabela de Preço:<br/>
                                <b>Deve sempre:</b>
                                <ol type="a" style="padding-left: 1.2em; margin: 4px 0 0;">
                                  <li>Carregar os valores dos itens.</li>
                                </ol>
                              </li>
                              <li style="margin-bottom: 10px;">
                                Quando <b>EXCLUIR</b> o item inversor:<br/>
                                <b>Deve sempre:</b>
                                <ol type="a" style="padding-left: 1.2em; margin: 4px 0 0;">
                                  <li>excluir o item <b>Tabela de Preço</b>,</li>
                                  <li>excluir os <b>Itens Compostos</b> e</li>
                                  <li>excluir os itens <b>Stringbox</b>, quando tiver.</li>
                                </ol>
                              </li>
                              <li style="margin-bottom: 10px;">
                                Quando <b>INCLUIR</b> novo item inversor:<br/>
                                <b>Deve sempre:</b>
                                <ol type="a" style="padding-left: 1.2em; margin: 4px 0 0;">
                                  <li>incluir os <b>Itens Compostos</b>,</li>
                                  <li>incluir os itens <b>Stringbox</b>, e</li>
                                  <li>incluir o item <b>Tabela de Preço</b> com novo preço se tiver cadastrado na Tabela de Preço; senão, deixa sem o item Tabela de Preço e <b>zera os valores dos itens</b>, menos dos Itens Compostos e Stringbox.</li>
                                </ol>
                              </li>
                              <li>
                                Quando <b>ALTERAR</b> a qtde do item inversor:<br/>
                                <b>Deve sempre:</b>
                                <ol type="a" style="padding-left: 1.2em; margin: 4px 0 0;">
                                  <li>excluir o item <b>Tabela de Preço</b>, e se encontrar um item com a qtd de inversores informada na Tabela de Preço, carregar este item; senão, deixa sem o item Tabela de Preço e carrega os valores dos itens.</li>
                                </ol>
                              </li>
                            </ol>
                          </div>
                        `,
                      });
                    }}
                  >
                    <InfoIcon size={16} />
                  </span>
                </p>
                {Object.entries(avisos).map(([key, mensagem]) => (
                  <div
                    key={key}
                    className=" mb-3 w-full flex border items-center  bg-[#fff5ea]  gap-2 px-4 p-4 rounded-md border-[#fcdcaa] shadow-sm"
                  >
                    <div className="rounded-full p-1 shadow-md bg-[#fef9f6]">
                      <RiErrorWarningFill size={20} color="#ffb747" />
                    </div>
                    <div className="grid gap-2">
                      <p className="text-black">&bull; {mensagem}</p>
                    </div>
                  </div>
                ))}
              </div>
              {canEditKit && (
                <>
                  {has_overload && (
                    <div className="bg-error text-white w-fit px-1 rounded">
                      Erro: Overload do Inversor{`: ${has_overload}`}
                    </div>
                  )}

                  {!hasAllComponents && componentesObrigatorios.length > 0 && (
                    <div className="bg-error text-white w-fit px-1 rounded">
                      Erro: Não possui:{" "}
                      {componentesObrigatorios
                        .filter(
                          (componenteObrigatorio: any) =>
                            !componentesKit
                              .map((componente: any) =>
                                String(
                                  componente.tipo_item ??
                                  componente.id_tipo_item ??
                                  ""
                                )
                              )
                              .includes(String(componenteObrigatorio?.value))
                        )
                        ?.map((componente: any) => componente?.label)
                        .join(", ")}
                    </div>
                  )}
                  {hasDiffDistribuitor.length > 0 && (
                    <div className="mb-3 w-full flex items-start bg-red-50 dark:bg-red-900/20 border-l-4 border-red-500 px-4 py-3 rounded-lg shadow-sm">
                      <div className="rounded-full p-1 shadow bg-white/80 dark:bg-red-900/40 mr-2 mt-0.5">
                        <RiErrorWarningFill
                          size={18}
                          className="text-red-600 dark:text-red-400"
                        />
                      </div>
                      <div className="flex-1">
                        <p className="text-sm font-semibold text-red-800 dark:text-red-300">
                          Componentes com distribuidor diferente do kit
                        </p>
                        <div className="mt-2 flex flex-wrap gap-2">
                          {hasDiffDistribuitor.map(
                            (nome: string, idx: number) => (
                              <span
                                key={`${nome}-${idx}`}
                                className="text-xs bg-red-100 text-red-800 dark:bg-red-800/40 dark:text-red-100 px-2 py-1 rounded-full border border-red-200 dark:border-red-600"
                                title={nome}
                              >
                                {nome}
                              </span>
                            )
                          )}
                        </div>
                      </div>
                    </div>
                  )}
                  <div className="flex gap-5 max-sm:flex-col">
                    {componentesKit.some(
                      (componente) => componente.tipo_item == 8
                    ) && (
                        <>
                          <fieldset className="flex flex-col border-black/25 border rounded p-2 px-3 w-fit">
                            <legend>
                              {calculo_capacidade_modulos_parametro
                                ? calculo_capacidade_modulos_parametro?.value ===
                                  "0"
                                  ? "Overload do inversor"
                                  : calculo_capacidade_modulos_parametro?.value ===
                                    "1"
                                    ? "Potência nominal"
                                    : `Potencia Nominal do Inversor + % Configurado (${String(porcent_calculo_capacidade_modulos_parametro || "0").replace("%", "")}%)`
                                : "Overload do inversor"}
                            </legend>
                            <div className="flex flex-row items-center gap-2">
                              <div>{String(overloadReferenceMin.toFixed(2))}</div>
                              <div className="w-[200px] h-[20px] bg-black-2/30 relative rounded overflow-hidden">
                                <div
                                  className="h-full flex flex-row items-center  rounded " // bg-gradient-to-r from-primary to-error
                                  style={{
                                    width: larguraBarra,
                                    background:
                                      "linear-gradient(90deg, rgba(9,9,121,1) 0, rgba(9,9,121,1) 100px, rgba(255,0,0,1) 200px)",
                                  }}
                                >
                                  <div
                                    style={{
                                      color: isSmall ? "black" : "white",
                                    }}
                                    className="text-sm max-sm:text-xs  font-bold absolute left-[50%]"
                                  >
                                    {String(overLoadValue)}
                                  </div>
                                </div>
                              </div>
                              <div>
                                {// new Intl.NumberFormat("pt-BR", {
                                  //   maximumFractionDigits: 2,
                                  // }).format(
                                  (calculo_capacidade_modulos_parametro
                                    ? calculo_capacidade_modulos_parametro?.value ===
                                      "0"
                                      ? overloadReferenceMax
                                      : calculo_capacidade_modulos_parametro?.value ===
                                        "1"
                                        ? potenciaTotalInvesores
                                        : +potenciaTotalInvesores +
                                        +potenciaTotalInvesores *
                                        (parseFloat(
                                          porcent_calculo_capacidade_modulos_parametro
                                        ) /
                                          100)
                                    : overloadReferenceMax
                                  )?.toFixed(
                                    2
                                  )
                                  // )}
                                }
                              </div>
                            </div>
                          </fieldset>

                          <fieldset className="border px-4 py-3 rounded shadow-sm w-fit">
                            <legend>Capacidade do(s) Inversor(es)</legend>
                            <div className="flex items-center gap-3 text-base-content">
                              <svg
                                xmlns="http://www.w3.org/2000/svg"
                                className="h-6 w-6 text-primary"
                                fill="none"
                                viewBox="0 0 24 24"
                                stroke="currentColor"
                              >
                                <path
                                  strokeLinecap="round"
                                  strokeLinejoin="round"
                                  strokeWidth={2}
                                  d="M9 20l-5.447-2.724A1 1 0 013 16.382V5.618a1 1 0 011.447-.894L9 7m0 13l6-3m-6 3V7m6 10l4.553 2.276A1 1 0 0021 18.382V7.618a1 1 0 00-.553-.894L15 4m0 13V4m0 0L9 7"
                                />
                              </svg>
                              <div className="flex gap-4">
                                {["1", "2"].includes(
                                  form.getValues(
                                    "calculo_capacidade_modulos_parametro"
                                  )?.value
                                ) ? null : (
                                  <div className="flex items-center gap-1">
                                    <span className="font-medium">Mínimo:</span>
                                    <span className="text-primary font-semibold">
                                      {modulosLimit.minModulos}
                                    </span>
                                  </div>
                                )}
                                <div className="h-6 w-px bg-primary/20" />
                                <div className="flex items-center gap-1">
                                  <span className="font-medium">Máximo:</span>
                                  <span className="text-primary font-semibold">
                                    {modulosLimit.maxModulos}
                                  </span>
                                </div>
                              </div>
                              <Button
                                className="bg-transparent text-primary p-0"
                                type="button"
                                onClick={(e: any) => {
                                  e.stopPropagation();

                                  // Gerar a fórmula para cada inversor
                                  const formulas = inversoresUsados.map(
                                    (inversor: any, index) => {
                                      const paramCalculo = form.getValues(
                                        "calculo_capacidade_modulos_parametro"
                                      )?.value;
                                      const paramPorcentCalculo = form.getValues(
                                        "porcent_calculo_capacidade_modulos_parametro"
                                      );

                                      const potenciaInversorW =
                                        parseFloat(inversor.potencia_item) * 1000; // kW para W
                                      const underload =
                                        +inversor.underload_item / 100;
                                      const overload = ["1", "2"].includes(
                                        paramCalculo
                                      )
                                        ? 1
                                        : +inversor.overload_item / 100;
                                      const potenciaModulo = componentesKit.find(
                                        (modulo) => modulo.tipo_item == 9
                                      )?.potencia_item;

                                      const qtdItem =
                                        parseInt(inversor.qtd_item) || 1;

                                      // Cálculo dos módulos mínimos e máximos
                                      const minModulos = Math.floor(
                                        (potenciaInversorW *
                                          qtdItem *
                                          underload) /
                                        potenciaModulo
                                      );
                                      let maxModulos =
                                        (potenciaInversorW * qtdItem * overload) /
                                        potenciaModulo;

                                      let extraCalculo = "";

                                      if (
                                        paramCalculo &&
                                        paramCalculo === "2" &&
                                        porcent_calculo_capacidade_modulos_parametro
                                      ) {
                                        const somaPorcentCalculo =
                                          maxModulos *
                                          (parseFloat(
                                            porcent_calculo_capacidade_modulos_parametro
                                          ) /
                                            100);
                                        maxModulos =
                                          maxModulos + somaPorcentCalculo;
                                        extraCalculo = `+ (${porcent_calculo_capacidade_modulos_parametro}\\% \\text{ de } ${Math.floor(maxModulos - somaPorcentCalculo)})`;
                                      }
                                      maxModulos = Math.floor(maxModulos);
                                      return `
                                      \\begin{array}{c}
                                        \\text{${inversor.descricao_item.split(" ").slice(0, 4).join(" ")}} \\\\
                                        \\begin{bmatrix}
                                          \\text{Mín.} = \\frac{${potenciaInversorW} \\times ${qtdItem} \\times ${underload}}{${potenciaModulo}} = ${minModulos} \\\\
                                          \\text{Máx.} = \\frac{${potenciaInversorW} \\times ${qtdItem} \\times ${overload}}{${potenciaModulo}} ${extraCalculo} = ${maxModulos}
                                        \\end{bmatrix}
                                      \\end{array} \\\\

                                    \\\\[6pt]
                                      \\textbf{Legenda das variáveis:} \\\\
                                      \\begin{array}{ll}
                                        P_{inv} & = \\text{Potência nominal do inversor (em W)} \\\\
                                        Q_{inv} & = \\text{Quantidade de inversores} \\\\
                                        U & = \\text{Underload (fração mínima de carga permitida)} \\\\
                                        O & = \\text{Overload (fração máxima de carga permitida)} \\\\
                                        P_{mod} & = \\text{Potência do módulo (em W)} \\\\
                                        \\text{Mín.} & = \\frac{P_{inv} \\times Q_{inv} \\times U}{P_{mod}} \\\\
                                        \\text{Máx.} & = \\frac{P_{inv} \\times Q_{inv} \\times O}{P_{mod}} ${paramCalculo === "2" &&
                                          porcent_calculo_capacidade_modulos_parametro
                                          ? `+ \\text{(${porcent_calculo_capacidade_modulos_parametro}\\% adicional)}`
                                          : ""
                                        }
                                      \\end{array}
                                    `;
                                    }
                                  );

                                  // Montar o HTML para exibir as fórmulas separadamente
                                  const formulasHtml = formulas
                                    .map((formula) => {
                                      return `<div style="display: flex; flex-direction: column; margin-bottom: 20px; text: 10px;">${katex.renderToString(
                                        formula,
                                        { throwOnError: false }
                                      )}</div>`;
                                    })
                                    .join("");

                                  Swal.fire({
                                    icon: "info",
                                    showConfirmButton: false,
                                    title: "Fórmulas por Inversor",
                                    html: `
                                  <div style="display: flex; flex-direction: column; align-items: center; font-size: 0.9rem; padding: 10px;">
                                    ${formulasHtml}
                                  </div>
                                `,
                                  });
                                }}
                              >
                                <InfoIcon size={24} />
                              </Button>
                            </div>
                          </fieldset>

                          <fieldset className="border px-1 py-3 rounded shadow-sm w-fit">
                            <legend className="flex-wrap whitespace-break-spaces">
                              Potência do(s) Inversor(es)
                            </legend>
                            <div className="flex items-center gap-3 justify-center text-base-content">
                              <Zap size={20} className=" text-primary" />
                              <div className="flex gap-4">
                                <div className="flex items-center gap-1">
                                  <span className="text-primary font-semibold">
                                    {potenciaTotalInvesores}
                                  </span>
                                </div>
                              </div>
                            </div>
                          </fieldset>

                          <fieldset className="border px-4 py-3 rounded shadow-sm w-fit">
                            <legend>Parâmetros de Cabos</legend>
                            <div className="flex flex-col gap-1 text-sm">
                              <div className="flex items-center gap-2">
                                Fórmula selecionada:{" "}
                                <strong>
                                  {calculoCaboParametro === "1"
                                    ? "Qtd Cabos x Qtd Módulos x Qtd Strings do Inversor"
                                    : "Qtd Cabos x Qtd Módulos"}
                                </strong>
                                <Button
                                  className="bg-transparent text-primary p-0"
                                  type="button"
                                  onClick={(e: any) => {
                                    e.stopPropagation();
                                    abrirInfoFormulaCabos();
                                  }}
                                >
                                  <InfoIcon size={18} />
                                </Button>
                              </div>
                            </div>
                          </fieldset>
                        </>
                      )}
                  </div>
                </>
              )}
            </div>
            <div className="flex max-sm:grid justify-items-center flex-row gap-2 shrink-0 ml-auto">
              <div className="flex flex-col justify-center">
                {canEditKit && (
                  // <Tooltip title="Adicionar Item" arrow={true} placement="left">
                  <Button
                    className=""
                    type="button"
                    onClick={() => setIsOpenNewItem(true)}
                  >
                    <Plus size={15} />
                  </Button>
                  // </Tooltip>
                )}
                {isOpenNewItem && (
                  <ModalComponente
                    hasForm={false}
                    header="Novo Item"
                    // defaultW="w-fit"
                    className="max-h-[70vh]"
                    opened={isOpenNewItem}
                    onClose={() => setIsOpenNewItem(false)}
                    hasSaveButton={false}
                  >
                    <NewItemComponentePropostaForm
                      submitAddItemKit={submitAddItemKit}
                      componentesKit={componentesKit}
                      dadosCard={dadosCard}
                      dadosForm={form.control._formValues}
                      distribuidor={
                        !kitManual
                          ? kitEscolhido?.distribuidor
                          : distribuidor?.id_distribuidor
                      }
                      distribuidorNativo={
                        String(
                          !kitManual
                            ? kitEscolhido?.distribuidor
                            : distribuidor?.id_distribuidor
                        ) === "4"
                      }
                      itemCompostos={itensCompostos.filter(
                        (item: any) =>
                          Number(item.potenciaDe_item) <= potenciaKwp &&
                          Number(item.potenciaAte_item) >= potenciaKwp
                      )}
                      tabelasPrecos={tabelasPrecos}
                      itensKitTabelaPreco={itensKitTabelaPreco}
                      filtrosTabelaPreco={getFiltrosTabelaPreco()}
                      defaultFilters={{
                        codFabricante_item:
                          form.control._formValues?.marca_inversor?.value,
                        fases_item:
                          form.control._formValues?.tipoLigacao_proposta,
                        tipoInversor_item:
                          form.control._formValues?.tipo_inversor?.value,
                        tipoStringInversor_item:
                          form.control._formValues?.tipo_string_inversor?.value,
                        tensoes_item: form.control._formValues?.tensoes
                          ?.map((tensao: any) => tensao.value)
                          ?.join(","),
                      }}
                      tensaoPadraoOrigem={tensaoPadraoOrigem}
                      inversoresBD={inversoresBD}
                    />
                  </ModalComponente>
                )}
              </div>
              <div className="flex flex-col items-center justify-center text-end">
                <div className="">Potência</div>
                <div className="self-center rounded-lg p-1 flex items-center border-bodydark text-white text-xs bg-success">
                  <BsLightningChargeFill />
                  {FormatFields.formatarNumero(
                    kitManual ? potenciaKwp : kitEscolhido?.potencia_kit
                  )}
                  Wp
                  {/* {kitSelecionado.potency}Wp */}
                </div>
              </div>
            </div>
          </div>
          <div className="w-full overflow-x-auto">
            <table className="mt-4 w-full min-w-max table-auto text-left">
              {componentesKit.filter((res) => res.status_item == 1).length >
                0 ? (
                <thead>
                  <tr>
                    {colunasTabela.map((head, index) => {
                      return (
                        <th
                          key={index}
                          className="cursor-pointer border-y  border-stroke bg-stroke/50 p-4 max-sm:p-2 dark:hover:bg-form-strokedark hover:bg-stroke"
                          colSpan={
                            isMobile
                              ? head == "Componente"
                                ? 2
                                : 1
                              : index == colunasTabela.length - 1
                                ? 2
                                : 1
                          }
                        >
                          {/* <Typography
                          variant="small"
                          color="blue-gray"
                          className="flex items-center justify-between gap-2 font-normal  leading-none opacity-90"
                        > */}
                          <div className="flex items-center justify-between gap-2 font-normal  leading-none opacity-90">
                            {head}
                          </div>
                          {/* </Typography> */}
                        </th>
                      );
                    })}
                  </tr>
                </thead>
              ) : (
                <thead>
                  <tr>
                    <th colSpan={2}>
                      <span className="py-4 justify-end flex">
                        Não há componentes para o kit!
                      </span>
                    </th>
                  </tr>
                </thead>
              )}
              <tbody>
                {componentesKit &&
                  componentesKit
                    .filter((res) => res.status_item == 1)
                    .map((componente: any, index: number) => {
                      return (
                        <ItemComponenteProposta
                          key={index}
                          itemIndex={index}
                          dadosDistribuidoresCredenciais={
                            dadosDistribuidoresCredenciais
                          }
                          itemCompostos={itensCompostos}
                          itensComp={itensComp}
                          componente={componente}
                          canEditKit={canEditKit}
                          submitEditItemKit={submitEditItemKit}
                          submitDeleteItemKit={submitDeleteItemKit}
                          componentesKit={componentesKit}
                          potenciaSistema={potenciaKwp}
                          tensaoPadraoOrigem={tensaoPadraoOrigem}
                          tabelasPrecos={tabelasPrecos}
                          itensKitTabelaPreco={itensKitTabelaPreco}
                        />
                      );
                    })}
                {usuario.visualiza_custo_kit_usuario == "1" && (
                  <tr>
                    {/* Mantém a mesma contagem de colunas do cabeçalho/linhas */}
                    <td colSpan={isMobile ? 5 : 4} className={classes}></td>
                    <td colSpan={2} className={classes}>
                      <div className="flex flex-col w-full">
                        <hr />
                        <div>Custo Total do Kit</div>
                        <Typography
                          variant="small"
                          color="blue-gray"
                          className="font-normal"
                        >
                          {formatarValor(custoTotalKit)}
                        </Typography>
                      </div>
                    </td>
                    {!isMobile && <td className={classes}></td>}
                  </tr>
                )}
              </tbody>
            </table>
          </div>
          {camposPersonalizados}
        </div>
        {isLoading && (
          <div className="absolute top-0 left-0 w-full h-full flex flex-col items-center justify-center bg-black-2/10">
            <LoaderSun />
          </div>
        )}
      </div>
    </Container>
  );
};

export default ComponentesProposta;