import LoaderSun from "@/components/common/Loader/LoaderSun";
import Input from "@/components/Forms/Input";
import { handleSweetAlert } from "@/components/Modal/SweetAlertConfirm";
import { listarTodosCargos } from "@/requests/CRUD/Perfil/listarPerfil";
import { toast } from "@/services/toast";
import { useAuth } from "@/src/contexts/authContext";
import { useScreenContext } from "@/src/contexts/ScreenContext";
import { formatarValor, FormatFields } from "@/utils";
import { Tooltip } from "@mui/material";
import { Info, RotateCcw } from "lucide-react";
import { useEffect, useMemo, useRef, useState } from "react";
import { calcularPreco, obterCustosExtras } from "../CXESSIM002";
import ResultadoPrecificacao from "../CXESSIM002/ResultadoPrecificacao";

const PrecificacaoProposta = ({
  form,
  blockNextStep,
  valorColeta,
  dadosCard,
  dadosAmpliacao,
  lastProposalInfo,
  dadosCliente,
  camposPersonalizados,
  setNextStepAction,
  camposPersonalizadosData,
}: any) => {
  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 emptyPrecificacao: any = {
    valor_kit: 0,
    porcentagem_sobre_kit: 0,
    valor_sobre_total_kit: 0,
    porcentagem_lucro_produto: 0,
    porcentagem_encargos_produto: 0,
    porcentagem_lucro_encargos_produto: 0,
    markup_produto: 0,
    valor_produto: 0,
    valor_total_produto: 0,
    valor_fixo_servico: 0,
    obra_por_placa_servico: 0,
    qtd_modulos: 0,
    qtd_ucs: 0,
    valor_obra_por_placa: 0,
    potencia_sistema: 0,
    obra_por_potencia_servico: 0,
    valor_obra_por_potencia: 0,
    valor_obra_servico: 0,
    porcentagem_servico: 0,
    valor_incluindo_porcentagem_servico: 0,
    lucro_servico: 0,
    encargos_servico: 0,
    porcentagem_lucro_encargos_servico: 0,
    markup_servico: 0,
    valor_servico: 0,
    valor_total_servico: 0,
    valor_extra: 0,
    valor_total_produto_servico_extra: 0,
    porcentagem_total: 0,
    valor_total_incluindo_porcentagem: 0,
    lucro_total: 0,
    encargos_total: 0,
    porcentagem_lucro_encargos_total: 0,
    markup_total: 0,
    valor_total: 0,
    preco_venda_sem_comissao: 0,
    preco_venda: 0,
    c_vendedor: 0,
    c_pre_vendedor: 0,
    c_gerente: 0,
    c_supervisor: 0,
    c_indicacao: 0,
    c_indicacao_bruto: 0,
    valor_comissao: 0,
    id_politica_comissao: "",
  };

  const [resultadoPrecificacao, setResultadoPrecificacao] = useState(
    form.control._formValues.resultadoPrecificacao || emptyPrecificacao
  );

  const {
    valor_kit,
    preco_venda_sem_comissao,
    preco_venda_final_sem_comissao,
    preco_venda,
    c_vendedor,
    c_pre_vendedor,
    c_gerente,
    c_supervisor,
    c_indicacao,
    c_indicacao_bruto,
    valor_comissao,
    valor_minimo_venda,
    valor_maximo_venda,
    c_max,
    calcular_comissao_por_loja,
    acaoValorFinalProposta_loja,
    valor_total_produto_servico_extra,
    valor_total_incluindo_porcentagem,
    encargos_total,
    lucro_total,
  } = resultadoPrecificacao;

  const [valorProposta, setValorProposta] = useState<any | number>(
    +FormatFields.desformatarNumeros(
      form.control._formValues?.valorFinalProposta
    ) ||
      preco_venda_final_sem_comissao ||
      0
  );
  const [isLoaded, setIsLoaded] = useState(false);
  const [descontoAcrescimoError, setDescontoAcrescimoError] = useState("");
  // Valor Base Referência: usado só pelo modo "Altera o % de Lucro da
  // Empresa" pra saber que lucro_total_ajuste mandar pro cálculo. Separado do
  // valorProposta ("Ajuste do Valor Base Empresa") de propósito - antes esse
  // fluxo mexia direto no valorProposta, disparando o efeito dele de novo
  // (recalculava comissão do vendedor à toa e ficava re-renderizando a tela).
  const [valorBaseReferencia, setValorBaseReferencia] = useState<number>(0);
  // "Restaurar Valores Iniciais" faz a restauração completa numa única chamada
  // do calcularPreco. O efeito de [valorProposta] disparado por essa mesma
  // restauração emitiria uma segunda chamada DEPOIS da nossa (efeito roda pós
  // render), e como a resposta mais nova é a que vale, ela sobrescreveria a
  // restauração das comissões. Guarda o valor-alvo: quando o efeito vê esse
  // exato valorProposta, sai de fininho e limpa a marca (auto-corrige, não fica
  // engasgado como um boolean ficaria se o efeito não disparasse).
  const valorPropostaRestauradoRef = useRef<number | null>(null);
  // Captura o "Valor Base Empresa" original (política pura) uma única vez,
  // antes de qualquer ajuste de lucro. O card VALOR BASE EMPRESA mostra SEMPRE
  // esse valor original - em qualquer configuração de loja - mesmo com o
  // lucro_total sendo ajustado por trás pra bater o alvo. Quem reflete o
  // ajuste é o "Valor Base Referência" (preco_venda_final_sem_comissao).
  const precoVendaSemComissaoOriginalRef = useRef<number | null>(null);
  if (
    precoVendaSemComissaoOriginalRef.current === null &&
    Number.isFinite(preco_venda_sem_comissao) &&
    preco_venda_sem_comissao > 0
  ) {
    precoVendaSemComissaoOriginalRef.current = preco_venda_sem_comissao;
  }
  // Mesma ideia, mas COM comissão (política padrão, sem nenhum ajuste) - é
  // sobre ESSE valor que o % Máximo de Desconto/Acréscimo do usuário incide
  // (não sobre o Valor Base sem comissão).
  const precoVendaComComissaoOriginalRef = useRef<number | null>(null);
  if (
    precoVendaComComissaoOriginalRef.current === null &&
    Number.isFinite(preco_venda) &&
    preco_venda > 0
  ) {
    precoVendaComComissaoOriginalRef.current = preco_venda;
  }
  // "100%" pra "% Ajustes" e pro cálculo do valor a partir dele sempre tem que
  // ser a base ORIGINAL (política pura), nunca a base já ajustada (que muda
  // no modo Lucro da Empresa) - senão cada edição desconta em cima do
  // desconto anterior, diminuindo o valor infinitamente a cada ciclo.
  const baseReferencia100Porcento =
    precoVendaSemComissaoOriginalRef.current ?? preco_venda_sem_comissao;
  // valor_minimo_venda/valor_maximo_venda (faixa de comissão do Vendedor) são
  // recalculados a cada resposta do calcularPreco a partir da base ATUAL - no
  // modo Lucro da Empresa essa base já vem ajustada, então o "piso" descia
  // junto com o valor a cada edição, nunca travando nada de verdade (dava pra
  // zerar a proposta). Congela os dois na primeira vez que aparecem, igual
  // as outras referências acima.
  const valorMinimoVendaOriginalRef = useRef<number | null>(null);
  if (
    valorMinimoVendaOriginalRef.current === null &&
    Number.isFinite(valor_minimo_venda) &&
    valor_minimo_venda > 0
  ) {
    valorMinimoVendaOriginalRef.current = valor_minimo_venda;
  }
  const valorMaximoVendaOriginalRef = useRef<number | null>(null);
  if (
    valorMaximoVendaOriginalRef.current === null &&
    Number.isFinite(valor_maximo_venda) &&
    valor_maximo_venda > 0
  ) {
    valorMaximoVendaOriginalRef.current = valor_maximo_venda;
  }
  // % de comissão ORIGINAL de cada cargo (política pura), congelados uma
  // única vez - usados como referência pra "cascata de comissões" (zerar
  // Vendedor, depois Pré-Vendedor, Gerente, Supervisor, Indicação, em ordem,
  // até bater o alvo). Usar o valor AO VIVO (resultadoPrecificacao) faria a
  // cascata recalcular sobre uma % já reduzida de um ciclo anterior,
  // encolhendo mais a cada edição em vez de sempre partir do total real da
  // política.
  const cVendedorOriginalRef = useRef<number | null>(null);
  if (
    cVendedorOriginalRef.current === null &&
    Number.isFinite(c_vendedor) &&
    c_vendedor > 0
  ) {
    cVendedorOriginalRef.current = c_vendedor;
  }
  const cPreVendedorOriginalRef = useRef<number | null>(null);
  if (
    cPreVendedorOriginalRef.current === null &&
    Number.isFinite(c_pre_vendedor) &&
    c_pre_vendedor! > 0
  ) {
    cPreVendedorOriginalRef.current = c_pre_vendedor!;
  }
  const cGerenteOriginalRef = useRef<number | null>(null);
  if (
    cGerenteOriginalRef.current === null &&
    Number.isFinite(c_gerente) &&
    c_gerente! > 0
  ) {
    cGerenteOriginalRef.current = c_gerente!;
  }
  const cSupervisorOriginalRef = useRef<number | null>(null);
  if (
    cSupervisorOriginalRef.current === null &&
    Number.isFinite(c_supervisor) &&
    c_supervisor! > 0
  ) {
    cSupervisorOriginalRef.current = c_supervisor!;
  }
  const cIndicacaoOriginalRef = useRef<number | null>(null);
  if (
    cIndicacaoOriginalRef.current === null &&
    Number.isFinite(c_indicacao) &&
    c_indicacao! > 0
  ) {
    cIndicacaoOriginalRef.current = c_indicacao!;
  }
  // % de Lucro da Empresa ORIGINAL (política pura), congelado uma única vez -
  // usado pra restaurar tudo ao estado original quando "Ajuste do Valor Final
  // da Proposta" volta pro valor normal. Sem isso, um desconto/acréscimo
  // anterior que mexeu em lucro_total_ajuste (modo "Lucro da Empresa") deixa
  // esse % "à deriva" pra sempre - ele é reenviado a cada chamada seguinte de
  // atualizarResultadoPrecificacao (ver função abaixo), então voltar o valor
  // final pro original não reestabelece o lucro/comissões originais sozinho.
  const lucroTotalOriginalRef = useRef<number | null>(null);
  if (
    lucroTotalOriginalRef.current === null &&
    Number.isFinite(lucro_total) &&
    lucro_total !== 0
  ) {
    lucroTotalOriginalRef.current = lucro_total!;
  }
  // Guarda de corrida: atualizarResultadoPrecificacao chama uma API async. Se o
  // usuário edita "% Ajustes" e, antes da resposta voltar, edita "Ajuste do
  // Valor Base Empresa" (ou vice-versa), as duas chamadas ficam em voo e a que
  // responder por último "ganha" - mesmo se for a mais antiga/desatualizada,
  // revertendo o campo mais recente pro valor de antes. Só aplica a resposta
  // se ainda for a chamada mais recente disparada.
  const atualizarResultadoPrecificacaoSeq = useRef(0);
  // Marca true só no onBlur real do "Ajuste do Valor Final da Proposta" -
  // usado pra não mostrar o toast de "ajustado pro mínimo/máximo" quando é o
  // valor inicial (carregado da política, sem o usuário ter mexido em nada)
  // que por coincidência já bate exatamente no limite (ex: comissão padrão
  // da política já é a máxima permitida).
  const usuarioEditouAjusteRef = useRef(false);

  const [confirmaAvancoComissao, setConfirmaAvancoComissao] = useState(true);

  const { isMobile } = useScreenContext();
  const { usuario, perfil } = useAuth();
  const formatarNumero = FormatFields.formatarNumero;

  // id do cargo marcado como Vendedor (vendedor_cargo == 1). Usado para decidir
  // a variante (VENDEDOR) x (ADM) das mensagens de atenção - ver
  // usuarioEhVendedor/usuarioVeTextoAdm mais abaixo. Fica null enquanto a lista
  // não carrega, e nesse intervalo vale o fallback cargo_perfil == "2".
  const [idCargoVendedor, setIdCargoVendedor] = useState<string | null>(null);

  useEffect(() => {
    listarTodosCargos()
      .then((cargos: any) => {
        const cargoVendedor = Array.isArray(cargos)
          ? cargos.find((cargo: any) => String(cargo?.vendedor_cargo) === "1")
          : null;
        if (cargoVendedor?.id_cargo !== undefined) {
          setIdCargoVendedor(String(cargoVendedor.id_cargo));
        }
      })
      .catch(() => {
        // Sem a lista de cargos o fallback cargo_perfil == "2" assume.
      });
  }, []);

  const normalizarTabelaRsi = (tabelaRsi: any[] = []) => {
    const anoBase = new Date().getFullYear();

    let acumulado = 0;
    return tabelaRsi.map((linha: any, index: number) => {
      const anoCalculado = Number(linha?.ano);
      const ano = Number.isFinite(anoCalculado)
        ? anoCalculado
        : anoBase + index;
      const fluxoCaixa = Number(linha?.fluxo_caixa) || 0;
      acumulado += fluxoCaixa;
      const status = acumulado >= 0 ? "Lucro" : "Investimento";

      return {
        ...linha,
        ano,
        status,
        preco_tarifa: linha?.preco_tarifa ?? linha?.tarifa_energia,
        energia:
          linha?.energia ?? linha?.geracao_anual ?? linha?.consumo_direto,
        tarifa_energia: linha?.tarifa_energia ?? linha?.tarifa_energia_evitada,
        tarifa_energia_evitada:
          linha?.tarifa_energia_evitada ?? linha?.tarifa_energia,
        receita_energia_evitada:
          linha?.receita_energia_evitada ?? linha?.receita_energia,
        economia_gerada: linha?.economia_gerada ?? linha?.receita_liquida,
        resultado_financeiro: linha?.resultado_financeiro ?? linha?.fluxo_caixa,
        cdb_130: linha?.cdb_130 ?? "",
        cdi: linha?.cdi ?? "",
        poupanca: linha?.poupanca ?? "",
      };
    });
  };
  // percentuais do usuário seguros (podem vir como string com vírgula)
  // Os valores de usuário já vêm no formato "8.00" ou "10.00", usar parseFloat simples
  const maxAcrescimoPercent =
    parseFloat(String(usuario?.max_acrescimo_usuario || "0")) || 0;
  const maxDescontoPercent =
    parseFloat(String(usuario?.max_desconto_usuario || "0")) || 0;

  // Limites do "Ajuste do Valor Final da Proposta", em ordem de prioridade:
  // 1) % Máximo de Desconto/Acréscimo do usuário, se configurado (sobre o
  //    preço normal COM comissão, política padrão) - segue o modo da loja
  //    (mexe no lucro se acaoValorFinalProposta_loja == "2", na comissão do
  //    vendedor se == "1").
  // 2) Sem % configurada: a comissão do vendedor NÃO é lucro da empresa, então
  //    mesmo em modo "Lucro da Empresa" faz sentido deixar o vendedor comer da
  //    própria comissão (faixa 0% a % máx da política) - desde que o usuário
  //    tenha permissão pra ver/usar esse ajuste (visualiza_max_desconto ou
  //    visualiza_max_acrescimo_proposta_usuario == "1"). Mesmo cálculo do modo
  //    "1", usado aqui como fallback.
  // 3) Sem % configurada E sem permissão nenhuma: não há como ajustar -
  //    mín=máx=preço normal (nenhum desconto/acréscimo possível).
  const modoVendedorFlexivel = String(acaoValorFinalProposta_loja) === "1";
  // "Calcular a Comissão por" = "Valor Base Empresa" ("1"): a comissão incide
  // sobre a base, então o Valor Final é consequência dela - o usuário não pode
  // digitar o Valor Final direto. Nesse modo o campo "Ajuste do Valor Final da
  // Proposta" fica OCULTO e o único caminho de ajuste é "Ajuste do Valor Base
  // Empresa"/"% Ajustes", que já respeitam Desconto Máximo/Acréscimo Máximo.
  // Só no modo "2" (Valor Final da Proposta) o campo aparece.
  // Quem decide se o campo aparece é a AÇÃO, não a base de cálculo da comissão:
  //
  //   Caso 1 ("2" + "1") - aparece, o ajuste sai da comissão.
  //   Caso 2 ("2" + "2") - aparece, o ajuste sai do lucro.
  //   Caso 3 ("1" + "1") - APARECE: mesmo calculando a comissão sobre o Valor
  //                        Base Empresa, é a COMISSÃO que é alterada aqui, então
  //                        o usuário precisa do campo. (Antes caía na mesma
  //                        regra do caso 4 e ficava oculto junto.)
  //   Caso 4 ("1" + "2")  - OCULTO: a comissão incide sobre a base e o ajuste
  //                        iria pro lucro, então o caminho é "% Ajustes"/"Ajuste
  //                        do Valor Base Empresa".
  const ocultarAjusteValorFinal =
    String(calcular_comissao_por_loja) !== "2" &&
    String(acaoValorFinalProposta_loja) === "2";
  // Regra suprema (vale em TODAS as configurações de loja): "% Ajustes" e
  // "Ajuste do Valor Base Empresa" mexem SOMENTE no Valor Base Empresa /
  // Lucro da Empresa - nunca em comissão de ninguém. O único campo que pode
  // mexer em comissão é o "Ajuste do Valor Final da Proposta".
  //
  // (Existia aqui um "Caso 1 da planilha" - calcular_comissao_por_loja "2" +
  // acaoValorFinalProposta_loja "1" - que fazia o "% Ajustes" virar espelho do
  // Valor Final e descontar da comissão do Vendedor, além de travar a base em
  // somente leitura. Quebrava três coisas: o piso do "% Ajustes" virava "onde a
  // comissão do Vendedor zera" em vez do % Máximo de Desconto do usuário (não
  // dava pra chegar nos 90%), o VALOR BASE REFERÊNCIA nunca atualizava - quem o
  // atualiza é o efeito de valorProposta, que esse desvio não disparava - e o
  // ajuste saía da comissão. Removido de propósito.)
  const temLimiteDescontoUsuario =
    maxDescontoPercent > 0 && precoVendaComComissaoOriginalRef.current !== null;
  const temLimiteAcrescimoUsuario =
    maxAcrescimoPercent > 0 &&
    precoVendaComComissaoOriginalRef.current !== null;
  const semNenhumaFolga = precoVendaComComissaoOriginalRef.current ?? 0;
  const usaVendedorParaAcrescimo =
    modoVendedorFlexivel ||
    (!temLimiteAcrescimoUsuario &&
      usuario?.visualiza_max_acrescimo_proposta_usuario == "1");
  // Desconto Máximo tem DUAS escalas diferentes, porque alimenta dois campos
  // de escalas diferentes:
  // - limiteMinimoAjusteBase (escala SEM comissão): usado no card "Desconto
  //   Máximo" e pra travar "Ajuste do Valor Base Empresa"/"% Ajustes" - com %
  //   configurada, escala o Valor Base Empresa ORIGINAL por esse % (mesmo
  //   valor que "Ajuste do Valor Base Empresa" mostra na menor % do range).
  // - limiteMinimoAjusteFinal (escala COM comissão): usado pra travar
  //   "Ajuste do Valor Final da Proposta" - base sempre travada no valor
  //   atual, só a comissão (Vendedor, ou todas em cascata) reduz até zerar.
  // Sem % configurada, os dois caem pro "TOTAL MÍNIMO PARA A VENDA" (já é
  // base + comissões não-vendedor, funciona nas duas pontas). Travados no
  // valor ORIGINAL (antes de qualquer ajuste) pelo motivo de sempre: valor
  // ao vivo deixaria o piso descer junto com cada desconto, permitindo
  // zerar a proposta em ciclos sucessivos.
  // Regra suprema: "Ajuste do Valor Base Empresa"/"% Ajustes" NUNCA mexe em
  // comissão de ninguém, de forma alguma - nem do Vendedor, nem de mais
  // ninguém. O piso desse campo nunca pode passar do ponto onde o Lucro da
  // Empresa zera (mesma fórmula do ajuste "Lucro da Empresa" abaixo,
  // invertida pra achar o valorProposta que zera novoLucroTotalPercent) -
  // antes, quando a % de Desconto Máximo configurada ia além desse ponto, o
  // restante saía da comissão do Vendedor (noPisoComVendedorDisponivel), o
  // que essa regra proíbe.
  const aMaisPParaLucroZero =
    (valor_total_produto_servico_extra || 0) +
    (valor_total_incluindo_porcentagem || 0);
  const limiteMinimoAjusteBaseLucroZero =
    aMaisPParaLucroZero > 0 && (encargos_total || 0) < 1
      ? aMaisPParaLucroZero / (1 - (encargos_total || 0))
      : 0;
  const limiteMinimoAjusteBase = Math.max(
    temLimiteDescontoUsuario
      ? baseReferencia100Porcento * (1 - maxDescontoPercent / 100)
      : (valorMinimoVendaOriginalRef.current ?? valor_minimo_venda),
    limiteMinimoAjusteBaseLucroZero
  );
  // Se o usuário tem permissão pra informar valor de comissão
  // (permite_informar_valor_comissao_usuario), ele pode zerar TODAS as
  // comissões (não só a do Vendedor) - nesse caso o piso absoluto é o
  // próprio Valor Base Empresa no piso (mesmo valor do card "Desconto
  // Máximo"), preço atual menos todas as comissões.
  const podeAlterarTodasComissoes =
    usuario?.permite_informar_valor_comissao_usuario == "1";
  // Regra suprema (espelhada da de "% Ajustes"): "Ajuste do Valor Final da
  // Proposta" NUNCA mexe em lucro_total_ajuste/base - só em comissão
  // (Vendedor, ou cascata se podeAlterarTodasComissoes). A base fica sempre
  // travada no valor ATUAL (live) - o piso é simplesmente onde a comissão
  // disponível pra reduzir chega em zero: base sozinha (todas as comissões
  // zeradas) com permissão pra mexer em todas, ou base + as outras comissões
  // (só a do Vendedor zerada) sem essa permissão.
  //
  // Base AO VIVO (preco_venda_final_sem_comissao) + os % de comissão
  // CONGELADOS da política. As duas metades importam:
  //
  // - % congelados: a comissão ao vivo já vem reduzida do próprio ajuste
  //   anterior. Com ela o piso descia a cada edição, e era isso que permitia o
  //   Valor Final cair em ciclos sucessivos (projeto 56).
  // - base ao vivo: este campo nunca mexe na base, então não há catraca; e o
  //   teto (tetoComComissoesCheias, logo abaixo) também é calculado sobre a
  //   base ao vivo. Com a base CONGELADA aqui, um "% Ajustes" de 90% derrubava
  //   o teto pra R$ 6.344,15 e deixava o piso parado em R$ 6.414,65 - piso
  //   acima do teto, e o clamp passava a devolver sempre o teto.
  const somaFracsComissaoPolitica =
    (cVendedorOriginalRef.current ?? c_vendedor ?? 0) +
    (cPreVendedorOriginalRef.current ?? c_pre_vendedor ?? 0) +
    (cGerenteOriginalRef.current ?? c_gerente ?? 0) +
    (cSupervisorOriginalRef.current ?? c_supervisor ?? 0) +
    (cIndicacaoOriginalRef.current ?? c_indicacao ?? 0);
  // Modo "2" (Calcular a Comissão por Valor Final) compõe comissão sobre
  // comissão - mesma fórmula usada em resolverComissoesEmCascata.
  const comissaoCompoe = String(calcular_comissao_por_loja) === "2";
  const baseViva = preco_venda_final_sem_comissao;
  // Sobe uma base qualquer pra escala COM comissão.
  function aplicarComissoes(base: number, fracs: number) {
    if (!(base > 0)) return 0;
    return comissaoCompoe
      ? base / (1 - Math.min(Math.max(fracs, 0), 0.9999))
      : base * (1 + Math.max(fracs, 0));
  }
  function aplicarComissoesSobreBaseViva(fracs: number) {
    return aplicarComissoes(baseViva, fracs);
  }

  // Caso 2 da planilha: "Quando Alterado o Valor Final na Proposta" = Altera o
  // Lucro da Empresa. Nesse modo o "Ajuste do Valor Final da Proposta" desconta
  // do LUCRO DA EMPRESA e NÃO recalcula os % de comissão - o que muda tanto o
  // recálculo (ver o efeito de [ajusteValorFinalProposta]) quanto os LIMITES do
  // campo: a faixa passa a ser a do lucro/base, não a da comissão disponível.
  const ajusteValorFinalIncideNoLucro =
    String(acaoValorFinalProposta_loja) === "2";
  // % de comissão AO VIVO (não os congelados da política): no Caso 2 eles ficam
  // parados, então são eles que convertem base <-> valor final.
  const somaFracsComissaoAtuais =
    (c_vendedor || 0) +
    (c_pre_vendedor || 0) +
    (c_gerente || 0) +
    (c_supervisor || 0) +
    (c_indicacao || 0);
  const baseNoTopoDoRangeAjustes =
    baseReferencia100Porcento * (1 + maxAcrescimoPercent / 100);

  // Só o Vendedor pode ser reduzido: piso = base + as OUTRAS comissões cheias.
  const fracsSemVendedor =
    somaFracsComissaoPolitica -
    (cVendedorOriginalRef.current ?? c_vendedor ?? 0);
  const limiteMinimoAjusteFinalVivo = ajusteValorFinalIncideNoLucro
    ? // Piso na escala do Valor Final = piso da BASE (onde o Lucro da Empresa
      // zera, ou o % Máximo de Desconto do usuário) com as comissões atuais.
      aplicarComissoes(limiteMinimoAjusteBase, somaFracsComissaoAtuais)
    : podeAlterarTodasComissoes
      ? baseViva
      : // Só o Vendedor pode ser reduzido: piso = base + as OUTRAS comissões.
        // Usa o valor_minimo_venda que o PRÓPRIO calcularPreco devolve, e não
        // uma reconstrução com os % congelados: é ele que entra na conta do
        // novoValorCVendedor mais abaixo, então piso e cálculo não podem
        // divergir (senão o Valor Final não fecha no valor digitado).
        //
        // Não há catraca: valor_minimo_venda depende só da base e das comissões
        // NÃO-vendedor, e este campo move apenas a do Vendedor.
        valor_minimo_venda > 0
        ? valor_minimo_venda
        : aplicarComissoesSobreBaseViva(fracsSemVendedor);
  const limiteMinimoAjusteFinal =
    limiteMinimoAjusteFinalVivo > 0
      ? limiteMinimoAjusteFinalVivo
      : podeAlterarTodasComissoes
        ? (precoVendaSemComissaoOriginalRef.current ??
          preco_venda_final_sem_comissao)
        : (valorMinimoVendaOriginalRef.current ?? valor_minimo_venda);
  // Piso EXIBIDO na variante (VENDEDOR) das mensagens. A planilha rotula a
  // linha como "Valor Mínimo(Zerando o % de Comissão do VENDEDOR)", então o
  // número tem que ser o piso de zerar SÓ a comissão do Vendedor.
  //
  // Não usa limiteMinimoAjusteFinal porque um vendedor com a permissão "9.
  // Informar Valor Comissão" tem piso técnico mais baixo (zera todas as
  // comissões) - aí o rótulo diria "do VENDEDOR" com o número de "TODAS", que
  // era outra forma de a mensagem não bater com a planilha.
  const limiteMinimoAjusteFinalVendedor = ajusteValorFinalIncideNoLucro
    ? limiteMinimoAjusteFinal
    : valor_minimo_venda > 0
      ? valor_minimo_venda
      : (valorMinimoVendaOriginalRef.current ??
        aplicarComissoesSobreBaseViva(fracsSemVendedor));
  // O card "Desconto Máximo" descreve o piso do campo que o usuário REALMENTE
  // usa: quem vê/usa "Ajuste do Valor Base Empresa" (visualiza_valor_base_
  // proposta_usuario) quer o piso na escala SEM comissão (bate com aquele
  // campo). Quem não vê esse campo (ex: vendedor, só mexe em "Ajuste do Valor
  // Final da Proposta") precisa do piso na escala COM comissão - mostrar o
  // valor sem comissão pra esse usuário não bate com nada que ele consegue
  // editar de verdade.
  const descontoMaximoExibido =
    usuario?.visualiza_valor_base_proposta_usuario == "1"
      ? limiteMinimoAjusteBase
      : limiteMinimoAjusteFinal;
  const limiteMaximoAjusteBruto = temLimiteAcrescimoUsuario
    ? precoVendaComComissaoOriginalRef.current! *
      (1 + maxAcrescimoPercent / 100)
    : usaVendedorParaAcrescimo
      ? (valorMaximoVendaOriginalRef.current ?? valor_maximo_venda)
      : semNenhumaFolga;
  // Nenhuma comissão passa da % configurada na política, e o "Ajuste do Valor
  // Final da Proposta" só mexe em comissão (nunca na base) - então o teto
  // REALMENTE alcançável é a BASE ATUAL com todas as comissões cheias.
  //
  // Tem que ser a base AO VIVO (preco_venda_final_sem_comissao), não o preço
  // original congelado: depois de um "% Ajustes" de 90% a base cai, e junto
  // com ela cai o valor que as comissões cheias produzem. Usar o original
  // fazia o card "ACRÉSCIMO MÁXIMO" prometer um valor inalcançável e deixava
  // o input "Ajuste do Valor Final da Proposta" aceitar um número que o
  // cálculo depois não entregava (input R$ 7.000,00 x card R$ 6.344,15).
  //
  // Não há risco de "catraca" aqui: por definição esse campo não mexe na base,
  // então preco_venda_final_sem_comissao não desce a cada edição dele - só
  // muda quando o Valor Base Empresa/"% Ajustes" muda.
  // Caso 2: o teto não é "comissão cheia" (a comissão não se move), é a BASE no
  // topo do range de "% Ajustes" com as comissões atuais.
  const tetoComComissoesCheias = ajusteValorFinalIncideNoLucro
    ? aplicarComissoes(baseNoTopoDoRangeAjustes, somaFracsComissaoAtuais)
    : aplicarComissoesSobreBaseViva(somaFracsComissaoPolitica);
  const limiteMaximoAjuste =
    tetoComComissoesCheias > 0
      ? Math.max(
          Math.min(limiteMaximoAjusteBruto, tetoComComissoesCheias),
          limiteMinimoAjusteFinal
        )
      : limiteMaximoAjusteBruto;

  // Item 07 - card "ACRÉSCIMO MÁXIMO" + linha "ACRÉSCIMO REFERÊNCIA".
  //
  // Estrutura idêntica ao card "Valor Base Empresa" / "Valor Base Referência":
  // o número GRANDE é o teto fixo da tela, e a linha de REFERÊNCIA é o valor
  // que os cálculos realmente usam (o que se move com o "% Ajustes").
  //
  // - acrescimoMaximoAbsoluto (grande) = base no topo do range de "% Ajustes"
  //   (valor_max_acrescimo_usuario, ex: 110%) já com todas as comissões cheias.
  //   Não se move: é o máximo que a tela permite em qualquer situação.
  // - limiteMaximoAjuste (referência) = teto EFETIVO, sobre a base ATUAL. É este
  //   que trava o "Ajuste do Valor Final da Proposta" e entra nos cálculos.
  const acrescimoMaximoAbsoluto = aplicarComissoes(
    baseNoTopoDoRangeAjustes,
    ajusteValorFinalIncideNoLucro
      ? somaFracsComissaoAtuais
      : somaFracsComissaoPolitica
  );
  // Com "% Ajustes" no topo do range os dois coincidem e a linha viraria ruído.
  const mostrarAcrescimoReferencia =
    acrescimoMaximoAbsoluto > 0 &&
    acrescimoMaximoAbsoluto - limiteMaximoAjuste > 0.01;
  // Fallback: sem o absoluto calculado (preço ainda zerado na primeira
  // renderização), o card mostra o efetivo em vez de R$ 0,00.
  const acrescimoMaximoExibido =
    acrescimoMaximoAbsoluto > 0 ? acrescimoMaximoAbsoluto : limiteMaximoAjuste;

  // // Função para calcular e atualizar a comissão do vendedor
  // const calcularComissaoVendedor = (valorComissao: number) => {
  //   const valorAplicado = preco_venda_final_sem_comissao.toFixed(2);
  //   const divisionPercent = valorComissao / Number(valorAplicado);
  //   const valorAplicadoComissao = Number(valorAplicado) * divisionPercent;

  //   const valorPreVendedor = preco_venda_final_sem_comissao * c_pre_vendedor;
  //   const valorGerente = preco_venda_final_sem_comissao * c_gerente;
  //   const valorSupervisor = preco_venda_final_sem_comissao * c_supervisor;
  //   const valorIndi = preco_venda_final_sem_comissao * c_indicacao;

  //   const somaAplicacaoComissao =
  //     valorPreVendedor +
  //     c_indicacao_bruto +
  //     valorGerente +
  //     valorSupervisor +
  //     valorIndi +
  //     valorAplicadoComissao;

  //   const novoPrecoVenda =
  //     preco_venda_final_sem_comissao + somaAplicacaoComissao;

  //   // Atualiza o estado
  //   setResultadoPrecificacao((prev: any) => ({
  //     ...prev,
  //     preco_venda: novoPrecoVenda,
  //     valor_comissao: somaAplicacaoComissao,
  //     c_vendedor: divisionPercent,
  //   }));

  //   setValorProposta(novoPrecoVenda);

  //   setValorAplicacaoComissao({
  //     valor: somaAplicacaoComissao,
  //     comissaoValor: valorAplicadoComissao,
  //     percent: divisionPercent,
  //   });

  //   return novoPrecoVenda;
  // };

  // Função para validar se o valor está dentro do limite de acréscimo
  const validarAcrescimoMaximo = (
    valorComissao: number,
    precoVendaAtual: number
  ) => {
    const maxAcres =
      form.control._formValues?.resultadoPrecificacao?.preco_venda *
      (1 + (maxAcrescimoPercent || 0) / 100);

    const validateComissao = Number(precoVendaAtual) + Number(valorComissao);

    if (Number(validateComissao) > maxAcres) {
      const min = Math.abs(precoVendaAtual - maxAcres);
      return min;
    }
    return valorComissao;
  };

  // Função para calcular o valor total atual (preço sem comissão do vendedor original)
  const calcularValorTotalAtual = () => {
    return +preco_venda - preco_venda_sem_comissao * c_vendedor;
  };

  // async function submitCustosExtras() {
  //   const { parametrosPrecificacao } = form.control._formValues;
  //   return calcularPreco({
  //     ...parametrosPrecificacao,
  //   })
  //     .then((resPrecificacao) => {
  //       form.setValue("resultadoPrecificacao", resPrecificacao);
  //       setResultadoPrecificacao(resPrecificacao);
  //       blockNextStep(false);
  //     })
  //     .catch(() => {
  //       blockNextStep(true);
  //     });
  // }
  let loja = form.control._formValues?.loja;

  useEffect(() => {
    // if (form.control._formValues?.valorNovo_comissaoVendedor) {
    //   const valorComissao = Number(
    //     form.control._formValues?.valorNovo_comissaoVendedor
    //   );
    //   calcularComissaoVendedor(valorComissao);
    // }

    // O `useState(resultadoPrecificacao)` acima é semeado com o que sobrou de
    // uma visita ANTERIOR a essa aba (form.control._formValues). Se o
    // usuário voltou em "Componentes"/"Custos Extras" e mudou algo, esse
    // valor semeado já está desatualizado - mas os refs congelados
    // (precoVendaSemComissaoOriginalRef e companhia) capturam ele mesmo
    // assim no primeiro render, ANTES do recálculo abaixo terminar (é
    // assíncrono). Resultado: os campos "ao vivo" atualizam pro valor novo,
    // mas tudo que depende dos refs fica preso no valor velho - a tela toda
    // fica contraditória. Reseta os refs aqui, toda vez que a aba (re)monta,
    // pra eles recapturarem do zero assim que o recálculo (se houver)
    // terminar.
    precoVendaSemComissaoOriginalRef.current = null;
    precoVendaComComissaoOriginalRef.current = null;
    valorMinimoVendaOriginalRef.current = null;
    valorMaximoVendaOriginalRef.current = null;
    // Mesma corrida de render acima vale pros % de comissão/lucro
    // congelados - sem resetar aqui também, eles ficam presos na % da
    // visita anterior enquanto base/preço já são os novos, misturando
    // escala nova com comissão velha na cascata de redução.
    cVendedorOriginalRef.current = null;
    cPreVendedorOriginalRef.current = null;
    cGerenteOriginalRef.current = null;
    cSupervisorOriginalRef.current = null;
    cIndicacaoOriginalRef.current = null;
    lucroTotalOriginalRef.current = null;

    blockNextStep(true);
    const qtdModulos =
      (dadosCard?.tipoNegocio_coleta === "3"
        ? form?.control?._formValues?.quantidade_modulos_ampliacao
        : form?.control?._formValues?.totalModulos) || "0";

    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 novosParametrosPrecificacao: any = {
      origem_contato: dadosCliente?.origem_cliente,
      tipo_negocio: dadosCard?.tipoNegocio_coleta,
      tipo_telhado:
        form?.control?._formValues?.telhado?.value ||
        dadosAmpliacao?.tipoTelhado_ampliacao ||
        lastProposalInfo?.telhado_proposta,
      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,
      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_supervisor_loja: dadosCard?.comissao_supervisor_loja,
      comissao_indicacao_loja: dadosCard?.comissao_indicacao_loja,
      custos_extras: form?.control?._formValues?.custos_extras || [],
      potencia_inversor: Number(potenciaInversor),
      codIndicador_coleta: dadosCard.codIndicador_coleta,
      ...(["2", "4"].includes(dadosCard.tipoNegocio_coleta)
        ? {
            valor_servico: FormatFields.desformatarNumeros(
              form?.control?._formValues?.valor_proposta
            ),
          }
        : {}),
    };

    const parametrosPrecificacao =
      form.control._formValues?.parametrosPrecificacao || {};
    // Aguarda a política de preço mais recente antes de calcular o preço - evita
    // que calcularPreco rode com a politicaPreco desatualizada (ex: config de
    // imposto de uma política antiga) enquanto obterCustosExtras ainda resolve.
    let politicaPrecoPromise: Promise<any> = Promise.resolve(
      form.control._formValues?.politicaPreco
    );
    // Kit/potência/módulos mudaram - qualquer "preco_venda_final_sem_comissao"
    // (override ABSOLUTO em R$, salvo em parametrosPrecificacao por uma edição
    // manual anterior de "Ajuste do Valor Base Empresa"/Lucro da Empresa) foi
    // calculado em cima do kit VELHO. Reenviar esse R$ fixo pro calcularPreco
    // agora, com um kit de custo bem diferente, trava a base no valor antigo
    // (o "Valor Base Referência" não acompanha o novo Custo do Kit e aparece
    // como um desconto/acréscimo gigante e sem sentido). Só limpa quando o
    // kit muda de verdade - não em toda visita (senão perde ajuste manual
    // legítimo do usuário na mesma sessão/kit).
    const baseKitAlterou = [
      "valor_kit",
      "potencia_sistema",
      "qtd_modulos",
      "potencia_modulo",
      "potencia_inversor",
      "distribuidor",
    ].some(
      (chave) =>
        parametrosPrecificacao[chave] != novosParametrosPrecificacao[chave]
    );
    // Detecta se houve alteração nos custos extras em relação aos parâmetros anteriores
    const custosExtrasAlteraram = Object.keys(novosParametrosPrecificacao).some(
      (chaveParametro) =>
        chaveParametro == "custos_extras"
          ? novosParametrosPrecificacao[chaveParametro].some(
              (custoExtra: any, indexCustoExtra: number) =>
                Object.keys(parametrosPrecificacao).includes(chaveParametro)
                  ? custoExtra.value !=
                      parametrosPrecificacao[chaveParametro][indexCustoExtra]
                        ?.value ||
                    custoExtra.isChecked !=
                      parametrosPrecificacao[chaveParametro][indexCustoExtra]
                        ?.isChecked ||
                    custoExtra.id_custo_extra !=
                      parametrosPrecificacao[chaveParametro][indexCustoExtra]
                        ?.id_custo_extra
                  : true
            )
          : false
    );
    if (
      Object.keys(novosParametrosPrecificacao).some(
        (chaveParametro) =>
          parametrosPrecificacao[chaveParametro] !=
          novosParametrosPrecificacao[chaveParametro]
      )
    ) {
      function setarPoliticaPrecoProposta(politica_preco: any) {
        form.setValue("politicaPreco", politica_preco);
      }
      politicaPrecoPromise = obterCustosExtras(
        {
          ...{
            ...novosParametrosPrecificacao,
            responsaveis: dadosCard?.responsaveis,
          },
          loja,
        },
        setarPoliticaPrecoProposta
      )
        .then(() => form.control._formValues?.politicaPreco)
        .catch(() => form.control._formValues?.politicaPreco);
    }

    if (
      dadosCard?.tipoNegocio_coleta === "3" ||
      Object.keys(resultadoPrecificacao).every(
        (chavePrecificacao) =>
          resultadoPrecificacao[chavePrecificacao] ==
          emptyPrecificacao[chavePrecificacao]
      ) ||
      Object.keys(novosParametrosPrecificacao).some((chaveParametro) =>
        chaveParametro == "custos_extras"
          ? novosParametrosPrecificacao[chaveParametro].some(
              (custoExtra: any, indexCustoExtra: number) =>
                Object.keys(parametrosPrecificacao).includes(chaveParametro)
                  ? custoExtra.value !=
                      parametrosPrecificacao[chaveParametro][indexCustoExtra]
                        ?.value ||
                    custoExtra.isChecked !=
                      parametrosPrecificacao[chaveParametro][indexCustoExtra]
                        ?.isChecked ||
                    custoExtra.id_custo_extra !=
                      parametrosPrecificacao[chaveParametro][indexCustoExtra]
                        ?.id_custo_extra
                  : true
            )
          : parametrosPrecificacao[chaveParametro] !=
            novosParametrosPrecificacao[chaveParametro]
      )
    ) {
      politicaPrecoPromise
        .then((politicaPrecoAtual) =>
          calcularPreco({
            ...parametrosPrecificacao,
            ...novosParametrosPrecificacao,
            // Kit mudou - descarta override absoluto em R$ da visita
            // anterior (ver comentário de baseKitAlterou acima). Sem isso o
            // preço final fica pinado no valor antigo, gerando um
            // desconto/acréscimo gigante e falso contra o kit novo.
            ...(baseKitAlterou
              ? {
                  preco_venda_final_sem_comissao: undefined,
                  valor_c_vendedor: undefined,
                }
              : {}),
            loja: form.control._formValues?.loja || loja,
            politicaPreco: politicaPrecoAtual,
            responsaveis: dadosCard?.responsaveis,
          })
        )
        .then((dadosPreco) => {
          // Se já existe um ajuste de proposta salvo no formulário ou no estado,
          // preservar esse valor sobre o resultado retornado pelo cálculo.
          const valorFinalSalvo = form.getValues("valorFinalProposta");
          let valorFinalSalvoNumerico: number | null = null;
          if (valorFinalSalvo && valorFinalSalvo !== "0,00") {
            valorFinalSalvoNumerico =
              +FormatFields.desformatarNumeros(valorFinalSalvo);
          } else if (
            typeof valorProposta === "number" &&
            !isNaN(valorProposta)
          ) {
            valorFinalSalvoNumerico = valorProposta;
          }
          form.setValue("parametrosPrecificacao", {
            ...parametrosPrecificacao,
            ...novosParametrosPrecificacao,
            responsaveis: dadosCard?.responsaveis,
          });
          const tabelaRsiBase =
            form.control._formValues?.tabela_rsi ||
            form.control._formValues?.rsiProposta?.tabela_rsi ||
            [];
          const tabelaRsiFormatada = normalizarTabelaRsi(tabelaRsiBase);
          const dadosPrecoComRsi = {
            ...dadosPreco,
            tabela_rsi: tabelaRsiFormatada,
          };

          setResultadoPrecificacao(dadosPrecoComRsi);
          form.setValue("resultadoPrecificacao", dadosPrecoComRsi);
          form.setValue("tabela_rsi", tabelaRsiFormatada);
          // form.setValue(
          //   "valorFinalProposta",
          //   formatarNumero(dadosPreco.preco_venda)
          // );

          // "Ajuste do Valor Final da Proposta" (ajusteValorFinalProposta)
          // foi semeado no mount com o que sobrou de uma visita ANTERIOR a
          // essa aba (form.control._formValues). Se o usuário editou
          // Componentes/Kits (não só "custos_extras" - custosExtrasAlteraram
          // abaixo só olha esse campo específico) e voltou, esse valor
          // semeado é de uma escala completamente diferente da recalculada
          // agora - sincroniza com o preço de fato calculado, senão os
          // efeitos de valorProposta/ajusteValorFinalProposta acabam
          // misturando base nova com alvo velho e todo o resto (comissão do
          // vendedor, % Ajustes, Desconto/Acréscimo Máximo) sai furado.
          if (
            Number.isFinite(dadosPreco.preco_venda) &&
            Math.abs(dadosPreco.preco_venda - ajusteValorFinalProposta) > 0.01
          ) {
            setAjusteValorFinalProposta(dadosPreco.preco_venda);
            form.setValue(
              "ajusteValorFinalProposta_formatado",
              FormatFields.formatarNumero(dadosPreco.preco_venda)
            );
          }

          // Resetar `.current = null` no topo do efeito (mount) não é
          // suficiente sozinho: entre esse reset e a resposta assíncrona
          // aqui chegar, pode rolar um re-render "no meio do caminho" (ex:
          // isLoaded virando true por outro motivo) com resultadoPrecificacao
          // AINDA desatualizado - a checagem "freeze on first valid value" do
          // corpo do render vê o ref null e recaptura o valor velho de novo,
          // travando ele permanentemente antes da resposta certa chegar.
          // Setar direto aqui, com o dado que acabou de vir do cálculo,
          // garante o valor certo independente de qualquer corrida de render.
          if (Number.isFinite(dadosPreco.preco_venda_sem_comissao)) {
            precoVendaSemComissaoOriginalRef.current =
              dadosPreco.preco_venda_sem_comissao;
          }
          if (Number.isFinite(dadosPreco.preco_venda)) {
            precoVendaComComissaoOriginalRef.current = dadosPreco.preco_venda;
          }
          if (Number.isFinite(dadosPreco.valor_minimo_venda)) {
            valorMinimoVendaOriginalRef.current = dadosPreco.valor_minimo_venda;
          }
          if (Number.isFinite(dadosPreco.valor_maximo_venda)) {
            valorMaximoVendaOriginalRef.current = dadosPreco.valor_maximo_venda;
          }
          // Mesmo motivo do bloco acima: seta direto do dado que acabou de
          // vir, senão a % congelada corre risco de travar na visita
          // anterior antes da resposta certa chegar.
          if (
            Number.isFinite(dadosPreco.c_vendedor) &&
            dadosPreco.c_vendedor > 0
          ) {
            cVendedorOriginalRef.current = dadosPreco.c_vendedor;
          }
          if (
            Number.isFinite(dadosPreco.c_pre_vendedor) &&
            dadosPreco.c_pre_vendedor > 0
          ) {
            cPreVendedorOriginalRef.current = dadosPreco.c_pre_vendedor;
          }
          if (
            Number.isFinite(dadosPreco.c_gerente) &&
            dadosPreco.c_gerente > 0
          ) {
            cGerenteOriginalRef.current = dadosPreco.c_gerente;
          }
          if (
            Number.isFinite(dadosPreco.c_supervisor) &&
            dadosPreco.c_supervisor > 0
          ) {
            cSupervisorOriginalRef.current = dadosPreco.c_supervisor;
          }
          if (
            Number.isFinite(dadosPreco.c_indicacao) &&
            dadosPreco.c_indicacao > 0
          ) {
            cIndicacaoOriginalRef.current = dadosPreco.c_indicacao;
          }
          if (
            Number.isFinite(dadosPreco.lucro_total) &&
            dadosPreco.lucro_total !== 0
          ) {
            lucroTotalOriginalRef.current = dadosPreco.lucro_total;
          }

          // blockNextStep(false);
          setConfirmaAvancoComissao(
            [
              dadosPreco.c_vendedor,
              dadosPreco.c_pre_vendedor,
              dadosPreco.c_gerente,
              dadosPreco.c_supervisor,
              dadosPreco.c_indicacao,
              dadosPreco.c_indicacao_bruto,
              dadosPreco.valor_comissao,
            ].some((val) => val != 0)
          );

          // Estes dois limites são comparados com `valorProposta`, que está na
          // escala SEM comissão (é o "Ajuste do Valor Base Empresa"). Antes
          // saíam de dadosPreco.preco_venda, que é a escala COM comissão - a
          // comparação misturava as duas escalas e disparava o reset abaixo
          // ("volta pra 100%") sem o valor estar fora de faixa nenhuma. Esse
          // reset mexia em valorProposta, o efeito dele recalculava tudo e
          // arrastava o "Ajuste do Valor Final da Proposta" pra um valor que o
          // usuário não pediu - o que aparecia como "avancei e virou o mínimo".
          const baseParaLimitesVisita =
            dadosPreco.preco_venda_final_sem_comissao ||
            dadosPreco.preco_venda_sem_comissao ||
            dadosPreco.preco_venda;
          const novo_valor_max_desconto_usuario =
            baseParaLimitesVisita * (1 - maxDescontoPercent / 100);
          const novo_valor_max_acrescimo_usuario =
            baseParaLimitesVisita * (1 + maxAcrescimoPercent / 100);
          if (custosExtrasAlteraram || baseKitAlterou) {
            // Resetar para 100% quando custos extras OU o kit (valor_kit/
            // potência/módulos) forem alterados - mesmo motivo do override
            // limpo acima, senão valorProposta/% Ajustes ficam com a conta
            // velha em cima do kit novo.
            form.setValue("porcentagemValorFinal", formatarNumero(100.0));
            setValorProposta(dadosPreco.preco_venda_sem_comissao);
            form.setValue(
              "valorFinalProposta",
              formatarNumero(dadosPreco.preco_venda_sem_comissao)
            );
          } else if (
            !form.control._formValues?.valorFinalProposta ||
            form.control._formValues?.valorFinalProposta == "0,00" ||
            Number(valorProposta?.toFixed(2)) <
              Number(novo_valor_max_desconto_usuario.toFixed(2)) ||
            Number(valorProposta?.toFixed(2)) >
              Number(novo_valor_max_acrescimo_usuario.toFixed(2))
          ) {
            form.setValue("porcentagemValorFinal", formatarNumero(100.0));
            setValorProposta(dadosPreco.preco_venda_final_sem_comissao);
          } else {
            recalcularValorPorcentagemProposta();
          }
          setIsLoaded(true);
        })
        .catch(() => {
          setIsLoaded(true);
        });
    } else {
      setIsLoaded(true);
      console.log(resultadoPrecificacao, "resultadoPrecificacao");
      setConfirmaAvancoComissao(
        [
          resultadoPrecificacao.c_vendedor,
          resultadoPrecificacao.c_pre_vendedor,
          resultadoPrecificacao.c_gerente,
          resultadoPrecificacao.c_supervisor,
          resultadoPrecificacao.c_indicacao,
          resultadoPrecificacao.c_indicacao_bruto,
          resultadoPrecificacao.valor_comissao,
        ].some((val) => val != 0)
      );
      if (
        [
          c_vendedor,
          c_pre_vendedor,
          c_gerente,
          c_supervisor,
          c_indicacao,
          c_indicacao_bruto,
          valor_comissao,
        ].every((val) => val == 0)
      ) {
        toast.error(
          <div>
            <div>
              Não foi encontrado uma política de comissão com os parâmetos
              informados:
            </div>
            <div className="text-error italic">
              <div>Valor da Proposta</div>
              <div>Vendedor do Negócio</div>
              <div>Origem do Contato</div>
              <div>Loja</div>
              <div>Tipo do negócio</div>
            </div>
            <div>O resultado não considerará VALORES DE COMISSÕES</div>
          </div>
        );
      }
    }
  }, []);

  // const [valorAplicacaoComissao, setValorAplicacaoComissao] = useState<any>();
  // const [valorComissaoCalculado, setValorComissaoCalculado] =
  //   useState<number>(0);
  const [ajusteValorFinalProposta, setAjusteValorFinalProposta] = useState<any>(
    form?.control?._formValues?.ajusteValorFinalProposta || 0
  );
  // Derivado (não state manual) - sempre fresco, independente de qual dos dois
  // campos de ajuste (Base Empresa ou Valor Final) foi o último a disparar o
  // recálculo. Guardar isso como state exigia recomputar em todo efeito que
  // pudesse mudar qualquer uma dessas 4 variáveis, e ficava stale quando só um
  // dos dois efeitos rodava.
  const valorAjusteTotal = useMemo(() => {
    // Referência = PREÇO PADRÃO da política (preco_venda com as comissões
    // cheias, congelado na primeira carga da aba), o MESMO ponto usado pela
    // mensagem "Desconto/Acréscimo" embaixo do campo "Ajuste do Valor Final da
    // Proposta".
    //
    // Antes a referência era valor_maximo_venda (teto máximo de comissão do
    // Vendedor), que fica acima do preço padrão - então a tela mostrava dois
    // descontos diferentes para o mesmo ajuste (campo -R$ 300,00 x card
    // -R$ 320,73, sendo os R$ 20,73 só a distância entre teto e preço padrão).
    const pontoNormalComissao = precoVendaComComissaoOriginalRef.current;
    const baseOriginal =
      precoVendaSemComissaoOriginalRef.current ?? preco_venda_sem_comissao;
    if (
      !isLoaded ||
      !Number.isFinite(ajusteValorFinalProposta) ||
      !Number.isFinite(pontoNormalComissao as number) ||
      !Number.isFinite(preco_venda_sem_comissao) ||
      !Number.isFinite(baseOriginal)
    ) {
      return 0;
    }
    // Desconta o ajuste da BASE (mesma conta do card "Ajuste Aplicado (Valor
    // Base)"): quando a base se move, o preço padrão se move junto, e esse
    // efeito já é mostrado naquele card. Aqui sobra só o que o "Ajuste do Valor
    // Final da Proposta" tirou/pôs na comissão. Base SEM ALTERAÇÃO: o termo é 0
    // e o card bate exatamente com a mensagem do campo.
    const ajusteDaBase =
      Number(preco_venda_sem_comissao.toFixed(2)) -
      Number(baseOriginal.toFixed(2));
    const ajuste = Number(
      (
        Number(ajusteValorFinalProposta.toFixed(2)) -
        Number((pontoNormalComissao as number).toFixed(2)) -
        ajusteDaBase
      ).toFixed(2)
    );
    // Resíduo de arredondamento não é ajuste: os 4 termos vêm arredondados a 2
    // casas cada, e o cálculo fecha o Valor Final somando comissão por comissão
    // já arredondada, então sobra 1-2 centavos sem ninguém ter editado nada -
    // era isso que acendia o card "Desconto (Comissão Vendedor) -R$ 0,02" e
    // gravava valorDesconto de centavos na proposta.
    return Math.abs(ajuste) <= 0.02 ? 0 : ajuste;
  }, [isLoaded, ajusteValorFinalProposta, preco_venda, preco_venda_sem_comissao]);

  // "Ajuste Aplicado (Valor Base)" - diferença entre o Valor Base Empresa
  // ajustado manualmente (valorProposta) e o preço puro calculado pela
  // política (preco_venda_sem_comissao). Mesma fórmula usada no card "Ajuste
  // Aplicado (Valor Base)" logo abaixo - centralizado aqui pra alimentar
  // também o Quadro de Custos e Lucro sem duplicar a conta.
  // Vale em QUALQUER configuração de loja: o ajuste da base sempre entra pelo
  // lucro_total_ajuste (naoAjustarVendedor), então quem se move é a base
  // natural AO VIVO (preco_venda_sem_comissao) contra a original congelada.
  // Comparar valorProposta contra preco_venda_sem_comissao dava ~0 sempre
  // ("SEM ALT.") depois que o cálculo voltava, porque os dois convergem.
  const ajusteValorBase = useMemo(() => {
    const original =
      precoVendaSemComissaoOriginalRef.current ?? preco_venda_sem_comissao;
    if (
      !Number.isFinite(preco_venda_sem_comissao) ||
      !Number.isFinite(original)
    ) {
      return 0;
    }
    return Number(
      (
        Number(preco_venda_sem_comissao.toFixed(2)) -
        Number(original.toFixed(2))
      ).toFixed(2)
    );
  }, [valorProposta, preco_venda_sem_comissao]);

  // Rede de segurança contra qualquer race das outras sincronizações acima:
  // sem edição REAL do usuário nesse campo (usuarioEditouAjusteRef), "Ajuste
  // do Valor Final da Proposta" tem que bater exatamente com o card "Valor
  // Final da Proposta" (preco_venda) - mesma origem, por definição. Ancorado
  // direto em preco_venda (não em ajusteValorFinalProposta) pra não competir
  // com o efeito de clamp abaixo nem entrar em loop.
  useEffect(() => {
    if (
      isLoaded &&
      !usuarioEditouAjusteRef.current &&
      Number.isFinite(preco_venda) &&
      Math.abs(preco_venda - ajusteValorFinalProposta) > 0.01
    ) {
      setAjusteValorFinalProposta(preco_venda);
      form.setValue(
        "ajusteValorFinalProposta_formatado",
        FormatFields.formatarNumero(preco_venda)
      );
    }
  }, [isLoaded, preco_venda]);

  useEffect(() => {
    // Campo oculto (comissão calculada pelo Valor Base Empresa): não existe
    // ajuste manual do Valor Final pra clampar/validar, e o efeito de sync
    // acima já mantém ajusteValorFinalProposta == preco_venda. Rodar as
    // fórmulas de comissão aqui nesse modo só mexeria em comissão sem o
    // usuário ter editado nada.
    if (ocultarAjusteValorFinal) {
      form.clearErrors("ajusteValorFinalProposta_formatado");
      return;
    }
    if (isLoaded) {
      // Limites já resolvidos no nível do componente (compartilhados com o
      // texto do "i" - ver limiteMinimoAjusteFinal/limiteMaximoAjuste acima).
      // Esse campo é escala COM comissão, por isso usa a versão "Final".
      const limiteMinimo = limiteMinimoAjusteFinal;
      const limiteMaximo = limiteMaximoAjuste;

      const novoAjusteValorFinalProposta =
        ajusteValorFinalProposta - limiteMinimo < 0
          ? limiteMinimo
          : ajusteValorFinalProposta > limiteMaximo
            ? limiteMaximo
            : ajusteValorFinalProposta;

      form.setValue(
        "ajusteValorFinalProposta",
        +FormatFields.desformatarNumeros(novoAjusteValorFinalProposta)
      );
      form.setValue(
        "ajusteValorFinalProposta_formatado",
        FormatFields.formatarNumero(novoAjusteValorFinalProposta)
      );

      // Mensagem de desconto/acréscimo compara contra o ponto "normal" (0% de
      // ajuste, preço padrão da política) - não contra o teto máximo. Antes
      // só ficava sem mensagem quando o valor estava exatamente no MÁXIMO,
      // então qualquer carregamento inicial (que não fica no teto) já
      // aparecia com "Desconto" sem o usuário ter mexido em nada.
      const pontoNormal =
        precoVendaComComissaoOriginalRef.current ?? limiteMaximo;
      const diferencaDoNormal = novoAjusteValorFinalProposta - pontoNormal;
      // Tolerância de centavos: o cálculo fecha o Valor Final arredondando
      // comissão por comissão (round2 de cada cargo antes de somar), então
      // preco_venda pode oscilar 1-2 centavos entre recálculos em relação ao
      // pontoNormal congelado na primeira carga. Isso não é desconto do
      // usuário - com o corte em 0,01 aparecia "Desconto: R$ 0,01 -0,00%" logo
      // ao abrir a aba, sem ninguém ter editado nada (perfil Vendedor).
      const TOLERANCIA_CENTAVOS_AJUSTE = 0.02;
      if (Math.abs(diferencaDoNormal) > TOLERANCIA_CENTAVOS_AJUSTE) {
        form.setError("ajusteValorFinalProposta_formatado" as never, {
          type: "manual",
          message:
            diferencaDoNormal < 0
              ? `Desconto: ${formatarValor(-diferencaDoNormal)} -${formatarNumero((-diferencaDoNormal / pontoNormal) * 100)}%`
              : `Acréscimo: ${formatarValor(diferencaDoNormal)} +${formatarNumero((diferencaDoNormal / pontoNormal) * 100)}%`,
        });
      } else {
        form.clearErrors("ajusteValorFinalProposta_formatado");
        // Dentro da tolerância o campo mostra o mesmo valor do card "VALOR FINAL
        // DA PROPOSTA" - senão fica o desencontro de 1 centavo visível na tela
        // (card R$ 6.991,97 x campo R$ 6.991,96).
        if (diferencaDoNormal !== 0) {
          form.setValue(
            "ajusteValorFinalProposta_formatado",
            FormatFields.formatarNumero(pontoNormal)
          );
        }
      }

      // Voltou pro valor "normal" (o preço com comissão de política, travado
      // em precoVendaComComissaoOriginalRef desde a primeira carga desta
      // visita à aba) - restaura tudo pro estado ORIGINAL da política, em vez
      // de deixar cair nas fórmulas genéricas abaixo. Essas fórmulas operam
      // sobre preco_venda_final_sem_comissao/lucro_total AO VIVO, que um
      // desconto/acréscimo anterior pode ter deixado "à deriva" (ex: modo
      // "Lucro da Empresa" muda lucro_total_ajuste, e atualizarResultadoPrecificacao
      // reenvia esse valor à deriva em toda chamada seguinte que não o
      // sobrescreva explicitamente) - sem esse reset explícito, voltar o
      // valor final pro original não reestabelece os % de comissão originais.
      if (
        usuarioEditouAjusteRef.current &&
        Math.abs(diferencaDoNormal) <= 0.01 &&
        precoVendaSemComissaoOriginalRef.current !== null
      ) {
        atualizarResultadoPrecificacao({
          preco_venda_final_sem_comissao:
            precoVendaSemComissaoOriginalRef.current,
          lucro_total_ajuste:
            lucroTotalOriginalRef.current !== null
              ? Number((lucroTotalOriginalRef.current * 100).toFixed(6))
              : undefined,
          c_vendedor_ajuste: Number(
            ((cVendedorOriginalRef.current ?? 0) * 100).toFixed(6)
          ),
          c_pre_vendedor_ajuste: Number(
            ((cPreVendedorOriginalRef.current ?? 0) * 100).toFixed(6)
          ),
          c_gerente_ajuste: Number(
            ((cGerenteOriginalRef.current ?? 0) * 100).toFixed(6)
          ),
          c_supervisor_ajuste: Number(
            ((cSupervisorOriginalRef.current ?? 0) * 100).toFixed(6)
          ),
          c_indicacao_ajuste: Number(
            ((cIndicacaoOriginalRef.current ?? 0) * 100).toFixed(6)
          ),
        })?.then((dadosPreco) => {
          if (!dadosPreco) return;
          const baseReal = dadosPreco.preco_venda_final_sem_comissao;
          if (Math.abs(baseReal - valorBaseReferencia) > 0.01) {
            setValorBaseReferencia(baseReal);
          }
          form.setValue("valorFinalProposta", formatarNumero(baseReal));
          form.setValue("porcentagemValorFinal", formatarNumero(100));
          form.setValue(
            "ajusteValorFinalProposta_formatado",
            FormatFields.formatarNumero(dadosPreco.preco_venda)
          );
        });
        return;
      }

      // Só avisa quando o clamp aconteceu por causa de uma edição real do
      // usuário nesse campo - o valor inicial (carregado da política, sem
      // ninguém ter mexido) pode coincidir com o limite (ex: comissão padrão
      // já é a máxima permitida) e não é "ajuste" nenhum.
      if (
        usuarioEditouAjusteRef.current &&
        novoAjusteValorFinalProposta == limiteMinimo
      ) {
        toast.info(
          temLimiteDescontoUsuario
            ? "Ajuste do Valor Final da Proposta ajustado para o mínimo possível de acordo com o desconto máximo permitido"
            : "Ajuste do Valor Final da Proposta ajustado para o mínimo possível (Total Mínimo para a Venda)"
        );
      } else if (
        usuarioEditouAjusteRef.current &&
        novoAjusteValorFinalProposta == limiteMaximo
      ) {
        toast.info(
          temLimiteAcrescimoUsuario
            ? "Ajuste do Valor Final da Proposta ajustado para o máximo possível de acordo com o acréscimo máximo permitido"
            : usaVendedorParaAcrescimo
              ? "Ajuste do Valor Final da Proposta ajustado para o máximo possível de acordo com a comissão do Vendedor"
              : "Ajuste do Valor Final da Proposta não pode ser alterado (sem permissão configurada)"
        );
      }

      // Caso 2 da planilha ("Quando Alterado o Valor Final na Proposta" =
      // Altera o Lucro da Empresa): o ajuste sai do LUCRO DA EMPRESA e os % de
      // comissão NÃO são recalculados.
      //
      // Caminho inverso do efeito de [valorProposta]: lá o alvo é uma BASE e o
      // lucro é derivado dela; aqui o alvo é um VALOR FINAL, então primeiro
      // desconta as comissões pra achar a base que produz esse final, e só
      // então converte essa base em % de lucro.
      //
      // Os % de comissão vão por pass-through (nenhum c_*_ajuste é enviado, e
      // NÃO se usa naoAjustarVendedor - que zeraria o override e faria a
      // comissão do Vendedor voltar pro padrão da política). Como os % ficam
      // parados, os valores em R$ acompanham a nova base - exatamente o
      // "recalculado os valores de comissões com os % configurados nos
      // parametros, SEM ALTERAR OS % DE COMISSÕES" da planilha.
      if (ajusteValorFinalIncideNoLucro) {
        const baseAlvo = comissaoCompoe
          ? novoAjusteValorFinalProposta *
            (1 - Math.min(Math.max(somaFracsComissaoAtuais, 0), 0.9999))
          : novoAjusteValorFinalProposta /
            (1 + Math.max(somaFracsComissaoAtuais, 0));

        if (baseAlvo > 0) {
          const aMaisPLucro =
            (valor_total_produto_servico_extra || 0) +
            (valor_total_incluindo_porcentagem || 0);
          const novoLucroTotalPercent = Number(
            ((1 - (encargos_total || 0) - aMaisPLucro / baseAlvo) * 100).toFixed(
              6
            )
          );
          atualizarResultadoPrecificacao({
            // Sentinela: não sobrescreve a base com um R$ bruto - quem a move
            // aqui é o lucro_total_ajuste.
            preco_venda_final_sem_comissao: null,
            lucro_total_ajuste: novoLucroTotalPercent,
          })?.then((dadosPreco) => {
            if (!dadosPreco) return;
            const baseReal =
              dadosPreco.preco_venda_final_sem_comissao ?? baseAlvo;
            if (Math.abs(baseReal - valorBaseReferencia) > 0.01) {
              setValorBaseReferencia(baseReal);
            }
            // Input e card "VALOR FINAL DA PROPOSTA" sempre com o mesmo número.
            if (
              Math.abs(dadosPreco.preco_venda - novoAjusteValorFinalProposta) <=
              0.01
            ) {
              form.setValue(
                "ajusteValorFinalProposta_formatado",
                FormatFields.formatarNumero(dadosPreco.preco_venda)
              );
            }
          });
        }
        return;
      }

      // Caso 1: o ajuste sai da COMISSÃO (cascata completa ou só Vendedor) e
      // nunca do lucro/base - a base (preco_venda_final_sem_comissao) fica
      // travada no valor atual. limiteMinimoAjusteFinal já trava o clamp no
      // topo desse efeito no ponto onde a comissão disponível pra reduzir
      // chega em zero.
      if (podeAlterarTodasComissoes) {
        // Usuário pode mexer em todas as comissões - zera em cascata
        // (Vendedor → Pré-Vendedor → Gerente → Supervisor → Indicação) até
        // bater o alvo, em vez de só reduzir o Vendedor e parar em 0.
        const fracsResolvidas = resolverComissoesEmCascata(
          preco_venda_final_sem_comissao,
          novoAjusteValorFinalProposta,
          {
            vendedor: cVendedorOriginalRef.current ?? (c_vendedor || 0),
            preVendedor:
              cPreVendedorOriginalRef.current ?? (c_pre_vendedor || 0),
            gerente: cGerenteOriginalRef.current ?? (c_gerente || 0),
            supervisor: cSupervisorOriginalRef.current ?? (c_supervisor || 0),
            indicacao: cIndicacaoOriginalRef.current ?? (c_indicacao || 0),
          },
          valorMaximoVendaOriginalRef.current ?? valor_maximo_venda,
          String(calcular_comissao_por_loja) === "2"
        );
        // Caso 3 da planilha ("Calcular a Comissão por" = Valor Base Empresa +
        // "Quando Alterado o Valor Final" = Altera a Comissão do Vendedor):
        // digitar R$ 22.150,00 devolvia R$ 22.150,01 (projeto 56 da HLG).
        //
        // Por quê: no modo "1" o cálculo (calcularPreco, em CXESSIM002) fecha o
        // Valor Final somando as comissões JÁ ARREDONDADAS a 2 casas -
        // round2(base + Σ round2(base * %)). Mandar as comissões como fração
        // pura deixa sobrar/faltar o resíduo desses arredondamentos, e ele
        // reaparece como 1 ou 2 centavos no Valor Final. No caso 1 (modo "2")
        // isso não acontece porque lá o Valor Final sai de uma fórmula única -
        // base / (1 - soma dos %) - sem arredondar componente por componente.
        //
        // Correção: no modo "1" a cascata é resolvida em CENTAVOS INTEIROS
        // (mesma ordem de redução), garantindo que a soma das comissões
        // arredondadas feche exatamente no valor digitado.
        const distribuicaoEmCentavos = comissaoCompoe
          ? null
          : distribuirComissoesEmCentavos(
              preco_venda_final_sem_comissao,
              novoAjusteValorFinalProposta,
              {
                vendedor: cVendedorOriginalRef.current ?? (c_vendedor || 0),
                preVendedor:
                  cPreVendedorOriginalRef.current ?? (c_pre_vendedor || 0),
                gerente: cGerenteOriginalRef.current ?? (c_gerente || 0),
                supervisor:
                  cSupervisorOriginalRef.current ?? (c_supervisor || 0),
                indicacao: cIndicacaoOriginalRef.current ?? (c_indicacao || 0),
              },
              c_indicacao_bruto || 0
            );

        atualizarResultadoPrecificacao({
          valor_c_vendedor:
            distribuicaoEmCentavos?.valorVendedor ??
            fracsResolvidas.vendedor * preco_venda_final_sem_comissao,
          c_pre_vendedor_ajuste: Number(
            (
              (distribuicaoEmCentavos?.fracs.preVendedor ??
                fracsResolvidas.preVendedor) * 100
            ).toFixed(6)
          ),
          c_gerente_ajuste: Number(
            (
              (distribuicaoEmCentavos?.fracs.gerente ??
                fracsResolvidas.gerente) * 100
            ).toFixed(6)
          ),
          c_supervisor_ajuste: Number(
            (
              (distribuicaoEmCentavos?.fracs.supervisor ??
                fracsResolvidas.supervisor) * 100
            ).toFixed(6)
          ),
          c_indicacao_ajuste: Number(
            (
              (distribuicaoEmCentavos?.fracs.indicacao ??
                fracsResolvidas.indicacao) * 100
            ).toFixed(6)
          ),
        })?.then((dadosPreco) => {
          if (!dadosPreco) return;
          // Input e card "VALOR FINAL DA PROPOSTA" têm que mostrar SEMPRE o
          // mesmo número - o que o cálculo realmente entregou. Descarta a
          // resposta se o alvo já mudou enquanto ela estava em voo.
          if (
            Math.abs(dadosPreco.preco_venda - novoAjusteValorFinalProposta) >
            0.01
          ) {
            return;
          }
          form.setValue(
            "ajusteValorFinalProposta_formatado",
            FormatFields.formatarNumero(dadosPreco.preco_venda)
          );
        });
        return;
      }

      // Modo "2" (Calcular pelo Total Final) compõe comissão sobre comissão:
      // Valor Final = Base / (1 - soma dos %) - por isso o ajuste do vendedor
      // não pode ser uma simples subtração, precisa inverter essa fórmula.
      let novoValorCVendedor: number;
      if (String(calcular_comissao_por_loja) === "2") {
        const outrosPercentuaisFrac =
          (c_pre_vendedor || 0) +
          (c_gerente || 0) +
          (c_indicacao || 0) +
          (c_supervisor || 0);
        const totalPercentualNecessario =
          1 - preco_venda_final_sem_comissao / novoAjusteValorFinalProposta;
        const vendedorFrac = Math.max(
          0,
          totalPercentualNecessario - outrosPercentuaisFrac
        );
        novoValorCVendedor = vendedorFrac * preco_venda_final_sem_comissao;
      } else {
        novoValorCVendedor = Math.max(
          0,
          novoAjusteValorFinalProposta - valor_minimo_venda
        );
      }

      atualizarResultadoPrecificacao({
        valor_c_vendedor: novoValorCVendedor,
      })?.then((dadosPreco) => {
        if (!dadosPreco) return;
        // Input e card "VALOR FINAL DA PROPOSTA" têm que mostrar SEMPRE o
        // mesmo número - o que o cálculo realmente entregou.
        form.setValue(
          "ajusteValorFinalProposta_formatado",
          FormatFields.formatarNumero(dadosPreco.preco_venda)
        );
      });
    }
  }, [ajusteValorFinalProposta]);

  // Os limites deste campo dependem da BASE (preco_venda_final_sem_comissao),
  // que muda quando "% Ajustes"/"Ajuste do Valor Base Empresa" é editado - e o
  // efeito de clamp acima só depende de [ajusteValorFinalProposta], então não
  // rodava nesse caso. Resultado: baixar a base pra 90% derrubava o teto (de
  // R$ 7.049,07 pra R$ 6.344,15) mas o input continuava com R$ 7.000,00,
  // divergindo do card "VALOR FINAL DA PROPOSTA".
  //
  // Reescreve só o estado - quem re-clampa, reescreve o form e recalcula é o
  // efeito acima, disparado por essa mudança. (ajusteValorFinalProposta fora
  // das deps de propósito: é lido do closure, e incluí-lo tornaria o efeito
  // reentrante.)
  useEffect(() => {
    if (!isLoaded || ocultarAjusteValorFinal) return;
    if (!(limiteMaximoAjuste > 0)) return;
    const clamped = Math.min(
      Math.max(ajusteValorFinalProposta, limiteMinimoAjusteFinal),
      limiteMaximoAjuste
    );
    if (Math.abs(clamped - ajusteValorFinalProposta) > 0.01) {
      setAjusteValorFinalProposta(Number(clamped.toFixed(2)));
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [limiteMinimoAjusteFinal, limiteMaximoAjuste, isLoaded]);

  // Base ORIGINAL (política pura), nunca a base já ajustada - senão o
  // "Desconto Máximo"/"Acréscimo Máximo" recalculam a cada edição do "%
  // Ajustes" (ou de qualquer coisa que mexa na base no modo Lucro da
  // Empresa), permitindo zerar o valor da proposta na prática.
  // Nunca abaixo do ponto onde o Lucro da Empresa zera - mesma regra suprema
  // do limiteMinimoAjusteBase acima, aplicada aqui pro clamp do valor
  // digitado bruto (antes de qualquer comparação com limiteMinimoAjusteBase).
  const valor_max_desconto_usuario = Math.max(
    baseReferencia100Porcento * (1 - maxDescontoPercent / 100),
    limiteMinimoAjusteBaseLucroZero
  );

  const valor_max_acrescimo_usuario =
    baseReferencia100Porcento * (1 + maxAcrescimoPercent / 100);

  // Cascata de comissões: quando o usuário tem permissão pra mexer em TODAS
  // as comissões (podeAlterarTodasComissoes), zerar só o Vendedor pode não
  // ser suficiente pra bater um alvo bem baixo, e vice-versa pro acréscimo.
  // `fracsFull` é sempre a % ORIGINAL da política (refs congelados), nunca a
  // % já ajustada de um ciclo anterior - a função é pura: mesmo alvo sempre
  // produz o mesmo resultado, não acumula erro entre chamadas.
  //
  // Desconto (alvoFinal <= tudo cheio): reduz na ordem Vendedor →
  // Pré-Vendedor → Gerente → Supervisor → Indicação - cada cargo só perde %
  // depois que o anterior já foi totalmente zerado.
  //
  // Acréscimo além do "tudo cheio" (todo mundo já no normal): preenche na
  // ordem inversa, de baixo pra cima - Indicação → Supervisor → Gerente →
  // Pré-Vendedor primeiro sobem pro próprio normal (se estiverem reduzidos),
  // e só o Vendedor estica ALÉM do normal, até `vendedorTetoFinal` (o mesmo
  // teto de "Acréscimo Máximo"/valor_maximo_venda) - os outros cargos não
  // têm um teto configurado além do normal da política.
  function resolverComissoesEmCascata(
    base: number,
    alvoFinal: number,
    fracsFull: {
      vendedor: number;
      preVendedor: number;
      gerente: number;
      supervisor: number;
      indicacao: number;
    },
    vendedorTetoFinal: number,
    compounding: boolean
  ) {
    const ordemReducao: Array<keyof typeof fracsFull> = [
      "vendedor",
      "preVendedor",
      "gerente",
      "supervisor",
      "indicacao",
    ];
    const sumFracFull = ordemReducao.reduce(
      (acc, chave) => acc + (fracsFull[chave] || 0),
      0
    );
    const finalComTudoCheio = compounding
      ? base / (1 - Math.min(sumFracFull, 0.9999))
      : base * (1 + sumFracFull);

    if (alvoFinal <= finalComTudoCheio) {
      const resultado = { ...fracsFull };
      if (compounding) {
        const sumFracAlvo =
          base > 0 && alvoFinal > 0 ? Math.max(0, 1 - base / alvoFinal) : 0;
        let deltaFrac = Math.max(0, sumFracFull - sumFracAlvo);
        for (const cargo of ordemReducao) {
          const fracFull = fracsFull[cargo] || 0;
          const reducao = Math.min(deltaFrac, fracFull);
          resultado[cargo] = fracFull - reducao;
          deltaFrac -= reducao;
        }
      } else {
        let deficit = Math.max(0, finalComTudoCheio - alvoFinal);
        for (const cargo of ordemReducao) {
          const fracFull = fracsFull[cargo] || 0;
          const valorFull = base * fracFull;
          const reducao = Math.min(deficit, valorFull);
          resultado[cargo] = base > 0 ? (valorFull - reducao) / base : 0;
          deficit -= reducao;
        }
      }
      return resultado;
    }

    // Acréscimo além do "tudo cheio": nenhum cargo passa da % configurada na
    // política de comissão - nem o Vendedor. Todo mundo fica no normal.
    //
    // (Antes o Vendedor era o único que "esticava" acima da própria % até
    // vendedorTetoFinal/valor_maximo_venda, e era assim que o "ACRÉSCIMO
    // MÁXIMO" era alcançado. Regra nova: comissão nunca passa do teto da
    // política, então o acréscimo real para no preço com todas as comissões
    // cheias - ver limiteMaximoAjuste.)
    return { ...fracsFull };
  }

  /**
   * Versão em CENTAVOS INTEIROS da cascata acima, usada só no modo "1"
   * ("Calcular a Comissão por" = Valor Base Empresa).
   *
   * Nesse modo o cálculo fecha o Valor Final como
   *   round2(base + Σ round2(base * %))
   * ou seja, arredonda componente por componente antes de somar. Resolver a
   * cascata em frações e deixar o cálculo arredondar depois faz sobrar/faltar
   * o resíduo desses arredondamentos - foi o que devolvia R$ 22.150,01 quando
   * o usuário digitava R$ 22.150,00 (caso 3 da planilha, projeto 56 da HLG).
   *
   * Aqui a conta é feita em centavos inteiros, na mesma ordem de redução
   * (Vendedor → Pré-Vendedor → Gerente → Supervisor → Indicação), de forma que
   * a soma das comissões arredondadas bata EXATAMENTE no valor digitado. A
   * comissão do Vendedor volta em R$ (é assim que o cálculo a recebe) e as
   * demais em fração, já "encaixadas" em centavos redondos sobre a base.
   *
   * A Indicação Bruta (c_indicacao_bruto) é somada pelo cálculo por fora e não
   * é redutível, então entra aqui apenas como parcela fixa do alvo.
   */
  function distribuirComissoesEmCentavos(
    base: number,
    alvoFinal: number,
    fracsFull: {
      vendedor: number;
      preVendedor: number;
      gerente: number;
      supervisor: number;
      indicacao: number;
    },
    brutoIndicacao: number
  ) {
    const emCentavos = (valor: number) =>
      Math.round(Number((valor || 0).toFixed(2)) * 100);
    const ordemReducao: Array<keyof typeof fracsFull> = [
      "vendedor",
      "preVendedor",
      "gerente",
      "supervisor",
      "indicacao",
    ];

    const centavos: Record<string, number> = {};
    ordemReducao.forEach((cargo) => {
      centavos[cargo] = emCentavos(base * (fracsFull[cargo] || 0));
    });

    const centavosCheios =
      ordemReducao.reduce((acc, cargo) => acc + centavos[cargo], 0) +
      emCentavos(brutoIndicacao);
    // Quanto de comissão o alvo comporta (o cálculo soma tudo por cima da base).
    const centavosAlvo = emCentavos(alvoFinal - base);

    let deficit = centavosCheios - centavosAlvo;
    if (deficit > 0) {
      for (const cargo of ordemReducao) {
        const reducao = Math.min(deficit, centavos[cargo]);
        centavos[cargo] -= reducao;
        deficit -= reducao;
        if (deficit <= 0) break;
      }
    }
    // Acréscimo além do "tudo cheio": nenhum cargo passa da % da política -
    // mesma regra da resolverComissoesEmCascata, então mantém os valores cheios.

    // Volta de centavos para fração da base, sem nunca passar da % configurada
    // na política: o arredondamento para centavo cheio (R$ 209,8083 -> R$ 209,81)
    // devolvia uma fração levemente MAIOR que a política (1,000008% no lugar de
    // 1%), e esse resíduo virava aviso falso de "Comissão acima do padrão" no
    // recálculo seguinte (ver calcularPreco em CXESSIM002).
    const fracDe = (valorCentavos: number, cargo: keyof typeof fracsFull) =>
      base > 0
        ? Math.min(valorCentavos / 100 / base, fracsFull[cargo] || 0)
        : 0;

    return {
      valorVendedor: centavos.vendedor / 100,
      fracs: {
        preVendedor: fracDe(centavos.preVendedor, "preVendedor"),
        gerente: fracDe(centavos.gerente, "gerente"),
        supervisor: fracDe(centavos.supervisor, "supervisor"),
        indicacao: fracDe(centavos.indicacao, "indicacao"),
      },
    };
  }

  // Regra suprema: "Ajuste do Valor Base Empresa"/"% Ajustes" nunca mexe em
  // comissão de ninguém - limiteMinimoAjusteBase/valor_max_desconto_usuario
  // já travam no ponto onde o Lucro da Empresa zera, então não existe mais
  // cenário aqui que precise sair da comissão do Vendedor (e por isso não
  // precisa mais avisar/confirmar nada com o usuário).
  function aplicarValorBaseComConfirmacaoSeNoPiso(
    valorDigitado: number,
    sincronizarDisplay: (valor: number) => void
  ) {
    // Trava no range permitido ("% Ajustes"/"Ajuste do Valor Base Empresa"
    // nunca podem passar do Desconto Máximo/Acréscimo Máximo) - sem isso, um
    // valor abaixo/acima do range ficava só marcado como erro
    // (descontoAcrescimoError, bloqueia o "Próximo") mas a base já tinha
    // sido aplicada errada, e a segunda edição em cima desse estado quebrado
    // fazia a tela toda perder a consistência.
    const valor = Number(
      Math.min(
        Math.max(valorDigitado, valor_max_desconto_usuario),
        valor_max_acrescimo_usuario
      ).toFixed(2)
    );
    if (Math.abs(valor - valorDigitado) > 0.01) {
      sincronizarDisplay(valor);
    }

    setValorProposta(valor);
  }

  function atualizarResultadoPrecificacao(parametros?: any) {
    blockNextStep(true);
    const meuSeq = ++atualizarResultadoPrecificacaoSeq.current;
    return calcularPreco({
      ...form.control._formValues?.parametrosPrecificacao,
      politicaPreco: form.control._formValues?.politicaPreco,
      ...parametros,
      // Sentinela: mandar `preco_venda_final_sem_comissao: null` explicitamente
      // significa "não sobrescreva a base" - deixa ela ser recalculada do zero
      // (usado no modo Lucro da Empresa, onde quem muda a base é o
      // lucro_total_ajuste, não um override bruto do valor final).
      preco_venda_final_sem_comissao:
        parametros?.preco_venda_final_sem_comissao === null
          ? undefined
          : parametros?.preco_venda_final_sem_comissao ||
            resultadoPrecificacao?.preco_venda_final_sem_comissao,
      // Preserva o % de Lucro da Empresa ajustado entre chamadas - senão
      // qualquer outra edição (ex: % Gerente) reseta o lucro de volta pro
      // padrão da política, perdendo o ajuste feito via Valor Final/Base.
      lucro_total_ajuste: Object.keys(parametros).includes("lucro_total_ajuste")
        ? parametros.lucro_total_ajuste
        : resultadoPrecificacao?.lucro_total !== undefined
          ? Number((resultadoPrecificacao.lucro_total * 100).toFixed(6))
          : undefined,
      // "naoAjustarVendedor" (modo Lucro da Empresa): comissão do Vendedor
      // nunca é tocada por esse fluxo - omite o override, deixa cair 100% no
      // padrão da política.
      // Quando valor_c_vendedor (R$ absoluto) é enviado, ele sempre ganha a
      // prioridade no cálculo (ver CXESSIM002/index.tsx), então mandar
      // c_vendedor_ajuste (%) junto é redundante e ainda dispara o aviso falso
      // "Comissão vendedor acima do padrão" (checado antes da prioridade
      // valer). Nesse caso, omite o campo.
      c_vendedor_ajuste: parametros?.naoAjustarVendedor
        ? undefined
        : Object.keys(parametros).includes("valor_c_vendedor")
          ? undefined
          : Object.keys(parametros).includes("c_vendedor_ajuste")
            ? parametros.c_vendedor_ajuste
            : Number((resultadoPrecificacao?.c_vendedor * 100).toFixed(6)),
      c_pre_vendedor_ajuste: Object.keys(parametros).includes(
        "c_pre_vendedor_ajuste"
      )
        ? parametros.c_pre_vendedor_ajuste
        : Number((resultadoPrecificacao?.c_pre_vendedor * 100).toFixed(6)),
      c_gerente_ajuste: Object.keys(parametros).includes("c_gerente_ajuste")
        ? parametros.c_gerente_ajuste
        : Number((resultadoPrecificacao?.c_gerente * 100).toFixed(6)),
      c_indicacao_ajuste: Object.keys(parametros).includes("c_indicacao_ajuste")
        ? parametros.c_indicacao_ajuste
        : Number((resultadoPrecificacao?.c_indicacao * 100).toFixed(6)),
      c_supervisor_ajuste: Object.keys(parametros).includes(
        "c_supervisor_ajuste"
      )
        ? parametros.c_supervisor_ajuste
        : Number((resultadoPrecificacao?.c_supervisor * 100).toFixed(6)),
    })
      .then((dadosPreco) => {
        // Chegou uma resposta mais antiga depois de uma mais nova já ter sido
        // disparada (usuário editou 2 campos rápido) - descarta, senão ela
        // reverte o campo mais recente pro valor de antes.
        if (meuSeq !== atualizarResultadoPrecificacaoSeq.current) {
          return null;
        }
        // // Se já existe um ajuste de proposta salvo no formulário ou no estado,
        // // preservar esse valor sobre o resultado retornado pelo cálculo.
        // const valorFinalSalvo = form.getValues("valorFinalProposta");
        // let valorFinalSalvoNumerico: number | null = null;
        // if (valorFinalSalvo && valorFinalSalvo !== "0,00") {
        //   valorFinalSalvoNumerico =
        //     +FormatFields.desformatarNumeros(valorFinalSalvo);
        // } else if (typeof valorProposta === "number" && !isNaN(valorProposta)) {
        //   valorFinalSalvoNumerico = valorProposta;
        // }

        form.setValue("parametrosPrecificacao", {
          ...form.control._formValues?.parametrosPrecificacao,
          politicaPreco: form.control._formValues?.politicaPreco,
          preco_venda_final_sem_comissao:
            parametros?.preco_venda_final_sem_comissao === null
              ? undefined
              : parametros?.preco_venda_final_sem_comissao ||
                resultadoPrecificacao?.preco_venda_final_sem_comissao,
          c_vendedor_ajuste: parametros?.naoAjustarVendedor
            ? undefined
            : Object.keys(parametros).includes("valor_c_vendedor")
              ? undefined
              : Object.keys(parametros).includes("c_vendedor_ajuste")
                ? parametros.c_vendedor_ajuste
                : Number((resultadoPrecificacao?.c_vendedor * 100).toFixed(6)),
          c_pre_vendedor_ajuste: Object.keys(parametros).includes(
            "c_pre_vendedor_ajuste"
          )
            ? parametros.c_pre_vendedor_ajuste
            : Number((resultadoPrecificacao?.c_pre_vendedor * 100).toFixed(6)),
          c_gerente_ajuste: Object.keys(parametros).includes("c_gerente_ajuste")
            ? parametros.c_gerente_ajuste
            : Number((resultadoPrecificacao?.c_gerente * 100).toFixed(6)),
          c_indicacao_ajuste: Object.keys(parametros).includes(
            "c_indicacao_ajuste"
          )
            ? parametros.c_indicacao_ajuste
            : Number((resultadoPrecificacao?.c_indicacao * 100).toFixed(6)),
          c_supervisor_ajuste: Object.keys(parametros).includes(
            "c_supervisor_ajuste"
          )
            ? parametros.c_supervisor_ajuste
            : Number((resultadoPrecificacao?.c_supervisor * 100).toFixed(6)),
        });
        setResultadoPrecificacao(dadosPreco);
        console.log("Dados de preço calculados2:", dadosPreco);
        form.setValue("resultadoPrecificacao", dadosPreco);
        // form.setValue(
        //   "valorFinalProposta",
        //   formatarNumero(dadosPreco.preco_venda)
        // );

        // blockNextStep(false);
        // setConfirmaAvancoComissao(
        //   [
        //     dadosPreco.c_vendedor,
        //     dadosPreco.c_pre_vendedor,
        //     dadosPreco.c_gerente,
        //     dadosPreco.c_supervisor,
        //     dadosPreco.c_indicacao,
        //     dadosPreco.c_indicacao_bruto,
        //     dadosPreco.valor_comissao,
        //   ].some((val) => val != 0)
        // );

        // const novo_valor_max_desconto_usuario =
        //   dadosPreco.preco_venda * (1 - maxDescontoPercent / 100);
        // const novo_valor_max_acrescimo_usuario =
        //   dadosPreco.preco_venda * (1 + maxAcrescimoPercent / 100);
        // if (
        //   !form.control._formValues?.valorFinalProposta ||
        //   form.control._formValues?.valorFinalProposta == "0,00" ||
        //   Number(valorProposta?.toFixed(2)) <
        //     Number(novo_valor_max_desconto_usuario.toFixed(2)) ||
        //   Number(valorProposta?.toFixed(2)) >
        //     Number(novo_valor_max_acrescimo_usuario.toFixed(2))
        // ) {
        //   form.setValue("porcentagemValorFinal", formatarNumero(100.0));
        //   setValorProposta(dadosPreco.preco_venda_final_sem_comissao);
        // } else {
        //   recalcularValorPorcentagemProposta();
        // }
        setIsLoaded(true);
        return dadosPreco;
      })
      .catch(() => {
        setIsLoaded(true);
        return null;
      });
  }

  // // Função para calcular o total de comissões dinamicamente
  // const calcularTotalComissoes = () => {
  //   let total = 0;

  //   const valorFinalPropostaFormRaw = form?.getValues("valorFinalProposta");
  //   const valorFinalPropostaForm = valorFinalPropostaFormRaw
  //     ? +FormatFields.desformatarNumeros(valorFinalPropostaFormRaw)
  //     : null;

  //   const valorPropostaBase =
  //     typeof valorProposta === "number" && !isNaN(valorProposta)
  //       ? valorProposta
  //       : valorFinalPropostaForm !== null && !isNaN(valorFinalPropostaForm)
  //         ? valorFinalPropostaForm
  //         : resultadoPrecificacao?.preco_venda_final_sem_comissao ||
  //           preco_venda_final_sem_comissao ||
  //           0;

  //   // Buscar valores editados do form, se existirem
  //   const comissaoVendedorForm = form?.getValues("comissaoVendedorPercentual");
  //   const comissaoPreVendedorForm = form?.getValues(
  //     "comissaoPreVendedorPercentual"
  //   );
  //   const comissaoGerenteForm = form?.getValues("comissaoGerentePercentual");
  //   const comissaoSupervisorForm = form?.getValues(
  //     "comissaoSupervisorPercentual"
  //   );
  //   const comissaoIndicacaoForm = form?.getValues(
  //     "comissaoIndicacaoPercentual"
  //   );

  //   // Usar valores do form se existirem, senão usar valores originais
  //   const c_vendedor_final =
  //     comissaoVendedorForm !== undefined
  //       ? comissaoVendedorForm / 100
  //       : c_vendedor;
  //   const c_pre_vendedor_final =
  //     comissaoPreVendedorForm !== undefined
  //       ? comissaoPreVendedorForm / 100
  //       : c_pre_vendedor;
  //   const c_gerente_final =
  //     comissaoGerenteForm !== undefined ? comissaoGerenteForm / 100 : c_gerente;
  //   const c_supervisor_final =
  //     comissaoSupervisorForm !== undefined
  //       ? comissaoSupervisorForm / 100
  //       : c_supervisor;
  //   const c_indicacao_final =
  //     comissaoIndicacaoForm !== undefined
  //       ? comissaoIndicacaoForm / 100
  //       : c_indicacao;

  //   // Vendedor
  //   total += valorPropostaBase * c_vendedor_final;

  //   // Pré-Vendedor
  //   total += valorPropostaBase * c_pre_vendedor_final;

  //   // Gerente
  //   total += valorPropostaBase * c_gerente_final;

  //   // Supervisor
  //   total += valorPropostaBase * c_supervisor_final;

  //   // Indicação
  //   total += valorPropostaBase * c_indicacao_final;
  //   total += c_indicacao_bruto;

  //   return total;
  // };

  // useEffect(() => {
  //   const novoValor = calcularTotalComissoes();
  //   setValorComissaoCalculado(novoValor);
  // }, [
  //   form?.watch("comissaoVendedorPercentual"),
  //   form?.watch("comissaoPreVendedorPercentual"),
  //   form?.watch("comissaoGerentePercentual"),
  //   form?.watch("comissaoSupervisorPercentual"),
  //   form?.watch("comissaoIndicacaoPercentual"),
  //   preco_venda_sem_comissao,
  //   resultadoPrecificacao,
  //   valorProposta,
  // ]);

  // // useEffect para calcular comissão inicial quando a página carrega
  // useEffect(() => {
  //   if (isLoaded && preco_venda_sem_comissao) {
  //     const novoValor = calcularTotalComissoes();
  //     setValorComissaoCalculado(novoValor);
  //   }
  // }, [isLoaded, preco_venda_sem_comissao]);

  // useEffect para inicializar valores quando a página carrega
  useEffect(() => {
    if (isLoaded && resultadoPrecificacao?.preco_venda_sem_comissao) {
      // Se não existe valorProposta mas existe um valor salvo no form
      if (!valorProposta || valorProposta === 0) {
        const valorFinalSalvo = form.getValues("valorFinalProposta");

        if (valorFinalSalvo && valorFinalSalvo !== "0,00") {
          const valorNumerico =
            +FormatFields.desformatarNumeros(valorFinalSalvo);

          if (valorNumerico > 0) {
            // Atualizar valorProposta com o valor salvo
            setValorProposta(valorNumerico);

            // Calcular e definir a porcentagem (usar valor antigo ajustado com custos extras)
            const porcentagem =
              (valorNumerico / preco_venda_final_sem_comissao) * 100;
            form.setValue("porcentagemValorFinal", formatarNumero(porcentagem));
          }
        }
      }
      // Só inicializa uma vez (valor ainda não setado) - resincronizar aqui toda
      // vez que resultadoPrecificacao muda cria loop de retroalimentação com o
      // efeito de ajusteValorFinalProposta logo acima (cada edição do usuário
      // nesse campo ou no "valorProposta" reseta o outro, gerando o drift de
      // arredondamento a cada ciclo).
      if (
        isLoaded &&
        (!ajusteValorFinalProposta || ajusteValorFinalProposta === 0)
      ) {
        setAjusteValorFinalProposta(preco_venda);
      }
      form.setValue("resultadoPrecificacao", resultadoPrecificacao);
    }
    // blockNextStep(!confirmaAvancoComissao || false);
  }, [isLoaded, resultadoPrecificacao]);

  useEffect(() => {
    blockNextStep(!confirmaAvancoComissao || descontoAcrescimoError);
  }, [descontoAcrescimoError, confirmaAvancoComissao, resultadoPrecificacao]);

  function recalcularValorPorcentagemProposta() {
    // // Determinar a base numérica utilizada (o mesmo usado para o card)
    // const valorFinalPropostaFormRaw = form.getValues("valorFinalProposta");
    // const valorFinalPropostaForm = valorFinalPropostaFormRaw
    //   ? +FormatFields.desformatarNumeros(valorFinalPropostaFormRaw)
    //   : NaN;

    // const baseUsed = !isNaN(valorProposta)
    //   ? valorProposta
    //   : Number.isFinite(valorFinalPropostaForm) &&
    //       !isNaN(valorFinalPropostaForm)
    //     ? valorFinalPropostaForm
    //     : preco_venda_final_sem_comissao || 0;

    // const finalPriceWithCommissions =
    //   baseUsed +
    //   (Number.isFinite(valorComissaoCalculado) ? valorComissaoCalculado : 0);

    // const finalPriceWithoutCommissions = baseUsed;

    // // Verificar limites usando o preço final (com comissões)
    if (
      Number(valorProposta.toFixed(2)) >=
        Number(valor_max_desconto_usuario.toFixed(2)) &&
      Number(valorProposta.toFixed(2)) <=
        Number(valor_max_acrescimo_usuario.toFixed(2))
    ) {
      // blockNextStep(!confirmaAvancoComissao || false);
      setDescontoAcrescimoError("");
    } else {
      blockNextStep(true);
      if (valorProposta < valor_max_desconto_usuario) {
        setDescontoAcrescimoError("Valor de Desconto excede o permitido");
      }
      if (
        valorProposta.toFixed(2) > (valor_max_acrescimo_usuario + 1).toFixed(2)
      ) {
        setDescontoAcrescimoError("Valor de Acréscimo excede o permitido");
      }
    }

    // // Atualizar campos de desconto/acréscimo no form com base no preço final
    // const referenciaPreco =
    //   form.control._formValues?.resultadoPrecificacao?.preco_venda ||
    //   resultadoPrecificacao?.preco_venda ||
    //   resultadoPrecificacao?.preco_venda ||
    //   0;
    // if (finalPriceWithCommissions > referenciaPreco) {
    //   form.setValue(
    //     "valorAcrescimo",
    //     finalPriceWithCommissions - referenciaPreco
    //   );
    //   form.setValue("valorDesconto", 0);
    // } else if (finalPriceWithCommissions < referenciaPreco) {
    //   form.setValue(
    //     "valorDesconto",
    //     referenciaPreco - finalPriceWithCommissions
    //   );
    //   try {
    //     form.unregister("valorAcrescimo");
    //   } catch (e) {
    //     // noop
    //   }
    // } else {
    //   form.setValue("valorDesconto", 0);
    //   try {
    //     form.unregister("valorAcrescimo");
    //   } catch (e) {
    //     // noop
    //   }
    // }

    // // Atualizar porcentagem baseada no preço final (comparando com preco_venda_sem_comissao ajustado)
    // if (resultadoPrecificacao?.preco_venda_sem_comissao) {
    //   const porcentagem = (baseUsed / preco_venda_final_sem_comissao) * 100;
    //   form.setValue("porcentagemValorFinal", formatarNumero(porcentagem));
    // }

    // // Atualizar valores auxiliares
    // if (typeof baseUsed === "number" && !isNaN(baseUsed)) {
    //   form.setValue("valorFinalProposta", formatarNumero(baseUsed));
    // }
    // form.setValue("valorTotal_proposta", baseUsed);
  }

  useEffect(() => {
    recalcularValorPorcentagemProposta();
    form.setValue("valorFinalProposta", formatarNumero(valorProposta));
    const porcentagem = (valorProposta / baseReferencia100Porcento) * 100;
    form.setValue("porcentagemValorFinal", formatarNumero(porcentagem));
    if (isLoaded) {
      // Restauração em andamento: quem manda no recálculo é
      // restaurarValoresIniciais(), não este efeito.
      if (
        valorPropostaRestauradoRef.current !== null &&
        Math.abs(valorProposta - valorPropostaRestauradoRef.current) <= 0.01
      ) {
        valorPropostaRestauradoRef.current = null;
        return;
      }
      // Voltou pro "100%" (valorProposta bate com a base ORIGINAL da política,
      // baseReferencia100Porcento): restaura a BASE e o LUCRO originais, porque
      // as ramificações abaixo operam sobre preco_venda_final_sem_comissao/
      // lucro_total AO VIVO, que uma edição anterior de "% Ajustes"/"Ajuste do
      // Valor Base Empresa" pode ter deixado "à deriva" (lucro_total_ajuste é
      // reenviado em toda chamada seguinte que não o sobrescreva - ver
      // atualizarResultadoPrecificacao).
      //
      // NÃO restaura os % de comissão. Regra suprema: "% Ajustes"/"Ajuste do
      // Valor Base Empresa" não mexem em comissão de ninguém - nem pra reduzir,
      // nem pra devolver ao padrão. Comissão é território exclusivo do "Ajuste
      // do Valor Final da Proposta".
      //
      // Era exatamente isso que apagava o ajuste do usuário: bastava este
      // efeito rodar uma vez com valorProposta ≈ base (um blur que reaplicasse
      // a mesma base, um remount, qualquer coisa) pra tudo voltar ao valor
      // original da política. Omitindo c_*_ajuste, atualizarResultadoPrecificacao
      // repassa as comissões AO VIVO (resultadoPrecificacao?.c_*) e o ajuste
      // sobrevive.
      if (
        Math.abs(valorProposta - baseReferencia100Porcento) <= 0.01 &&
        precoVendaSemComissaoOriginalRef.current !== null
      ) {
        atualizarResultadoPrecificacao({
          preco_venda_final_sem_comissao:
            precoVendaSemComissaoOriginalRef.current,
          lucro_total_ajuste:
            lucroTotalOriginalRef.current !== null
              ? Number((lucroTotalOriginalRef.current * 100).toFixed(6))
              : undefined,
        })?.then((dadosPreco) => {
          if (!dadosPreco) return;
          if (
            Math.abs(dadosPreco.preco_venda - ajusteValorFinalProposta) > 0.01
          ) {
            setAjusteValorFinalProposta(dadosPreco.preco_venda);
          }
        });
        return;
      }

      // Regra suprema: "Ajuste do Valor Base Empresa"/"% Ajustes" NUNCA mexe
      // em comissão de ninguém, de forma alguma - sempre modo "Lucro da
      // Empresa" pra esse campo, independente de acaoValorFinalProposta_loja
      // (a config da loja só vale pro campo "Ajuste do Valor Final da
      // Proposta"). limiteMinimoAjusteBase/valor_max_desconto_usuario já
      // travam o valorProposta no ponto onde o Lucro da Empresa zera, então
      // não existe mais cenário de "no piso, cai pra comissão do Vendedor"
      // aqui - a exceção que existia pra isso foi removida de propósito.
      const aMaisP =
        (valor_total_produto_servico_extra || 0) +
        (valor_total_incluindo_porcentagem || 0);
      // % com precisão alta (não 2 casas) pra reproduzir o valorProposta
      // exato na volta.
      const novoLucroTotalPercent = Number(
        ((1 - (encargos_total || 0) - aMaisP / valorProposta) * 100).toFixed(6)
      );

      const parametrosAtualizacao: any = {
        naoAjustarVendedor: true,
        preco_venda_final_sem_comissao: null,
        lucro_total_ajuste: novoLucroTotalPercent,
      };
      if (Math.abs(valorProposta - valorBaseReferencia) > 0.01) {
        setValorBaseReferencia(valorProposta);
      }
      // "% Ajustes" precisa refletir esse valorProposta - senão fica
      // travado em 100% mesmo com o "Ajuste do Valor Base Empresa" tendo
      // sido editado direto (sem passar pelo campo "% Ajustes").
      form.setValue(
        "porcentagemValorFinal",
        formatarNumero((valorProposta / baseReferencia100Porcento) * 100)
      );

      atualizarResultadoPrecificacao(parametrosAtualizacao)?.then(
        (dadosPreco) => {
          // Mantém "Ajuste do Valor Final da Proposta" refletindo o total atual
          // sempre que a base (Ajuste do Valor Base Empresa) muda. Só propaga se
          // realmente mudou (>1 centavo) - senão isso re-dispara o efeito de
          // ajusteValorFinalProposta, que por sua vez re-sincroniza valorProposta,
          // disparando este efeito de novo: loop infinito de retrigger.
          if (
            dadosPreco &&
            Math.abs(dadosPreco.preco_venda - ajusteValorFinalProposta) > 0.01
          ) {
            setAjusteValorFinalProposta(dadosPreco.preco_venda);
          }
        }
      );
    }
  }, [
    valorProposta,
    // preco_venda,
    // confirmaAvancoComissao,
    // valorComissaoCalculado,
    // resultadoPrecificacao?.preco_venda,
    // resultadoPrecificacao?.preco_venda,
  ]);

  /**
   * Item 04 - textos do "i" do ajuste, transcritos da aba "Valor Final da
   * Proposta" da planilha do integrador.
   *
   * Os quatro casos da planilha são o cruzamento de dois parâmetros da loja:
   *   calcular_comissao_por_loja:   "2" = Valor Final da Proposta
   *                                 "1" = Valor Base da Empresa
   *   acaoValorFinalProposta_loja:  "1" = Altera os Valores de Comissão do Vendedor
   *                                 "2" = Altera o Lucro da Empresa
   *
   * Nos casos 1 e 2 (comissão pelo Valor Final) o texto vai no "i" do "Ajuste do
   * Valor Final da Proposta". Nos casos 3 e 4 esse campo é ocultado, então o
   * texto vai no "i" do "% Ajustes" - o campo que o usuário realmente edita ali.
   *
   * Cada caso tem duas redações: "(VENDEDOR)" e "(ADM) (Usuários Permissões)" -
   * ver usuarioVeTextoAdm. As duas mostram Valor Mínimo, Valor Máximo e Valor
   * Ajustado Atual; o que muda é a redação e os rótulos dos limites (LUCRO DA
   * EMPRESA para o vendedor, TODOS os % de Comissão para o ADM).
   *
   * Os limites exibidos são os que o campo REALMENTE aplica (os mesmos usados no
   * clamp), não os números do exemplo da planilha.
   */
  /**
   * Linha de identificação do usuário logado, presente em TODAS as mensagens de
   * atenção desta tela.
   *
   * Os limites mostrados nessas mensagens (Valor Mínimo/Máximo, Desconto e
   * Acréscimo Máximo) saem do cadastro do usuário logado - sem o nome dele na
   * mensagem não dava pra validar de onde veio cada número.
   *
   * O "ATENÇÃO!!" NÃO entra aqui nem no corpo das mensagens: quem o exibe é o
   * título do próprio alerta (handleSweetAlert), senão aparece duas vezes.
   */
  function linhaUsuarioLogado() {
    const nomeUsuario = usuario?.nome_usuario || "-";
    // Só o NOME do usuário logado, igual à planilha ("Usuário: Ailton
    // Vendedor"). A marca da variante ("(VENDEDOR)" / "(ADM) (Usuários
    // Permissões)") e os % de desconto/acréscimo do cadastro saíram daqui: na
    // planilha aquilo era anotação interna para indicar qual texto cada
    // permissão recebe, não conteúdo da mensagem.
    return `
      <div class="italic">
        Usuário: <b>${nomeUsuario}</b>
      </div>
    `;
  }

  function montarHtmlAtencaoAjuste(
    corpo: string,
    rotuloMinimo: string,
    valorMinimo: number,
    rotuloMaximo: string,
    valorMaximo: number,
    valorAtual: number,
    observacao: string
  ) {
    return `
      <div class="flex flex-col gap-2 text-left">
        ${linhaUsuarioLogado()}
        <div>${corpo}</div>
        <div class="italic text-meta-1">
          Valor Mínimo (${rotuloMinimo}): ${formatarValor(valorMinimo)}
        </div>
        <div class="italic text-meta-1">
          Valor Máximo (${rotuloMaximo}): ${formatarValor(valorMaximo)}
        </div>
        <div class="italic">
          Valor Ajustado Atual: ${formatarValor(valorAtual)}
        </div>
        <div class="italic font-semibold">${observacao}</div>
      </div>
    `;
  }

  /**
   * Item 03 - "Restaurar Valores Iniciais".
   *
   * Volta a tela pro estado da PRIMEIRA carga desta visita, antes de qualquer
   * alteração. Não precisa de snapshot novo: todos os valores originais já são
   * congelados na primeira resposta do calcularPreco
   * (precoVendaSemComissaoOriginalRef, lucroTotalOriginalRef e os
   * c*OriginalRef) justamente porque os limites da tela dependem deles.
   */
  const podeRestaurarValoresIniciais =
    isLoaded && precoVendaSemComissaoOriginalRef.current !== null;

  function restaurarValoresIniciais() {
    const baseOriginal = precoVendaSemComissaoOriginalRef.current;
    if (baseOriginal === null) return;

    handleSweetAlert({
      icon: "warning",
      title: "Restaurar Valores Iniciais?",
      html: 'Os ajustes feitos nesta tela ("% Ajustes", "Ajuste do Valor Base Empresa", "Ajuste do Valor Final da Proposta" e os % de comissão) voltam para os valores de quando você entrou. Essa ação não pode ser desfeita.',
    }).then((result: any) => {
      if (!result?.isConfirmed) return;

      // Impede o efeito de [valorProposta] de emitir um recálculo concorrente -
      // mas SÓ quando valorProposta vai realmente mudar. Se o usuário mexeu
      // apenas no Valor Final, setValorProposta abaixo é no-op, o efeito nunca
      // dispara e a marca ficaria pendurada, engolindo a próxima edição
      // legítima da base que caísse nesse mesmo valor.
      valorPropostaRestauradoRef.current =
        Math.abs(valorProposta - baseOriginal) > 0.01 ? baseOriginal : null;
      usuarioEditouAjusteRef.current = false;
      setDescontoAcrescimoError("");
      form.clearErrors("ajusteValorFinalProposta_formatado");

      setValorProposta(baseOriginal);
      setValorBaseReferencia(baseOriginal);
      form.setValue("valorFinalProposta", formatarNumero(baseOriginal));
      form.setValue("porcentagemValorFinal", formatarNumero(100));

      atualizarResultadoPrecificacao({
        preco_venda_final_sem_comissao: baseOriginal,
        lucro_total_ajuste:
          lucroTotalOriginalRef.current !== null
            ? Number((lucroTotalOriginalRef.current * 100).toFixed(6))
            : undefined,
        c_vendedor_ajuste: Number(
          ((cVendedorOriginalRef.current ?? 0) * 100).toFixed(6)
        ),
        c_pre_vendedor_ajuste: Number(
          ((cPreVendedorOriginalRef.current ?? 0) * 100).toFixed(6)
        ),
        c_gerente_ajuste: Number(
          ((cGerenteOriginalRef.current ?? 0) * 100).toFixed(6)
        ),
        c_supervisor_ajuste: Number(
          ((cSupervisorOriginalRef.current ?? 0) * 100).toFixed(6)
        ),
        c_indicacao_ajuste: Number(
          ((cIndicacaoOriginalRef.current ?? 0) * 100).toFixed(6)
        ),
      })?.then((dadosPreco) => {
        if (!dadosPreco) return;
        const baseReal =
          dadosPreco.preco_venda_final_sem_comissao ?? baseOriginal;
        setValorBaseReferencia(baseReal);
        setAjusteValorFinalProposta(dadosPreco.preco_venda);
        form.setValue("valorFinalProposta", formatarNumero(baseReal));
        form.setValue("porcentagemValorFinal", formatarNumero(100));
        form.setValue("ajusteValorFinalProposta", dadosPreco.preco_venda);
        form.setValue(
          "ajusteValorFinalProposta_formatado",
          FormatFields.formatarNumero(dadosPreco.preco_venda)
        );
        form.clearErrors("ajusteValorFinalProposta_formatado");
        toast.success("Valores iniciais restaurados.");
      });
    });
  }

  // Variante do texto: (ADM) (Usuários Permissões) x (VENDEDOR), conforme a
  // aba "Valor Final da Proposta" da planilha.
  //
  // O CARGO manda: quem é Vendedor recebe SEMPRE a variante (VENDEDOR), mesmo
  // que tenha a permissão "9. Informar Valor Comissão" marcada. Antes o único
  // discriminador era essa permissão (podeAlterarTodasComissoes), e um vendedor
  // com ela ligada caía no texto de ADM - era o motivo de as mensagens não
  // baterem com a planilha ao entrar como VENDEDOR.
  //
  // Para quem NÃO é Vendedor, segue valendo a permissão: é ela que decide se o
  // usuário pode zerar todas as comissões, então o texto não descreve uma faixa
  // diferente da que o campo realmente aceita.
  //
  // Identificação do cargo: `vendedor_cargo == 1` da tabela de cargos (mesma
  // regra do SpeedDial). O `cargo_perfil == "2"` é o fallback já usado em
  // vários pontos do sistema, para o caso da lista de cargos não ter carregado.
  const usuarioEhVendedor =
    (idCargoVendedor !== null &&
      String(perfil?.cargo_perfil) === String(idCargoVendedor)) ||
    (idCargoVendedor === null && String(perfil?.cargo_perfil) === "2");
  const usuarioVeTextoAdm = !usuarioEhVendedor && podeAlterarTodasComissoes;

  /**
   * "i" do "Ajuste do Valor Final da Proposta" - casos 1, 2 e 3 da planilha
   * (só no caso 4 o campo é OCULTADO, ver ocultarAjusteValorFinal).
   *
   * Caso 3 ("1" + "1") cai no mesmo texto do caso 1: nos dois a ação é "Altera
   * os Valores de Comissão do Vendedor", e é da comissão que o ajuste sai. A
   * diferença entre eles é só a BASE de cálculo da comissão (composta no caso 1,
   * aditiva no caso 3), que muda os números, não a redação.
   */
  function htmlInfoAjusteValorFinal() {
    // Caso 2 da planilha: "Quando Alterado o Valor Final na Proposta" = Altera
    // o Lucro da Empresa. O desconto sai do LUCRO DA EMPRESA e os % de comissão
    // ficam parados - e os limites abaixo já são os do lucro/base, então os
    // rótulos descrevem exatamente o que os números representam.
    if (ajusteValorFinalIncideNoLucro) {
      const observacao =
        "Obs: Neste caso deverá ser diminuido do % de lucro da loja e recalculado os valores de comissões com os % configurados nos parametros, SEM ALTERAR OS % DE COMISSÕES.";
      // Vendedor e ADM veem a MESMA redação e os MESMOS limites aqui: na
      // planilha o bloco do vendedor traz "Valor Mínimo (Zerando o % de LUCRO DA
      // EMPRESA)" / "Valor Máximo (Considerando o % de LUCRO DA EMPRESA)" com os
      // valores. A anotação "=> ISSO AQUI APENAS PARA VC SABER MAS NÃO MOSTRAR
      // OS VENDENDEDORES" era referência interna da planilha, não instrução de
      // esconder os limites na tela.
      return montarHtmlAtencaoAjuste(
        "Se houver desconto no Ajuste do Valor Final da Proposta irá diminuir do percentual e Valor do LUCRO DA EMPRESA, que neste caso o valor poderá ficar entre:",
        "Zerando o % de LUCRO DA EMPRESA",
        limiteMinimoAjusteFinal,
        "Considerando o % de LUCRO DA EMPRESA",
        limiteMaximoAjuste,
        ajusteValorFinalProposta,
        observacao
      );
    }

    // Caso 1 da planilha: Altera os Valores de Comissão do Vendedor (% e R$).
    const observacaoCaso1 =
      "Obs: Lembrando que neste caso os % de comissões serão alterados automaticamente, diminuindo conforme a necessidade do desconto informado.";
    if (usuarioVeTextoAdm) {
      return montarHtmlAtencaoAjuste(
        "Se houver desconto no Ajuste do Valor Final da Proposta irá diminuir dos percentuais e Valores das Comissões configuradas, que neste caso o valor poderá ficar entre:",
        "Zerando TODOS os % de Comissões",
        limiteMinimoAjusteFinal,
        "Considerando TODOS os % de Comissão",
        limiteMaximoAjuste,
        ajusteValorFinalProposta,
        observacaoCaso1
      );
    }
    // (VENDEDOR) - casos 1 e 3 (célula D3). É o único texto de vendedor que a
    // planilha manda mostrar COM os limites: aqui o ajuste sai da comissão dele
    // mesmo, então ele precisa saber até onde pode ir.
    return montarHtmlAtencaoAjuste(
      "Se houver desconto no Ajuste do Valor Final da Proposta irá diminuir do percentual e Valor da Comissão do Vendedor, que neste caso o valor poderá ficar entre:",
      "Zerando o % de Comissão do VENDEDOR",
      limiteMinimoAjusteFinalVendedor,
      "Considerando o % de Comissão do VENDEDOR",
      limiteMaximoAjuste,
      ajusteValorFinalProposta,
      observacaoCaso1
    );
  }

  /**
   * "i" do "% Ajustes"/"Ajuste do Valor Base Empresa". Em TODOS os 4 casos da
   * planilha esse campo mexe no LUCRO DA EMPRESA (Valor Base Empresa) e nunca
   * nos % de comissão - só a observação final muda de caso pra caso.
   */
  function htmlInfoAjustePercentual() {
    const comissaoPorValorFinal = String(calcular_comissao_por_loja) === "2";
    const alteraLucro = String(acaoValorFinalProposta_loja) === "2";

    // Observação por caso (colunas "Obs" da planilha).
    let observacao: string;
    if (comissaoPorValorFinal && !alteraLucro) {
      // Caso 1. A planilha trazia aqui "e não poderá alterar o VALOR BASE
      // EMPRESA" - clausula removida de propósito: essa restrição foi retirada
      // do sistema (o campo "Ajuste do Valor Base Empresa" é editável em
      // qualquer configuração de loja), então manter o texto descreveria um
      // comportamento que não existe mais.
      observacao =
        "Obs: Lembrando que neste caso os % de comissões só deverão ser alterados manualmente pelo usuário sem recalcular, e o desconto não poderá ser maior que o % de LUCRO configurado.";
    } else if (alteraLucro && comissaoPorValorFinal) {
      // Caso 2.
      observacao =
        "Obs: Neste caso deverá ser diminuido do % de lucro da loja e recalculado os valores de comissões com os % configurados nos parametros.";
    } else {
      // Casos 3 e 4 (comissão calculada pelo Valor Base da Empresa).
      observacao =
        "Obs: Lembrando que neste caso os % de comissões só deverão ser alterados manualmente pelo usuário.";
    }

    // (VENDEDOR): abertura literal da planilha - caso 1 na célula D5, casos 2, 3
    // e 4 nas células D12/D18/D24 -, agora COM os limites (rótulos de LUCRO DA
    // EMPRESA, como no bloco laranja da planilha).
    //
    // Os limites do vendedor saem na escala que ele consegue editar: quem não vê
    // o campo "Ajuste do Valor Base Empresa"
    // (visualiza_valor_base_proposta_usuario != "1") só mexe no Valor Final, e
    // mostrar o número na escala sem comissão não bateria com nada na tela -
    // mesma regra do card "Desconto Máximo" (descontoMaximoExibido).
    //
    // O parágrafo que começa em "O % Ajustes é para o usuário conseguir
    // alterar..." é da variante (ADM) e não pode aparecer para o vendedor.
    if (!usuarioVeTextoAdm) {
      const veEscalaBase =
        usuario?.visualiza_valor_base_proposta_usuario == "1";
      return montarHtmlAtencaoAjuste(
        comissaoPorValorFinal && !alteraLucro
          ? // Caso 1 (D5).
            "Se houver desconto no % Ajustes, o valor será diminuido do percentual e Valor do LUCRO DA EMPRESA, que neste caso o valor poderá ficar entre:"
          : // Casos 2, 3 e 4 (D12/D18/D24).
            "Se houver desconto no % Ajustes da Proposta irá diminuir do percentual e Valor do LUCRO DA EMPRESA, que neste caso o valor poderá ficar entre:",
        "Zerando o % de LUCRO DA EMPRESA",
        veEscalaBase ? limiteMinimoAjusteBase : limiteMinimoAjusteFinal,
        "Considerando o % de LUCRO DA EMPRESA",
        veEscalaBase ? valor_max_acrescimo_usuario : limiteMaximoAjuste,
        veEscalaBase ? valorProposta : ajusteValorFinalProposta,
        observacao
      );
    }

    // (ADM) (Usuários Permissões): texto completo, com os limites na escala do
    // Valor Base Empresa (é a base que este campo move).
    return montarHtmlAtencaoAjuste(
      // A planilha escreve "e o Valor Final da Proposta poderá ficar entre",
      // mas os dois números do exemplo dela estão em escalas diferentes
      // (mínimo = base x 0,85; máximo = valor final x 1,15). Aqui os dois
      // limites são da escala do VALOR BASE - que é o que este campo move -,
      // então a frase fala de Valor Base Referência pra descrever o que os
      // números realmente são.
      "O % Ajustes é para o usuário conseguir alterar o Valor Base Referência, e está vinculado aos percentuais de desconto e acréscimo configurados no cadastro do usuário, que neste caso irá reduzir ou aumentar o LUCRO DA EMPRESA e o Valor Base Referência poderá ficar entre:",
      "Zerando TODOS os % de Comissão",
      limiteMinimoAjusteBase,
      "Considerando TODOS os % de Comissão Configurado",
      valor_max_acrescimo_usuario,
      valorProposta,
      observacao
    );
  }

  // Sincronizar os campos do form (valorDesconto / valorAcrescimo) com o Ajuste Aplicado
  useEffect(() => {
    // const precoFinalBase = resultadoPrecificacao?.preco_venda_sem_comissao || 0;

    // const valorFinalSalvo = form.getValues("valorFinalProposta");
    // const valorFinalNumerico =
    //   valorFinalSalvo && valorFinalSalvo !== "0,00"
    //     ? +FormatFields.desformatarNumeros(valorFinalSalvo)
    //     : typeof valorProposta === "number" && !isNaN(valorProposta)
    //       ? valorProposta
    //       : null;

    // if (valorFinalNumerico === null) {
    //   // Sem ajuste explícito: limpar campos relacionados
    //   try {
    //     form.setValue("valorDesconto", 0);
    //     form.unregister("valorAcrescimo");
    //   } catch (e) {
    //     // noop
    //   }
    //   return;
    // }

    if (!valorAjusteTotal) {
      // Sem ajuste explícito: limpar campos relacionados
      try {
        form.setValue("valorDesconto", 0);
        form.setValue("valorAcrescimo", 0);
        // form.unregister("valorAcrescimo");
      } catch (e) {
        // noop
      }
      return;
    }

    if (valorAjusteTotal > 0) {
      // Acréscimo
      form.setValue("valorAcrescimo", valorAjusteTotal);
      form.setValue("valorDesconto", 0);
    } else if (valorAjusteTotal < 0) {
      // Desconto
      form.setValue("valorDesconto", -valorAjusteTotal);
      form.setValue("valorAcrescimo", 0);
      // try {
      //   form.unregister("valorAcrescimo");
      // } catch (e) {
      //   // noop
      // }
    } else {
      form.setValue("valorDesconto", 0);
      form.setValue("valorAcrescimo", 0);
      // try {
      //   form.unregister("valorAcrescimo");
      // } catch (e) {
      //   // noop
      // }
    }
    form.setValue("valorAjusteTotal", valorAjusteTotal);
  }, [
    // form?.watch("valorFinalProposta"),
    // valorProposta,
    valorAjusteTotal,
    // resultadoPrecificacao?.preco_venda_sem_comissao,
  ]);

  // // Atualizar o campo do form 'preco_venda_aplicando_comissao' para refletir o card "Valor Final da Proposta"
  // useEffect(() => {
  //   const baseFromState = Number(valorProposta);
  //   const valorFinalPropostaFormRaw = form?.getValues("valorFinalProposta");
  //   const baseFromForm = valorFinalPropostaFormRaw
  //     ? +FormatFields.desformatarNumeros(valorFinalPropostaFormRaw)
  //     : NaN;

  //   const baseFallback =
  //     Number.isFinite(baseFromState) && !isNaN(baseFromState)
  //       ? baseFromState
  //       : Number.isFinite(baseFromForm) && !isNaN(baseFromForm)
  //         ? baseFromForm
  //         : resultadoPrecificacao?.preco_venda_sem_comissao ||
  //           resultadoPrecificacao?.preco_venda_sem_comissao ||
  //           0;

  //   const commission = Number.isFinite(valorComissaoCalculado)
  //     ? valorComissaoCalculado
  //     : 0;

  //   const totalComAplicacao = baseFallback + commission;

  //   // Atualiza o form com o valor numérico (não formatado) para uso posterior
  //   try {
  //     form.setValue("preco_venda_aplicando_comissao", totalComAplicacao);
  //     if (!ajusteValorFinalProposta && commission != 0) {
  //       form.setValue(
  //         "ajusteValorFinalProposta_formatado",
  //         FormatFields.formatarNumero(totalComAplicacao)
  //       );
  //       form.setValue("ajusteValorFinalProposta", totalComAplicacao);
  //     }
  //   } catch (e) {
  //     // noop
  //   }
  // }, [
  //   form?.watch("valorFinalProposta"),
  //   valorProposta,
  //   valorComissaoCalculado,
  //   resultadoPrecificacao?.preco_venda_sem_comissao,
  //   resultadoPrecificacao?.preco_venda_sem_comissao,
  // ]);

  return (
    <>
      {isLoaded ? (
        Object.keys(resultadoPrecificacao).some(
          (key) => resultadoPrecificacao[key] != 0
        ) ? (
          <div
            // onClick={() => setVisualizarValores((prev) => !prev)}
            className="dark:text-white max-sm:h-[75vh] max-sm:overflow-auto"
          >
            <div className="w-full flex flex-col justify-center items-center max-sm:text-xs relative p-4 md:p-6 bg-gradient-to-br from-white to-gray-50 dark:from-gray-900 dark:to-gray-800 rounded-lg shadow-sm">
              <div className="flex flex-col justify-center items-center w-full max-w-5xl gap-6">
                {/* Título */}
                <div className="text-center">
                  <h2 className="font-bold text-3xl max-sm:text-xl bg-gradient-to-r from-primary to-primary/70 bg-clip-text text-transparent">
                    Precificação
                  </h2>
                  <div className="h-1 w-20 bg-gradient-to-r from-primary to-primary/50 mx-auto mt-2 rounded-full"></div>
                </div>

                {/* Configurações da loja que definem como a comissão é
                    calculada nessa tela - só informativo, pra não precisar ir
                    até Configurações da Loja pra saber qual modo tá ativo. */}
                <div className="flex flex-wrap justify-center gap-2 -mt-2 mb-1">
                  <div className="flex items-center gap-1.5 text-xs font-medium text-gray-700 dark:text-gray-300">
                    <span>Calcular a Comissão por:</span>
                    <span className="px-3 py-1 rounded-full bg-primary/10 text-primary border border-primary/20">
                      {String(calcular_comissao_por_loja) === "2"
                        ? "Valor Final da Proposta"
                        : "Valor Base Empresa"}
                    </span>
                  </div>
                  <div className="flex items-center gap-1.5 text-xs font-medium text-gray-700 dark:text-gray-300">
                    <span>Quando Alterado o Valor Final na Proposta:</span>
                    <span className="px-3 py-1 rounded-full bg-primary/10 text-primary border border-primary/20">
                      {modoVendedorFlexivel
                        ? "Altera os Valores de Comissão do Vendedor (% e R$)"
                        : "Altera o Lucro da Empresa (% e R$)"}
                    </span>
                  </div>
                </div>

                {/* Item 03 - volta a tela pro estado da primeira carga desta
                    visita, antes de qualquer alteração. */}
                {podeRestaurarValoresIniciais && (
                  <div className="flex justify-center -mt-3">
                    <button
                      type="button"
                      onClick={restaurarValoresIniciais}
                      title="Volta % Ajustes, Valor Base Empresa, Valor Final da Proposta e os % de comissão para os valores de quando você entrou nesta tela"
                      className="flex items-center gap-2 px-4 py-2 text-xs font-semibold rounded-full border border-primary/30 text-primary bg-white/60 dark:bg-white/10 hover:bg-primary/10 transition-colors"
                    >
                      <RotateCcw size={14} />
                      Restaurar Valores Iniciais
                    </button>
                  </div>
                )}

                {/* Aviso quando Valor Final da Proposta < Valor Base Empresa */}
                {(() => {
                  // Mesma base mostrada no card "Valor Base Empresa" logo
                  // abaixo - travada no modo Lucro da Empresa. Comparar contra
                  // a base sem comissão (live, sempre crescente/decrescente a
                  // cada edição de valorProposta) dava falso positivo, porque
                  // essa base para de acompanhar o ajuste no modo Lucro da
                  // Empresa (valorProposta fica congelado de propósito).
                  const valorBaseEmpresa =
                    precoVendaSemComissaoOriginalRef.current ??
                    preco_venda_sem_comissao ??
                    0;
                  // "Valor Final da Proposta" já é o preco_venda (live) do
                  // card logo abaixo - comparar direto com ele, sem recalcular
                  // com valorProposta (que fica parado no modo Lucro da
                  // Empresa e gerava um "abaixo do Valor Base Empresa" falso
                  // mesmo estando em acréscimo).
                  if (preco_venda < valorBaseEmpresa) {
                    return (
                      <div className="w-full max-w-5xl -mt-2 mb-1">
                        <div className="flex flex-row items-center gap-3 bg-yellow-100 dark:bg-yellow-900/30 border-l-4 border-yellow-500 px-4 py-3 rounded-md shadow-sm">
                          <svg
                            xmlns="http://www.w3.org/2000/svg"
                            viewBox="0 0 24 24"
                            fill="currentColor"
                            className="w-6 h-6 text-yellow-600 dark:text-yellow-400 flex-shrink-0"
                          >
                            <path
                              fillRule="evenodd"
                              d="M10.29 3.86c.77-1.33 2.65-1.33 3.42 0l8.14 14.04c.75 1.3-.21 2.94-1.71 2.94H3.86c-1.5 0-2.46-1.64-1.71-2.94L10.29 3.86zM12 9a.75.75 0 01.75.75v4.5a.75.75 0 01-1.5 0v-4.5A.75.75 0 0112 9zm0 8a.75.75 0 100 1.5.75.75 0 000-1.5z"
                              clipRule="evenodd"
                            />
                          </svg>
                          <div className="text-md font-medium text-yellow-800 dark:text-yellow-300">
                            <span className="font-bold">ATENÇÃO!!</span> O{" "}
                            <span className="font-bold">
                              Valor Final da Proposta
                            </span>{" "}
                            está abaixo do{" "}
                            <span className="font-bold">
                              Valor Base Empresa
                            </span>
                            .<br />
                          </div>
                        </div>
                      </div>
                    );
                  }
                  return null;
                })()}

                {/* Cards de Valores */}
                <div className="flex flex-wrap justify-center gap-4 w-full">
                  {usuario.visualiza_custo_kit_usuario == "1" && (
                    <div className="flex-1 min-w-[300px] bg-white dark:bg-gray-800 rounded-xl shadow-md hover:shadow-lg transition-all duration-300 p-5 border border-gray-100 dark:border-gray-700">
                      <div className="flex flex-col items-center gap-2">
                        <span className="text-sm font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wide">
                          Custo do Kit
                        </span>
                        <span className="text-2xl font-bold text-gray-900 dark:text-white">
                          {formatarValor(valor_kit)}
                        </span>
                      </div>
                    </div>
                  )}
                  {usuario?.visualiza_valor_base_proposta_usuario == "1" && (
                    <div className="flex-1 min-w-[300px] bg-gradient-to-br from-primary/10 to-primary/5 dark:from-primary/20 dark:to-primary/10 rounded-xl shadow-md hover:shadow-lg transition-all duration-300 p-5 border border-primary/20">
                      <div className="flex flex-col items-center gap-2">
                        <span className="text-sm font-medium text-primary uppercase tracking-wide">
                          Valor Base Empresa{" "}
                        </span>
                        {/* VALOR BASE EMPRESA nunca muda: é sempre a base
                            ORIGINAL da política (congelada na primeira
                            resposta do cálculo), em qualquer configuração de
                            loja. Quem reflete o ajuste é o "Valor Base
                            Referência" logo abaixo. Antes, quando
                            acaoValorFinalProposta_loja == "1", este número caía
                            no preco_venda_sem_comissao AO VIVO e se mexia junto
                            com o "% Ajustes". */}
                        <span className="text-2xl font-bold text-primary">
                          {formatarValor(
                            precoVendaSemComissaoOriginalRef.current ??
                              preco_venda_sem_comissao
                          )}
                        </span>
                        {/* Sempre visível, em qualquer combinação de
                            "Calcular a Comissão por" x "Quando Alterado o
                            Valor Final na Proposta" - preco_venda_final_sem_comissao
                            é literalmente o valor usado no cálculo (base
                            natural quando nada foi sobrescrito, ou o alvo
                            resolvido via lucro_total_ajuste / Ajuste do Valor
                            Base Empresa quando foi). */}
                        <div className="flex flex-col items-center border-t border-primary/20 pt-2 mt-1 w-full">
                          <span className="text-xs font-medium text-primary/70 uppercase tracking-wide">
                            Valor Base Referência
                          </span>
                          <span className="text-sm font-semibold text-primary/90">
                            {formatarValor(preco_venda_final_sem_comissao)}
                          </span>
                        </div>
                      </div>
                    </div>
                  )}
                  {
                    <div className="flex-1 min-w-[300px] bg-gradient-to-br from-success/10 to-success/5 dark:from-success/20 dark:to-success/10 rounded-xl shadow-md hover:shadow-lg transition-all duration-300 p-5 border border-success/20">
                      <div className="flex flex-col items-center gap-2">
                        <span className="text-sm font-medium text-success uppercase tracking-wide text-center">
                          Valor Final da Proposta
                        </span>
                        <span className="text-2xl font-bold text-success">
                          {/* {formatarValor(
                            (() => {
                              const baseFromState = Number(valorProposta);
                              const baseFromForm = (() => {
                                try {
                                  const v =
                                    form?.getValues("valorFinalProposta");
                                  return v
                                    ? +FormatFields.desformatarNumeros(v)
                                    : NaN;
                                } catch (e) {
                                  return NaN;
                                }
                              })();
                              const baseFallback =
                                Number.isFinite(baseFromState) &&
                                !isNaN(baseFromState)
                                  ? baseFromState
                                  : Number.isFinite(baseFromForm) &&
                                      !isNaN(baseFromForm)
                                    ? baseFromForm
                                    : resultadoPrecificacao?.preco_venda_sem_comissao ||
                                      0;

                              const commission = Number.isFinite(
                                valorComissaoCalculado
                              )
                                ? valorComissaoCalculado
                                : 0;

                              return baseFallback + commission;
                            })()
                          )} */}
                          {formatarValor(preco_venda)}
                        </span>
                      </div>
                      {/* Oculto quando "Calcular a Comissão por" = "Valor Base
                          Empresa": nesse modo o Valor Final é resultado da
                          comissão sobre a base, então só "Ajuste do Valor Base
                          Empresa"/"% Ajustes" podem ser editados. */}
                      {!ocultarAjusteValorFinal && (
                        <Input
                          name="ajusteValorFinalProposta_formatado"
                          // label={`Ajuste do Valor Final da Proposta`}
                          label={
                            <span className="flex items-center gap-1">
                              Ajuste do Valor Final da Proposta
                              <button
                                type="button"
                                className="hover:text-primary cursor-pointer p-1 rounded"
                                onClick={(e: any) => {
                                  e.stopPropagation();
                                  handleSweetAlert({
                                    icon: "warning",
                                    title: "ATENÇÃO!!",
                                    showDenyButton: false,
                                    confirmButtonText: "Ok",
                                    html: htmlInfoAjusteValorFinal(),
                                  });
                                }}
                              >
                                <Info size={16} />
                              </button>
                            </span>
                          }
                          mascara="numero"
                          onBlur={(e) => {
                            // form.setValue(
                            //   "ajusteValorFinalProposta",
                            //   +FormatFields.desformatarNumeros(e?.target?.value)
                            // );
                            const novoValor = +FormatFields.desformatarNumeros(
                              e?.target?.value
                            );
                            const semMargemNenhuma =
                              maxDescontoPercent == 0 &&
                              maxAcrescimoPercent == 0;
                            const pontoNormalAtual =
                              precoVendaComComissaoOriginalRef.current ??
                              novoValor;
                            const mudouDeVerdade =
                              Math.abs(novoValor - pontoNormalAtual) > 0.01;

                            if (semMargemNenhuma && mudouDeVerdade) {
                              handleSweetAlert({
                                icon: "warning",
                                title: "ATENÇÃO!!",
                                html: `
                                  <div class="flex flex-col gap-2 text-left">
                                    ${linhaUsuarioLogado()}
                                    <div>Você não tem % de margem para mexer no "Valor Total da Proposta", caso prosseguir, o valor será descontado da Comissão do Vendedor.</div>
                                  </div>
                                `,
                              }).then((result: any) => {
                                if (result?.isConfirmed) {
                                  form.setValue("parametrosPrecificacao", {
                                    ...form.control._formValues
                                      ?.parametrosPrecificacao,
                                    termoAceiteSemMargemComissaoVendedor: true,
                                  });
                                  usuarioEditouAjusteRef.current = true;
                                  setAjusteValorFinalProposta(novoValor);
                                } else {
                                  // Cancelou - reverte o campo pro valor que já estava aplicado.
                                  form.setValue(
                                    "ajusteValorFinalProposta_formatado",
                                    FormatFields.formatarNumero(
                                      ajusteValorFinalProposta
                                    )
                                  );
                                }
                              });
                              return;
                            }

                            usuarioEditouAjusteRef.current = true;
                            setAjusteValorFinalProposta(novoValor);
                            // const percent =
                            //   +FormatFields.desformatarNumeros(e.target.value) / 100;
                            // // usar a base imutável quando disponível
                            // const base = Number(
                            //   resultadoSimulador?.preco_venda_sem_comissao || 0
                            // );
                            // const valor = base * percent;
                            // setValorProposta(valor);
                            // // não sobrescrever a base original (preco_venda_sem_comissao)
                            // // apenas atualizamos o valorProposta que serve como ajuste
                          }}
                          formulario={form}
                          // width={
                          //   maxDescontoPercent == 0 && maxAcrescimoPercent == 0
                          //     ? "hidden"
                          //     : undefined
                          // }
                          // Item 08: o Input nasce com bg-transparent e sumia
                          // dentro do card verde do "Valor Final da Proposta",
                          // parecendo um texto fixo. Fundo branco deixa claro
                          // que é um campo editável.
                          inputClassName="bg-white dark:bg-form-input"
                          prefix={"R$"}
                          // defaultValue={FormatFields.formatarNumero(preco_venda_aplicando_comissao)}
                        />
                      )}
                    </div>
                  }
                </div>

                {/* Campos de Input */}
                <div
                  className={`flex flex-${isMobile ? "col" : "row"} gap-4 w-full max-w-5xl items-end justify-center`}
                >
                  <div className="flex-1 min-w-[160px]">
                    <Input
                      name="porcentagemValorFinal"
                      label={
                        <span className="flex items-center gap-1">
                          {`% Ajustes ${
                            usuario?.visualiza_max_desconto_proposta_usuario ==
                              "1" &&
                            usuario?.visualiza_max_acrescimo_proposta_usuario ==
                              "1"
                              ? `(${formatarNumero(
                                  (1 - maxDescontoPercent / 100) * 100
                                )}-${formatarNumero(
                                  (1 + maxAcrescimoPercent / 100) * 100
                                )})`
                              : usuario?.visualiza_max_desconto_proposta_usuario ==
                                  "1"
                                ? `(${formatarNumero(
                                    (1 - maxDescontoPercent / 100) * 100
                                  )})`
                                : usuario?.visualiza_max_acrescimo_proposta_usuario ==
                                    "1"
                                  ? `(${formatarNumero(
                                      (1 + maxAcrescimoPercent / 100) * 100
                                    )})`
                                  : ""
                          }`}
                          {/* Item 04: nos casos 3 e 4 da planilha o "Ajuste do
                              Valor Final da Proposta" (e o "i" dele) fica
                              oculto - o texto de atenção vem pra cá, que é o
                              campo que o usuário edita nesses modos. */}
                          <button
                            type="button"
                            className="hover:text-primary cursor-pointer p-1 rounded"
                            onClick={(e: any) => {
                              e.stopPropagation();
                              handleSweetAlert({
                                icon: "warning",
                                title: "ATENÇÃO!!",
                                showDenyButton: false,
                                confirmButtonText: "Ok",
                                html: htmlInfoAjustePercentual(),
                              });
                            }}
                          >
                            <Info size={16} />
                          </button>
                        </span>
                      }
                      mascara="numero"
                      onBlur={(e) => {
                        const percent =
                          +FormatFields.desformatarNumeros(e.target.value) /
                          100;

                        // Referência de 100% ainda não carregada (preço zerado
                        // na primeira renderização): ignora a edição em vez de
                        // aplicar 0 e zerar a proposta.
                        if (!baseReferencia100Porcento) {
                          return;
                        }

                        // Blur sem edição nenhuma (usuário só deu Tab por cima
                        // do campo) tem que ser no-op absoluto.
                        //
                        // A comparação precisa ser na MESMA unidade em que o
                        // campo é exibido - % com 2 casas. O guard antigo
                        // comparava em dinheiro (R$ 0,01), e 0,005% (metade da
                        // última casa exibida, ou seja, invisível no campo) já
                        // vale R$ 1,05 numa base de R$ 20.980,83. Resultado: o
                        // primeiro Tab por cima do campo passava o guard,
                        // chamava setValorProposta e caía no ramo "voltou pro
                        // 100%" do efeito de valorProposta, que restaura todas
                        // as comissões da política - apagando o "Ajuste do
                        // Valor Final da Proposta" que o usuário tinha acabado
                        // de fazer.
                        const percentExibidoAtual = formatarNumero(
                          (valorProposta / baseReferencia100Porcento) * 100
                        );
                        const percentExibidoDigitado = formatarNumero(
                          +FormatFields.desformatarNumeros(e.target.value)
                        );
                        if (percentExibidoAtual === percentExibidoDigitado) {
                          return;
                        }

                        // usar sempre a base ORIGINAL (política pura), nunca a
                        // já ajustada - senão cada edição desconta em cima do
                        // desconto anterior e o valor cai infinitamente.
                        // Arredonda pra 2 casas aqui - senão o resto decimal
                        // (ex: 20141.04 * 0.9657 = 19448.19928...) se propaga
                        // pros cálculos seguintes e os campos nunca fecham
                        // exatamente iguais.
                        const valor = Number(
                          (baseReferencia100Porcento * percent).toFixed(2)
                        );
                        // não sobrescrever a base original (preco_venda_sem_comissao)
                        // apenas atualizamos o valorProposta que serve como ajuste -
                        // e só se o valor resultante realmente mudou, senão dispara
                        // o efeito de valorProposta à toa.
                        if (Math.abs(valor - valorProposta) > 0.01) {
                          aplicarValorBaseComConfirmacaoSeNoPiso(
                            valor,
                            (valorParaExibir) => {
                              form.setValue(
                                "porcentagemValorFinal",
                                formatarNumero(
                                  (valorParaExibir /
                                    baseReferencia100Porcento) *
                                    100
                                )
                              );
                              form.setValue(
                                "valorFinalProposta",
                                formatarNumero(valorParaExibir)
                              );
                            }
                          );
                        }
                      }}
                      formulario={form}
                      width={
                        maxDescontoPercent == 0 && maxAcrescimoPercent == 0
                          ? "hidden"
                          : undefined
                      }
                    />
                  </div>
                  {maxDescontoPercent > 0 || maxAcrescimoPercent > 0 ? (
                    <>
                      <div
                        className={`flex-1 min-w-[160px] ${usuario?.visualiza_valor_base_proposta_usuario != "1" && "hidden"}`}
                      >
                        <Input
                          name="valorFinalProposta"
                          label={"Ajuste do Valor Base Empresa"}
                          mascara="numero"
                          onBlur={(e) => {
                            const valor = +FormatFields.desformatarNumeros(
                              e.target.value
                            );
                            // Blur sem edição (só Tab por cima) tem que ser
                            // no-op - este handler chamava aplicarValorBase...
                            // incondicionalmente, e reaplicar a mesma base já
                            // era suficiente pra disparar o efeito de
                            // valorProposta. Compara na unidade exibida (R$
                            // com 2 casas), não no float cru: a diferença
                            // sub-centavo é invisível no campo mas passava.
                            if (
                              formatarNumero(valor) ===
                              formatarNumero(valorProposta)
                            ) {
                              return;
                            }
                            aplicarValorBaseComConfirmacaoSeNoPiso(
                              valor,
                              (valorParaExibir) => {
                                form.setValue(
                                  "valorFinalProposta",
                                  formatarNumero(valorParaExibir)
                                );
                                form.setValue(
                                  "porcentagemValorFinal",
                                  formatarNumero(
                                    (valorParaExibir /
                                      baseReferencia100Porcento) *
                                      100
                                  )
                                );
                              }
                            );

                            // // Calcular a porcentagem baseada na base imutável
                            // const baseRef = preco_venda_final_sem_comissao;
                            // if (baseRef) {
                            //   const porcentagem = (valor / baseRef) * 100;
                            //   form.setValue(
                            //     "porcentagemValorFinal",
                            //     formatarNumero(porcentagem)
                            //   );
                            // }
                          }}
                          prefix={"R$"}
                          formulario={form}
                        />
                      </div>
                      <div className="flex-1 min-w-[160px]">
                        {(() => {
                          const precoFinalBase = preco_venda_sem_comissao || 0;

                          const valorFinalSalvo =
                            form.getValues("valorFinalProposta");
                          const valorFinalNumerico: any =
                            valorFinalSalvo && valorFinalSalvo !== "0,00"
                              ? +FormatFields.desformatarNumeros(
                                  valorFinalSalvo
                                )
                              : typeof valorProposta === "number" &&
                                  !isNaN(valorProposta)
                                ? valorProposta
                                : null;

                          if (valorFinalNumerico === null) return null;

                          const ajusteValor = ajusteValorBase;
                          const ajustePercent =
                            precoFinalBase > 0
                              ? (ajusteValor / precoFinalBase) * 100
                              : 0;

                          // Determinar cores: Verde=acréscimo, Vermelho=desconto, Azul=sem alteração
                          const isDesconto = ajusteValor < 0;
                          const isAcrescimo = ajusteValor > 0;
                          const semAlteracao = ajusteValor == 0;

                          let borderColor =
                            "border-gray-300 dark:border-gray-600";
                          let textColor = "text-gray-900 dark:text-gray-100";
                          let labelColor = "text-gray-600 dark:text-gray-400";
                          let iconColor = "text-gray-600 dark:text-gray-400";

                          if (isDesconto) {
                            borderColor = "border-red-300 dark:border-red-600";
                            textColor = "text-red-700 dark:text-red-400";
                            labelColor = "text-red-600 dark:text-red-500";
                            iconColor = "text-red-600 dark:text-red-500";
                          } else if (isAcrescimo) {
                            borderColor =
                              "border-green-300 dark:border-green-600";
                            textColor = "text-green-700 dark:text-green-400";
                            labelColor = "text-green-600 dark:text-green-500";
                            iconColor = "text-green-600 dark:text-green-500";
                          } else if (semAlteracao) {
                            borderColor =
                              "border-blue-300 dark:border-blue-600";
                            textColor = "text-blue-700 dark:text-blue-400";
                            labelColor = "text-blue-600 dark:text-blue-500";
                            iconColor = "text-blue-600 dark:text-blue-500";
                          }

                          return (
                            <div className="flex-1 min-w-[160px]">
                              <label className="mb-2.5 block text-black dark:text-white text-sm font-medium">
                                Ajuste Aplicado (Valor Base)
                              </label>
                              <div
                                className={`relative w-full rounded-lg border-2 ${borderColor} bg-white dark:bg-gray-800 py-3 px-4 font-semibold outline-none transition focus:border-primary shadow-sm flex items-center gap-2 h-11`}
                              >
                                {isDesconto ? (
                                  <svg
                                    xmlns="http://www.w3.org/2000/svg"
                                    className={`h-5 w-5 flex-shrink-0 ${iconColor}`}
                                    viewBox="0 0 20 20"
                                    fill="currentColor"
                                  >
                                    <path
                                      fillRule="evenodd"
                                      d="M5 10a1 1 0 011-1h8a1 1 0 110 2H6a1 1 0 01-1-1z"
                                      clipRule="evenodd"
                                    />
                                  </svg>
                                ) : isAcrescimo ? (
                                  <svg
                                    xmlns="http://www.w3.org/2000/svg"
                                    className={`h-5 w-5 flex-shrink-0 ${iconColor}`}
                                    viewBox="0 0 20 20"
                                    fill="currentColor"
                                  >
                                    <path
                                      fillRule="evenodd"
                                      d="M10 5a1 1 0 011 1v3h3a1 1 0 110 2h-3v3a1 1 0 11-2 0v-3H6a1 1 0 110-2h3V6a1 1 0 011-1z"
                                      clipRule="evenodd"
                                    />
                                  </svg>
                                ) : (
                                  <svg
                                    xmlns="http://www.w3.org/2000/svg"
                                    className={`h-5 w-5 flex-shrink-0 ${iconColor}`}
                                    viewBox="0 0 20 20"
                                    fill="currentColor"
                                  >
                                    <path
                                      fillRule="evenodd"
                                      d="M10 18a8 8 0 100-16 8 8 0 000 16zm0-2a6 6 0 100-12 6 6 0 000 12z"
                                      clipRule="evenodd"
                                    />
                                  </svg>
                                )}
                                <div className="flex flex-col gap-0">
                                  <span
                                    className={`text-xs uppercase font-semibold leading-tight ${labelColor}`}
                                  >
                                    {isDesconto
                                      ? "Desconto"
                                      : isAcrescimo
                                        ? "Acréscimo"
                                        : "Sem Alt."}
                                  </span>
                                  <span
                                    className={`text-sm font-bold leading-tight ${textColor}`}
                                  >
                                    {formatarValor(ajusteValor)}{" "}
                                    {!isNaN(ajustePercent) &&
                                      `${
                                        isDesconto
                                          ? "-"
                                          : isAcrescimo
                                            ? "+"
                                            : ""
                                      }${formatarNumero(
                                        Math.abs(ajustePercent)
                                      )}%`}
                                  </span>
                                </div>
                              </div>
                            </div>
                          );
                        })()}
                      </div>
                    </>
                  ) : null}
                </div>
                {/* Ajuste Aplicado - card pequeno e centralizado abaixo dos inputs */}

                {/* Limites de Desconto e Acréscimo */}
                <div className="flex flex-wrap justify-center gap-4 w-full">
                  {usuario?.visualiza_max_desconto_proposta_usuario == "1" && (
                    <Tooltip
                      title={
                        temLimiteDescontoUsuario
                          ? "O valor Mínimo que o Valor Final da Proposta pode chegar quando aplicado o valor máximo de desconto junto dos valores mínimos de comissões"
                          : 'O valor Mínimo que o "Valor Final da Proposta" pode chegar quando zerada a comissão do Vendedor, mantendo as demais comissões da política'
                      }
                    >
                      <div className="flex-1 min-w-[200px] bg-red-50 dark:bg-red-900/20 rounded-xl shadow-sm p-5 border-l-4 border-red-500">
                        <div className="flex flex-col items-center gap-2">
                          <div className="flex items-center gap-2">
                            <svg
                              className="w-5 h-5 text-red-500"
                              fill="none"
                              stroke="currentColor"
                              viewBox="0 0 24 24"
                            >
                              <path
                                strokeLinecap="round"
                                strokeLinejoin="round"
                                strokeWidth={2}
                                d="M19 14l-7 7m0 0l-7-7m7 7V3"
                              />
                            </svg>
                            <span className="text-sm font-medium text-red-700 dark:text-red-400 uppercase tracking-wide">
                              Desconto Máximo
                            </span>
                            <button
                              type="button"
                              className="hover:text-primary cursor-pointer p-1 rounded"
                              onClick={(e: any) => {
                                e.stopPropagation();
                                handleSweetAlert({
                                  icon: "info",
                                  title: "Como o Desconto Máximo é calculado",
                                  showDenyButton: false,
                                  confirmButtonText: "Ok",
                                  html: `
                                    <div class="flex flex-col gap-2 text-left">
                                      ${linhaUsuarioLogado()}
                                      <div class="italic">
                                        ${
                                          usuario?.visualiza_valor_base_proposta_usuario !=
                                          "1"
                                            ? `Desconto Máximo = Valor Final da Proposta no menor valor permitido (escala com comissão, igual "Ajuste do Valor Final da Proposta") = ${formatarValor(descontoMaximoExibido)}`
                                            : temLimiteDescontoUsuario
                                              ? `Desconto Máximo = Valor Base Empresa original × (1 - ${formatarNumero(maxDescontoPercent)}% de desconto máximo) = ${formatarValor(descontoMaximoExibido)} e zerando todas os percentuais de comissões`
                                              : `Desconto Máximo = Total Mínimo para a Venda (original, sem nenhum ajuste), ${formatarValor(descontoMaximoExibido)} - preço com a comissão do Vendedor a 0%, mantendo as demais comissões da política.`
                                        }
                                      </div>
                                    </div>
                                  `,
                                });
                              }}
                            >
                              <Info size={16} />
                            </button>
                          </div>
                          <span className="text-xl font-bold text-red-600 dark:text-red-400">
                            {formatarValor(descontoMaximoExibido)}
                          </span>
                        </div>
                      </div>
                    </Tooltip>
                  )}
                  {usuario?.visualiza_max_acrescimo_proposta_usuario == "1" && (
                    <Tooltip
                      title={
                        mostrarAcrescimoReferencia
                          ? 'Acréscimo Máximo: o valor Máximo que o Valor Final da Proposta pode chegar quando aplicado o valor máximo de acréscimo ("% Ajustes" no topo do range) junto dos valores máximos de comissões. Acréscimo Referência: o teto usado nos cálculos agora, com o Valor Base Empresa atual e todos os % de comissão cheios - é ele que limita o "Ajuste do Valor Final da Proposta".'
                          : "O valor Máximo que o Valor Final da Proposta pode chegar quando aplicado o valor máximo de acréscimo junto dos valores máximos de comissões"
                      }
                    >
                      <div className="flex-1 min-w-[200px] bg-green-50 dark:bg-green-900/20 rounded-xl shadow-sm p-5 border-l-4 border-green-500">
                        <div className="flex flex-col items-center gap-2">
                          <div className="flex items-center gap-2">
                            <svg
                              className="w-5 h-5 text-green-500"
                              fill="none"
                              stroke="currentColor"
                              viewBox="0 0 24 24"
                            >
                              <path
                                strokeLinecap="round"
                                strokeLinejoin="round"
                                strokeWidth={2}
                                d="M5 10l7-7m0 0l7 7m-7-7v18"
                              />
                            </svg>
                            <span className="text-sm font-medium text-green-700 dark:text-green-400 uppercase tracking-wide">
                              Acréscimo Máximo
                            </span>
                          </div>
                          <span className="text-xl font-bold text-green-600 dark:text-green-400">
                            {formatarValor(acrescimoMaximoExibido)}
                          </span>
                          {/* Item 07 - "Acréscimo Referência": mesma estrutura
                              do "Valor Base Referência" no card da base. O
                              número grande é o teto ABSOLUTO da tela ("% Ajustes"
                              no topo do range + comissões cheias); esta linha é o
                              teto EFETIVO sobre a base atual - o valor que os
                              cálculos usam e que trava o campo. */}
                          {mostrarAcrescimoReferencia && (
                            <div className="flex flex-col items-center border-t border-green-500/20 pt-2 mt-1 w-full">
                              <span className="text-xs font-medium text-green-700/70 dark:text-green-400/70 uppercase tracking-wide">
                                Acréscimo Referência
                              </span>
                              <span className="text-sm font-semibold text-green-600/90 dark:text-green-400/90">
                                {formatarValor(limiteMaximoAjuste)}
                              </span>
                            </div>
                          )}
                        </div>
                      </div>
                    </Tooltip>
                  )}
                  {(() => {
                    // Não faz sentido em modo "Lucro da Empresa": o vendedor
                    // fica travado e não participa desse ajuste.
                    if (
                      !valorAjusteTotal ||
                      String(acaoValorFinalProposta_loja) !== "1"
                    )
                      return null;

                    const ajusteValor = valorAjusteTotal;
                    const ajustePercent =
                      valorAjusteTotal > 0
                        ? (ajusteValor / preco_venda) * 100
                        : 0;

                    // Determinar cores: Verde=acréscimo, Vermelho=desconto, Azul=sem alteração
                    const isDesconto = ajusteValor < 0;
                    const isAcrescimo = ajusteValor > 0;
                    const semAlteracao = ajusteValor == 0;

                    let borderColor = "border-gray-300 dark:border-gray-600";
                    let textColor = "text-gray-900 dark:text-gray-100";
                    let labelColor = "text-gray-600 dark:text-gray-400";
                    let iconColor = "text-gray-600 dark:text-gray-400";

                    if (isDesconto) {
                      borderColor = "border-red-300 dark:border-red-600";
                      textColor = "text-red-700 dark:text-red-400";
                      labelColor = "text-red-600 dark:text-red-500";
                      iconColor = "text-red-600 dark:text-red-500";
                    } else if (isAcrescimo) {
                      borderColor = "border-green-300 dark:border-green-600";
                      textColor = "text-green-700 dark:text-green-400";
                      labelColor = "text-green-600 dark:text-green-500";
                      iconColor = "text-green-600 dark:text-green-500";
                    } else if (semAlteracao) {
                      borderColor = "border-blue-300 dark:border-blue-600";
                      textColor = "text-blue-700 dark:text-blue-400";
                      labelColor = "text-blue-600 dark:text-blue-500";
                      iconColor = "text-blue-600 dark:text-blue-500";
                    }

                    return (
                      <Tooltip
                        title={
                          "Quanto o Ajuste do Valor Final da Proposta está abaixo (desconto) ou acima (acréscimo) do preço padrão da política - o mesmo valor mostrado na mensagem embaixo do campo. Sai da comissão do Vendedor."
                        }
                      >
                        <div
                          className={
                            isAcrescimo
                              ? "w-full sm:w-[260px] bg-green-50 dark:bg-green-900/20 rounded-xl shadow-sm p-5 border-l-4 border-green-500"
                              : "w-full sm:w-[260px] bg-red-50 dark:bg-red-900/20 rounded-xl shadow-sm p-5 border-l-4 border-red-500"
                          }
                        >
                          <div className="flex flex-col items-center gap-2">
                            <div className="flex items-center gap-2">
                              <svg
                                className={`w-5 h-5 text-${isAcrescimo ? "green" : "red"}-500`}
                                fill="none"
                                stroke="currentColor"
                                viewBox="0 0 24 24"
                              >
                                <path
                                  strokeLinecap="round"
                                  strokeLinejoin="round"
                                  strokeWidth={2}
                                  d={
                                    isAcrescimo
                                      ? "M5 10l7-7m0 0l7 7m-7-7v18"
                                      : "M19 14l-7 7m0 0l-7-7m7 7V3"
                                  }
                                />
                              </svg>
                              <span
                                className={
                                  isAcrescimo
                                    ? "text-sm font-medium text-green-700 dark:text-green-400 uppercase tracking-wide"
                                    : "text-sm font-medium text-red-700 dark:text-red-400 uppercase tracking-wide"
                                }
                              >
                                {`${
                                  isDesconto
                                    ? "Desconto"
                                    : isAcrescimo
                                      ? "Acréscimo"
                                      : "Sem Alt."
                                } (Comissão Vendedor)`}
                              </span>
                            </div>
                            <span
                              className={
                                isAcrescimo
                                  ? `text-xl font-bold text-green-600 dark:text-green-400`
                                  : `text-xl font-bold text-red-600 dark:text-red-400`
                              }
                            >
                              {formatarValor(valorAjusteTotal)}
                            </span>
                          </div>
                        </div>
                      </Tooltip>
                    );
                  })()}
                </div>

                {/* Mensagem de Erro */}
                {descontoAcrescimoError && (
                  <div className="w-full max-w-3xl">
                    <div className="bg-red-50 dark:bg-red-900/20 border-l-4 border-red-500 rounded-lg p-4 shadow-sm">
                      <div className="flex items-center gap-3">
                        <svg
                          className="w-6 h-6 text-red-500 flex-shrink-0"
                          fill="none"
                          stroke="currentColor"
                          viewBox="0 0 24 24"
                        >
                          <path
                            strokeLinecap="round"
                            strokeLinejoin="round"
                            strokeWidth={2}
                            d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
                          />
                        </svg>
                        <span className="text-red-700 dark:text-red-400 font-medium">
                          {descontoAcrescimoError}
                        </span>
                      </div>
                    </div>
                  </div>
                )}

                {/* Checkbox de Confirmação */}
                {[
                  c_vendedor,
                  c_pre_vendedor,
                  c_gerente,
                  c_indicacao,
                  c_indicacao_bruto,
                  valor_comissao,
                ].every((val) => val == 0) && (
                  <div className="w-full max-w-3xl">
                    <div
                      className={`rounded-xl p-5 shadow-sm border-2 transition-all duration-300 ${
                        confirmaAvancoComissao
                          ? "bg-green-50 dark:bg-green-900/20 border-green-500"
                          : "bg-yellow-50 dark:bg-yellow-900/20 border-yellow-500"
                      }`}
                    >
                      <Input
                        name="confirmaAvancoComissao"
                        label="Confirmar que a Proposta não possui Comissão"
                        labelSize={`text-lg font-semibold transition-all ${confirmaAvancoComissao ? "text-green-700 dark:text-green-400" : "text-yellow-700 dark:text-yellow-400"}`}
                        type="checkbox"
                        onChange={(e) =>
                          setConfirmaAvancoComissao(e.target.checked)
                        }
                      />
                    </div>
                  </div>
                )}
              </div>
            </div>
            <ResultadoPrecificacao
              // valorAplicacaoComissao={valorAplicacaoComissao}
              // form={form}
              resultadoPrecificacao={resultadoPrecificacao}
              setParametrosPrecificacao={(parametros: any) =>
                atualizarResultadoPrecificacao(parametros)?.then(
                  (dadosPreco) => {
                    // Editar uma % de comissão direto no quadro de Comissões
                    // (ex: "% Vendedor") muda o Valor Final na prática, mas
                    // não passa pelo Effect do "Ajuste do Valor Final da
                    // Proposta" - sem isso, o campo ficava mostrando o alvo
                    // de uma edição anterior, divergindo do card "Valor Final
                    // da Proposta" (que já é esse mesmo dadosPreco.preco_venda).
                    if (
                      dadosPreco &&
                      Math.abs(
                        dadosPreco.preco_venda - ajusteValorFinalProposta
                      ) > 0.01
                    ) {
                      setAjusteValorFinalProposta(dadosPreco.preco_venda);
                      form.setValue(
                        "ajusteValorFinalProposta_formatado",
                        FormatFields.formatarNumero(dadosPreco.preco_venda)
                      );
                    }
                  }
                )
              }
              // No modo "Lucro da Empresa" o valorProposta fica desacoplado
              // do cálculo real (quem move a base é lucro_total_ajuste via
              // "Valor Base Referência") - ajusteValorBase não representa mais
              // uma divergência real, só ruído. O ajuste já aparece embutido
              // em "LUCRO NO TOTAL".
              valorAjusteTotal={
                String(acaoValorFinalProposta_loja) === "1"
                  ? ajusteValorBase
                  : 0
              }
            />
            <div className="mt-4">{camposPersonalizados}</div>
          </div>
        ) : (
          <div onClick={() => {}}>Não foi encontrado política de preço</div>
        )
      ) : (
        <div className="flex justify-center">
          <LoaderSun />
        </div>
      )}
    </>
  );
};

export default PrecificacaoProposta;