"use client";

import LoaderSun from "@/components/common/Loader/LoaderSun";
import Button from "@/components/Forms/Button";
import { handleSweetAlert } from "@/components/Modal/SweetAlertConfirm";
import { listarOrientacoesSolares } from "@/requests/common/OrientacoesSolares/listarInclinacoesTelhado";
import { buscaTensaoProjetoOrigem } from "@/requests/CRUD/ColetaDados/editarColeta";
import { useScreenContext } from "@/src/contexts/ScreenContext";
import {
  formatarValor,
  FormatFields,
  getDateBrasil,
  getDateTimeBrasil,
} from "@/utils";
import {
  aplicarAumentoConsumo,
  obterPorcentagemAumentoConsumo,
} from "@/utils/calcularConsumoComAumento";
import { calcMonthly, calcTotalConsumo } from "@/utils/calcules";
import {
  formatarLinhaPolitica,
  IOrigemDadosDefault,
  origemDadosConfiguracaoGeral,
  ParametrosPoliticaVigente,
} from "@/utils/origemDadosDefault";
import html2canvas from "html2canvas";
import jsPDF from "jspdf";
import katex from "katex";
import { FileDown, InfoIcon, Printer } from "lucide-react";
import dynamic from "next/dynamic";
import { useEffect, useMemo, useRef, useState } from "react";
import { useReactToPrint } from "react-to-print";
import Swal from "sweetalert2";

const ReactApexChart = dynamic(() => import("react-apexcharts"), {
  ssr: false,
});
declare global {
  interface Window {
    Apex?: any;
  }
}
// interface ChartState {
//   series: Array<{ name: string; data: number[] }>;
// }

export default function ResumoProposta({
  origem,
  tarifasEnergia,
  cod_coleta,
  form,
  performance_ratio_parametro,
  media_irradiacao_mensal,
  sombreamentos_coleta,
  perdaMedia,
  estimativa_geracao_cliente,
  fabricanteModulo,
  tipoNegocio_coleta,
  isLoadedResumo,
  refResultSimulador,
  tipo_ampliacao,
  dadosAmpliacao,
  proposta,
  id_coleta,
  tipo_kit,
  nome_distribuidor,
  lastProposalInfo,
  nome_telhado,
  validade_proposta,
  data_geracao_proposta,
  nome_usuario,
  valor_simultaneidade_proposta,
  qtd_visualizacoes_proposta,
  obs_proposta,
  valorTotal_proposta,
  preco_tarifa,
  valor_desconto,
  valor_total_sem_desconto,
  valor_acrescimo,
  valor_total_sem_acrescimo,
  payback,
  potencia_sistema,
  nome_concessisonaria,
  nome_tipoLigacao_proposta,
  grupo_proposta,
  subgrupo_proposta,
  ucs,
  consumoTotal,
  estimativa_geracao,
  abatimento,
  abatimentoCliente,

  qtd_modulos,
  fiob_tarifa,
  potencia_modulo,
  modulo,
  fabricantes,
  area_ocupada,
  apexOptionsGraficoGeracao,
  apexSeriesGraficoGeracao,
  apexOptionsGraficoRsi,
  apexSeriesGraficoRsi,
  area_modulo,
  inversores_proposta,
  consumoAmpliacao_cliente,
  distribuicaoDosModulos,
  // qtd_min_modulos,
  // qtd_max_modulos,
  tabela_rsi,
  obs_negocio,
  percentual_aumento_consumo,
  consumo_medio_real,
  seguro_percentual,
  origem_dados_default,
  parametros_politica_vigente,
}: {
  origem?: string;
  parametros_politica_vigente?: ParametrosPoliticaVigente | null;
  tarifasEnergia?: any;
  form?: any;
  abatimentoCliente?: any;
  cod_coleta?: any;
  consumoAmpliacao_cliente?: any;
  estimativa_geracao_cliente?: any;
  origem_dados_default?: IOrigemDadosDefault;
  performance_ratio_parametro?: any;
  media_irradiacao_mensal?: any;
  sombreamentos_coleta?: any;
  perdaMedia?: any;
  fabricanteModulo?: any;
  tipo_ampliacao?: any;
  dadosAmpliacao?: any;
  isLoadedResumo?: any;
  lastProposalInfo?: any;
  proposta?: any;
  id_coleta?: any;
  tipo_kit?: any;
  nome_distribuidor?: any;
  nome_telhado?: any;
  validade_proposta?: any;
  data_geracao_proposta?: any;
  refResultSimulador?: any;
  nome_usuario?: any;
  valor_simultaneidade_proposta?: any;
  qtd_visualizacoes_proposta?: any;
  obs_proposta?: any;
  valorTotal_proposta?: any;
  preco_tarifa?: any;
  valor_desconto?: any;
  valor_total_sem_desconto?: any;
  valor_acrescimo?: any;
  valor_total_sem_acrescimo?: any;
  payback?: any;
  potencia_sistema?: any;
  nome_concessisonaria?: any;
  nome_tipoLigacao_proposta?: any;
  grupo_proposta?: any;
  subgrupo_proposta?: any;
  ucs?: any;
  consumoTotal?: any;
  estimativa_geracao?: any;
  abatimento?: any;
  qtd_modulos?: any;
  fiob_tarifa?: any;
  potencia_modulo?: any;
  modulo?: any;
  fabricantes?: any;
  area_ocupada?: any;
  apexOptionsGraficoGeracao?: any;
  apexSeriesGraficoGeracao?: any;
  apexOptionsGraficoRsi?: any;
  apexSeriesGraficoRsi?: any;
  area_modulo?: any;
  inversores_proposta?: any;
  tipoNegocio_coleta?: any;
  distribuicaoDosModulos?: any;
  // qtd_min_modulos: any;
  // qtd_max_modulos: any;
  tabela_rsi?: any;
  obs_negocio?: any;
  percentual_aumento_consumo?: any;
  consumo_medio_real?: any;
  seguro_percentual?: any;
}) {
  const rsi_table = [
    { title: "Ano", value: "ano", type: "year" },
    { title: "Geração anual [kWh]", value: "geracao_anual", type: "kWh" },
    { title: "Consumo direto [kWh]", value: "consumo_direto", type: "kWh" },
    { title: "Tarifa Energia Evitada", value: "tarifa_energia" },
    { title: "Receita Energia Evitada", value: "receita_energia" },
    { title: "Energia Injetada [kWh]", value: "energia_injetada", type: "kWh" },
    { title: "Tarifa SCEE", value: "tarifa_scee" },
    { title: "Receita SCEE", value: "receita_scee" },
    { title: "Receita Bruta", value: "receita_bruta" },
    { title: "Operação e Manutenção", value: "opex" },
    { title: "Seguro", value: "seguro" },
    { title: "Receita Líquida", value: "receita_liquida" },
    { title: "Fluxo de Caixa", value: "fluxo_caixa" },
  ];
  const { isMobile } = useScreenContext();
  const [componentesCliente, setComponentesCliente] = useState<any>([]);
  const [componentesModulosCliente, setComponentesModulosCliente] =
    useState<any>([]);
  const [orientacoesSolares, setOrientacoesSolares] = useState<any[]>([]);
  const [tensaoRedeOrigem, setTensaoRedeOrigem] = useState<string>("");
  const fioBTarifa = fiob_tarifa;

  function setKitsAmpliacaoManual() {
    setComponentesCliente([
      {
        tipo_item: "8",
        qtd_item: dadosAmpliacao.qtdInversores_ampliacao,
        potencia_item: dadosAmpliacao.potenciaInversores_ampliacao,
      },
    ]);
    setComponentesModulosCliente({
      qtd_item: dadosAmpliacao?.qtdModulos_ampliacao,
      potencia_item: dadosAmpliacao?.potenciaModulos_ampliacao,
    });
  }
  useEffect(() => {
    // Buscar orientações solares do banco
    listarOrientacoesSolares().then((res) => {
      setOrientacoesSolares(res);
    });
    async function fetchData() {
      if (tipoNegocio_coleta === "3") {
        setKitsAmpliacaoManual();
        // if (tipoNegocio_coleta === "3" && cod_coleta) {
      }
      // if (tipoNegocio_coleta === "3" && cod_coleta) {
      //   try {
      //     const res = await listarComponentesKitByKitId(
      //       Number(lastProposalInfo.kit_proposta)
      //     );
      //     setComponentesCliente(res.componentesKit);
      //     setComponentesModulosCliente(
      //       res.componentesKit.find((a: any) => a.tipo_item === "9")
      //     );
      //   } catch (e) {

      //     setKitsAmpliacaoManual();
      //   }
      // } else if (tipoNegocio_coleta === "3" && !cod_coleta) {
      //   setKitsAmpliacaoManual();
      // }
    }

    fetchData();
  }, []);

  useEffect(() => {
    if (tipoNegocio_coleta === "3" && lastProposalInfo?.id_coleta) {
      buscaTensaoProjetoOrigem({
        projetoRef_coleta: lastProposalInfo.id_coleta,
      })
        .then((res: any) => {
          if (res?.tensao_padrao) {
            setTensaoRedeOrigem(res.tensao_padrao);
          }
        })
        .catch(() => {
          setTensaoRedeOrigem("");
        });
    }
  }, [tipoNegocio_coleta, lastProposalInfo?.id_coleta]);

  const n = (v: any) => Number(v) || 0;

  // Função auxiliar para obter o nome da orientação
  const getOrientacaoNome = (codOrientacao: string) => {
    const orientacao = orientacoesSolares.find(
      (o: any) => o.id_orientacao === codOrientacao,
    );
    return orientacao?.nome_orientacao || codOrientacao;
  };

  const getFaseInversorLabel = (fase: any) => {
    const faseNormalizada = String(fase ?? "")
      .trim()
      .toLowerCase();
    if (faseNormalizada === "1" || faseNormalizada.includes("mono")) {
      return "Monofásico";
    }
    if (faseNormalizada === "2" || faseNormalizada.includes("bi")) {
      return "Bifásico";
    }
    if (faseNormalizada === "3" || faseNormalizada.includes("tri")) {
      return "Trifásico";
    }
    return "Não Informado";
  };

  const normalizeTabelaInversores = (lista: any[]) => {
    if (!Array.isArray(lista)) {
      return [];
    }

    return lista
      .filter((item: any) => {
        const nome = String(item?.descricao_item ?? item?.descricao ?? "")
          .trim()
          .toLowerCase();

        const isPlaceholderSemInversor =
          nome === "sem inversor" ||
          nome === "proposta sem inversores" ||
          nome === "proposta sem inversor";

        return !isPlaceholderSemInversor;
      })
      .map((item: any) => {
        const fabricanteId =
          item?.codFabricante_item ?? item?.cod_fabricante ?? item?.fabricante;

        const fabricanteNome =
          typeof fabricanteId === "string" &&
          Number.isNaN(Number(fabricanteId)) &&
          fabricanteId.trim() !== ""
            ? fabricanteId
            : (fabricantes.find(
                (a: any) => a.id_fabricante === Number(fabricanteId),
              )?.nome_fabricante ??
              fabricantes.find(
                (a: any) =>
                  a.id_fabricante ===
                  Number(dadosAmpliacao?.marcaInversores_ampliacao),
              )?.nome_fabricante ??
              "Não Informado");

        const fase =
          item?.fase ??
          item?.fases_item ??
          dadosAmpliacao?.faseInversores_ampliacao;

        return {
          qtd_item: item?.qtd_item ?? item?.qtd ?? "Não Informado",
          descricao_item:
            item?.descricao_item ??
            item?.descricao ??
            item?.nome ??
            "Não Informado",
          fabricante: fabricanteNome,
          modelo: item?.modelo ?? item?.modelo_item ?? "Não Informado",
          fase: getFaseInversorLabel(fase),
          potencia: item?.potencia ?? item?.potencia_item ?? "Não Informado",
          cpmin: item?.cpmin ?? item?.potenciaNominalMin_item ?? "",
          cpmax: item?.cpmax ?? item?.potenciaNominalMaxima_item ?? "",
        };
      });
  };

  const tabelaInversoresProposta = normalizeTabelaInversores(
    inversores_proposta || [],
  );
  const tabelaInversoresOrigem = normalizeTabelaInversores(
    (dadosAmpliacao?.tabela_inversores_origem as any[]) ||
      (componentesCliente || []).filter((c: any) => c.tipo_item === "8"),
  );

  const mergeInversores = (a: any[], b: any[]) => {
    const map = new Map<string, any>();
    const pushItem = (item: any) => {
      const key = `${item.descricao_item}||${item.modelo}||${item.fabricante}`;
      const existing = map.get(key);
      const qtd = Number(item.qtd_item) || 0;
      if (existing) {
        existing.qtd_item = Number(existing.qtd_item || 0) + qtd;
      } else {
        map.set(key, { ...item, qtd_item: qtd });
      }
    };
    (a || []).forEach(pushItem);
    (b || []).forEach(pushItem);
    return Array.from(map.values());
  };

  const renderTabelaInversores = (tabelaInversores: any[]) => {
    if (!tabelaInversores?.length) {
      return <div className="text-sm">Proposta sem Inversores</div>;
    }

    return (
      <div className="overflow-x-auto">
        <table className="min-w-[720px] w-full">
          <thead>
            <tr>
              <th className="p-2 text-center">Quantidade</th>
              <th className="p-2 text-center">Nome</th>
              <th className="p-2 text-center">Fabricante</th>
              <th className="p-2 text-center">Modelo</th>
              <th className="p-2 text-center">Fase</th>
              <th className="p-2 text-center">Potência</th>
            </tr>
          </thead>
          <tbody>
            {tabelaInversores.map((inversor: any, index: number) => (
              <tr key={`${inversor.descricao_item}-${index}`}>
                <td className="text-center px-2 py-1">
                  {inversor.qtd_item || inversor.qtd}
                </td>
                <td className="text-center px-2 py-1">
                  {inversor.descricao_item}
                </td>
                <td className="text-center px-2 py-1">{inversor.fabricante}</td>
                <td className="text-center px-2 py-1">{inversor.modelo}</td>
                <td className="text-center px-2 py-1">{inversor.fase}</td>
                <td className="text-center px-2 py-1">
                  {inversor.potencia !== "Não Informado"
                    ? `${inversor.potencia} kW`
                    : "Não Informado"}
                </td>
              </tr>
            ))}
          </tbody>
        </table>
      </div>
    );
  };

  // Estruturas are shown as a single label (see below);
  // removed table rendering and aggregation for estruturas.

  // Consumo

  const qtdModulosRange = useMemo(() => {
    const condicao =
      (tipoNegocio_coleta === "3" &&
        cod_coleta &&
        tipo_ampliacao?.value === "1" &&
        origem !== "view") ||
      tipoNegocio_coleta !== "3";

    if (!condicao || !inversores_proposta?.length || !potencia_modulo) {
      return { min: undefined, max: undefined };
    }

    return (inversores_proposta ?? []).reduce(
      (acc: { min: number; max: number }, inversor: any) => {
        const potenciaInversorW = parseFloat(inversor.potencia_item) * 1000;
        const underload = +inversor.underload_item / 100;
        const overload = +inversor.overload_item / 100;
        const potenciaModulo = +potencia_modulo;
        const qtdItem = parseInt(inversor.qtd_item) || 1;

        let minModulos = Math.floor(
          (potenciaInversorW * qtdItem * underload) / potenciaModulo,
        );
        let maxModulos = Math.floor(
          (potenciaInversorW * qtdItem * overload) / potenciaModulo,
        );

        if (inversor.tipoInversor_item === "micro_inversor") {
          let microMax = Math.floor(
            (potenciaInversorW * overload) / potenciaModulo,
          );
          microMax =
            microMax > +inversor.qtdModulos_max_item
              ? +inversor.qtdModulos_max_item
              : microMax;
          maxModulos = microMax * qtdItem;
        }

        return { min: acc.min + minModulos, max: acc.max + maxModulos };
      },
      { min: 0, max: 0 },
    );
  }, [
    tipoNegocio_coleta,
    cod_coleta,
    tipo_ampliacao?.value,
    origem,
    inversores_proposta,
    potencia_modulo,
  ]);
  const qtd_min_modulos = qtdModulosRange.min;
  const qtd_max_modulos = qtdModulosRange.max;

  const somaConsumos = ucs
    ?.filter((u: any) => u?.isAmpliacao_uc_coleta === "1")
    ?.map((uc: any) =>
      uc.tipoValor === "Mensal" ? calcMonthly(uc.valor) : Number(uc.valor) || 0,
    )
    .reduce((acc: number, cur: number) => acc + cur, 0);

  const labelTipoAmpliacao = useMemo(() => {
    if (!tipo_ampliacao) return "";
    if (typeof tipo_ampliacao === "object") {
      if (tipo_ampliacao.label) return tipo_ampliacao.label;
      if (tipo_ampliacao.value !== undefined) {
        const valueStr = String(tipo_ampliacao.value);
        if (valueStr === "0") return "Módulos";
        if (valueStr === "1") return "Módulos e Inversores";
        if (valueStr === "2") return "Outros";
        if (valueStr === "3") return "Bateria";
      }
    }
    const valStr = String(tipo_ampliacao);
    if (valStr === "0") return "Módulos";
    if (valStr === "1") return "Módulos e Inversores";
    if (valStr === "2") return "Outros";
    if (valStr === "3") return "Bateria";
    return valStr;
  }, [tipo_ampliacao]);

  // No Olhinho (origem === "view") não há "form"; usa o % e o consumo real
  // gravados na proposta como fallback.
  const porcentagemAumentoConsumo = obterPorcentagemAumentoConsumo(
    form?.control?._formValues?.porcentagemGeracao,
    percentual_aumento_consumo,
  );

  const consumoRealBase =
    consumo_medio_real !== undefined &&
    consumo_medio_real !== null &&
    consumo_medio_real !== ""
      ? Number(consumo_medio_real)
      : Number(consumoTotal);

  const consumoComAumento = aplicarAumentoConsumo(
    consumoRealBase,
    form?.control?._formValues?.porcentagemGeracao,
    percentual_aumento_consumo,
  );

  // Sombreamento, Performance Ratio e Seguro exibidos no resumo: na
  // geração/simulador prevalece o valor digitado no form; no Olhinho
  // (origem === "view") usa o que foi gravado na proposta.
  const sombreamentoResumo =
    form?.control?._formValues?.sombreamentos_coleta ?? sombreamentos_coleta;
  const performanceRatioBruto =
    form?.control?._formValues?.performance_ratio_parametro ??
    performance_ratio_parametro;
  const performanceRatioResumo =
    performanceRatioBruto && typeof performanceRatioBruto === "object"
      ? performanceRatioBruto.value
      : performanceRatioBruto;
  const seguroResumo =
    form?.control?._formValues?.seguro_rsi_coleta ?? seguro_percentual;

  const temValorResumo = (v: any) => v !== undefined && v !== null && v !== "";

  const linhasSombreamentoPerformance = [
    ...(temValorResumo(sombreamentoResumo)
      ? [
          [
            "Sombreamento (%):",
            FormatFields.formatarNumero(
              FormatFields.desformatarNumeros(sombreamentoResumo),
            ),
          ],
        ]
      : []),
    ...(temValorResumo(performanceRatioResumo)
      ? [
          [
            "Performance Ratio (%):",
            FormatFields.formatarNumero(
              FormatFields.desformatarNumeros(performanceRatioResumo),
            ),
          ],
        ]
      : []),
  ];

  const linhaSeguro = temValorResumo(seguroResumo)
    ? [
        [
          "Seguro (%):",
          FormatFields.formatarNumero(
            FormatFields.desformatarNumeros(seguroResumo),
          ),
        ],
      ]
    : [];

  const origemDadosResumo =
    origem_dados_default ?? origemDadosConfiguracaoGeral();

  const linhasOrigemDadosDefault = [
    ["Origem dos Dados Default:", origemDadosResumo.rotulo],
    [
      "Política de Preço / Comissão / Custos Extras:",
      formatarLinhaPolitica(origemDadosResumo, parametros_politica_vigente),
    ],
  ];

  let resumoDados: {
    [x: string]: {
      [y: string]: any[][];
    };
  };
  if (origem === "simulador") {
    resumoDados = {
      "Dados Simulador": {
        "Informações Gerais": [
          ["Origem:", origem],
          ["Data Geração:", getDateTimeBrasil(undefined, new Date())],
          ["Gerado por:", nome_usuario],
          ...linhasOrigemDadosDefault,
          ["Tipo de Kit:", tipo_kit],
          ["Distribuidor:", nome_distribuidor],
          ["Tipo de Telhado:", nome_telhado],
          ["% Fator de Simultaneidade:", valor_simultaneidade_proposta],
          [
            "% de Aumento de Consumo:",
            FormatFields.formatarNumero(porcentagemAumentoConsumo),
          ],
          ...linhaSeguro,
          ...linhasSombreamentoPerformance,
        ],
        Valores: [
          [
            <div key={1} className="text-2xl">
              Valor da Simulação:
            </div>,
            <div key={1} className="text-2xl">
              {formatarValor(valorTotal_proposta)}
            </div>,
          ],
          [
            "Valor da Tarifa de Aplicação:",
            `R$ ${FormatFields.formatarNumeroPreciso(preco_tarifa)}`,
          ],
          // ...(valor_desconto
          //   ? [
          //       ["Valor de Desconto:", `-${formatarValor(valor_desconto)}`],
          //       [
          //         "Valor Total Sem Desconto:",
          //         formatarValor(valor_total_sem_desconto),
          //       ],
          //     ]
          //   : []),
          // ...(valor_acrescimo > 1
          //   ? [
          //       ["Valor de Acréscimo:", `+${formatarValor(valor_acrescimo)}`],
          //       [
          //         "Valor Total Sem Acréscimo:",
          //         formatarValor(valor_total_sem_acrescimo),
          //       ],
          //     ]
          //   : []),
          ...(valor_desconto
            ? [
                [
                  "Valor Total de Ajustes:",
                  `-${formatarValor(valor_desconto)}`,
                ],
                [
                  "Valor Total Sem Ajustes:",
                  formatarValor(valor_total_sem_desconto),
                ],
              ]
            : []),
          ...(valor_acrescimo > 0
            ? [
                [
                  "Valor Total de Ajustes:",
                  `+${formatarValor(valor_acrescimo)}`,
                ],
                [
                  "Valor Total Sem Ajustes:",
                  formatarValor(valor_total_sem_acrescimo),
                ],
              ]
            : []),
        ],
        Sistema: [
          ["Concessionária:", nome_concessisonaria],
          [
            "Consumo Total (kWh):",
            `${FormatFields.formatarNumero(consumoTotal)} kWh`,
          ],
        ],
      },
      "Dimensionamento do Sistema": {
        Geração: [
          ["Consumo Mensal:", `${consumoTotal} kWh`],
          ["Geração Mensal:", `${estimativa_geracao} kWh`],
          [
            "Abatimento:",
            `${FormatFields.formatarNumero(
              Number(
                FormatFields.desformatarNumeros(
                  abatimento ?? 0,
                ),
              ).toFixed(2),
            )} %`,
          ],
          [
            "Geração anual:",
            <div key={1} className="flex flex-row gap-1">
              <div>{(+estimativa_geracao * 12).toFixed(2)} kWh</div>
              <Button
                className="bg-transparent text-primary p-0"
                type="button"
                onClick={(e: any) => {
                  e.stopPropagation();
                  const estimativaMensal = Number(estimativa_geracao || 0);
                  const resultado = (estimativaMensal * 12).toFixed(2);

                  const formula = `
                  \\text{Geração Estimada Anual (kWh)} \\\\
                  \\overset{\\text{Mensal}}{${estimativaMensal}} \\times \\overset{\\text{Meses}}{12} = ${resultado}
                `;

                  const formulaHtml = `<div style="display: flex; flex-direction: column; margin-bottom: 20px;">
                  ${katex.renderToString(formula, { throwOnError: false })}
                </div>`;

                  Swal.fire({
                    icon: "info",
                    showConfirmButton: false,
                    // title: "Cálculo da Geração Estimada Anual",
                    html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      ${formulaHtml}
                    </div>
                  `,
                  });
                }}
              >
                <InfoIcon size={24} />
              </Button>
            </div>,
          ],
        ],
        Módulos: [
          ["Quantidade de placas:", qtd_modulos],
          [
            "Valor do Fio B:",
            `R$ ${FormatFields.formatarNumeroPreciso(fiob_tarifa)}`,
          ],
          [
            "Potência do Módulo:",
            `${FormatFields.formatarNumero(potencia_modulo)} W`,
          ],
          [
            "Fabricante do Módulo:",
            fabricantes.find(
              (a: any) => a.id_fabricante === modulo?.codFabricante_item,
            )?.nome_fabricante,
          ],
          // ["Modelo do Módulo:", modulo.modelo_item],
          [
            "Potência do Sistema:",
            <div key={1} className="flex flex-row gap-1">
              <div>{FormatFields.formatarNumero(potencia_sistema)} kWp</div>
              <Button
                className="bg-transparent text-primary p-0"
                type="button"
                onClick={(e: any) => {
                  e.stopPropagation();
                  Swal.fire({
                    icon: "info",
                    showConfirmButton: false,
                    title: "Cálculo da Área Total Estimada dos Módulos",
                    html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      <div class="text-error italic">
                        Potência dos Módulos Wp * quantidade de módulos = Potência do Sistema Wp
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(potencia_modulo)} Wp * ${qtd_modulos} = ${FormatFields.formatarNumero(+potencia_sistema * 1000)} Wp
                      </div>
                      <div>
                        =
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(+potencia_sistema)} kWp
                      </div>
                    </div>
                  `,
                  });
                }}
              >
                <InfoIcon size={24} />
              </Button>
            </div>,
          ],
          [
            "Área do Módulo em m²:",
            `${FormatFields.formatarNumero(area_modulo)} m²`,
          ],
          [
            "Orientação:",
            (
              distribuicaoDosModulos ||
              form?.control?._formValues?.distribuicaoDosModulos
            )
              ?.map((dist: any) => getOrientacaoNome(dist.orientacao))
              .join(", ") || "Não informado",
          ],

          [
            "Área Total Estimada em m²:",
            <div key={1} className="flex flex-row gap-1">
              <div>{area_ocupada?.toFixed(2)} m²</div>
              <Button
                className="bg-transparent text-primary p-0"
                type="button"
                onClick={(e: any) => {
                  e.stopPropagation();
                  Swal.fire({
                    icon: "info",
                    showConfirmButton: false,
                    title: "Cálculo da Área Total Estimada dos Módulos",
                    html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      <div class="text-error italic">
                        Área dos módulos m² * quantidade de módulos = Área Total m²
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(area_modulo)} m² * ${qtd_modulos} = ${FormatFields.formatarNumero(+area_ocupada)} m²
                      </div>
                    </div>
                  `,
                  });
                }}
              >
                <InfoIcon size={24} />
              </Button>
            </div>,
          ],
        ],

        "Inversor(es)": [
          [
            <div key={1}>
              {renderTabelaInversores(tabelaInversoresProposta)}
            </div>,
          ],
        ],

        ...(((tipoNegocio_coleta === "3" && cod_coleta) ||
          tipoNegocio_coleta !== "3") && {
          "Capacidade de Módulos no(s) Inversor(es)": [
            ["Mínimo:", qtd_min_modulos],
            ["Máximo:", qtd_max_modulos],
          ],
        }),
      },
    };
  } else {
    resumoDados = {
      "Dados Da Proposta": {
        "Informações Gerais": [
          [
            <div key={1} className="text-2xl">
              {tipoNegocio_coleta === "3"
                ? "Nr. Negócio Ampliação:"
                : "Negócio:"}
            </div>,
            <div key={1} className="text-2xl">
              {id_coleta}
            </div>,
          ],
          ...(tipoNegocio_coleta === "3" && lastProposalInfo?.id_coleta
            ? [["Nr. Negócio Origem:", lastProposalInfo?.id_coleta]]
            : []),
          [
            tipoNegocio_coleta !== "3" ? "Tipo de Kit:" : "Tipo de Componente",
            tipo_kit,
          ],
          ["Distribuidor:", nome_distribuidor],
          ["Tipo de Telhado:", nome_telhado],
          ...(tipoNegocio_coleta === "3" && labelTipoAmpliacao
            ? [["Tipo de Ampliação:", labelTipoAmpliacao]]
            : []),
          ["Válido até:", validade_proposta],
          ...linhasSombreamentoPerformance,
          ...(tipoNegocio_coleta !== "3"
            ? [
                ["% Fator de Simultaneidade:", valor_simultaneidade_proposta],
                [
                  "% de Aumento de Consumo:",
                  FormatFields.formatarNumero(porcentagemAumentoConsumo),
                ],
                ...linhaSeguro,
              ]
            : []),

          ["Data Geração:", data_geracao_proposta],
          ...(proposta?.status_proposta == 1
            ? [
                [
                  "Data Aprovação:",
                  `${new Date(proposta.data_hora_aprovacao).toLocaleDateString(
                    "pt-BR",
                  )} - Aprovado por: ${proposta.nome_usuario_aprovacao}`,
                ],
              ]
            : []),
          ...(proposta?.status_proposta == 3
            ? [
                [
                  "Data Cancelamento:",
                  `${new Date(proposta.data_hora_reprovacao).toLocaleDateString(
                    "pt-BR",
                  )} - Cancelado por: ${proposta.nome_usuario_reprovacao}`,
                ],
              ]
            : []),
          ["Gerado por:", nome_usuario],
          ...(origem_dados_default
            ? [
                ["Origem dos Dados Default:", origem_dados_default.rotulo],
                ...(origem_dados_default.tipo === "PROPOSTA_EXISTENTE"
                  ? [
                      [
                        "Política de Preço / Comissão / Custos Extras:",
                        `Copiados da Proposta nº ${origem_dados_default.id_proposta_base} — alterações posteriores nas Políticas NÃO foram consideradas`,
                      ],
                    ]
                  : [
                      [
                        "Política de Preço / Comissão / Custos Extras:",
                        "Configuração Geral vigente na data da geração",
                      ],
                    ]),
              ]
            : []),
        ],
        Valores: [
          [
            <div key={1} className="text-2xl">
              Valor da Proposta:
            </div>,
            <div key={1} className="text-2xl">
              {formatarValor(valorTotal_proposta)}
            </div>,
          ],

          // [
          //   "Valor da Tarifa de Aplicação:",
          //   `R$ ${FormatFields.formatarNumeroPreciso(preco_tarifa)}`,
          // ],
          ...(tipoNegocio_coleta !== "3"
            ? [
                [
                  "Valor da Tarifa de Aplicação:",
                  `R$ ${FormatFields.formatarNumeroPreciso(preco_tarifa)}`,
                ],
              ]
            : []),
          ...(valor_desconto
            ? [
                ["Valor de Desconto:", `-${formatarValor(valor_desconto)}`],
                [
                  "Valor Total Sem Desconto:",
                  formatarValor(valor_total_sem_desconto),
                ],
              ]
            : []),
          ...(valor_acrescimo
            ? [
                ["Valor de Acréscimo:", `+${formatarValor(valor_acrescimo)}`],
                [
                  "Valor Total Sem Acréscimo:",
                  formatarValor(valor_total_sem_acrescimo),
                ],
              ]
            : []),
          ...(tipoNegocio_coleta !== "3" ? [["Payback:", payback]] : []),
          ...(potencia_sistema
            ? [
                [
                  "Valor por kWp:",
                  <div key="1" className="flex flex-row gap-1">
                    <div>
                      {formatarValor(valorTotal_proposta / potencia_sistema)}
                    </div>
                    <Button
                      className="bg-transparent text-primary p-0"
                      type="button"
                      onClick={(e: any) => {
                        e.stopPropagation();

                        const valorFinal = valorTotal_proposta;
                        const potencia = potencia_sistema;

                        const formulas = `
                  \\text{Cálculo do custo por kWp} \\\\
                  \\frac{
                    \\overset{\\text{Valor Final R}\\text{\\textdollar}}{${valorFinal}}
                  }{
                    \\overset{\\text{Potência (kWp)}}{${potencia}}
                  } = {\\text{R}}{\\text{\\textdollar}} ${(valorFinal / potencia).toFixed(2)}/kWp
                `;

                        const formulasHtml = `<div style="display: flex; flex-direction: column; margin-bottom: 20px;">${katex.renderToString(
                          formulas,
                          { throwOnError: false },
                        )}</div>`;

                        Swal.fire({
                          icon: "info",
                          showConfirmButton: false,
                          // title: "Cálculo  do Custo por kWp",
                          html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      ${formulasHtml}
                    </div>
                  `,
                        });
                      }}
                    >
                      <InfoIcon size={24} />
                    </Button>
                  </div>,
                ],
              ]
            : []),
          [<div key="1">&nbsp;</div>],
          ["OBS da Oportunidade:", obs_negocio],
        ],
        Sistema: [
          ["Concessionária:", nome_concessisonaria],
          ["Tipo de Ligação:", nome_tipoLigacao_proposta],
          ...(tipoNegocio_coleta === "3"
            ? [
                [
                  "Tensão da Rede:",
                  tensaoRedeOrigem ? `${tensaoRedeOrigem}V` : "Não Informado",
                ],
              ]
            : []),
          ...(tipoNegocio_coleta === "3" && lastProposalInfo?.disjuntor_coleta
            ? [["Disjuntor:", `${lastProposalInfo?.disjuntor_coleta}A`]]
            : []),
          ["Grupo:", grupo_proposta],
          ["Subgrupo:", subgrupo_proposta],
          // ["Concessionária:", nome_concessisonaria],
          ...(tipoNegocio_coleta !== "3"
            ? [
                [
                  "Consumo Total (kWh):",
                  `${FormatFields.formatarNumero(
                    tipoNegocio_coleta === "3"
                      ? ucs.find((u: any) => u.isAmpliacao_uc_coleta === "1")
                          .valor
                      : ucs.reduce(
                          (acc: number, uc: any) =>
                            (acc +=
                              +uc.valor == +uc.valor
                                ? +uc.valor
                                : uc.valor.reduce(
                                    (acc: number, curr: string) => acc + +curr,
                                    0,
                                  ) /
                                  uc.valor.filter(
                                    (val: number | string) => val !== "",
                                  ).length),
                          0,
                        ),
                  )} kWh`,
                ],
              ]
            : []),
          [<div key="1">&nbsp;</div>],
          ["OBS da Proposta:", obs_proposta],
        ],
        ...(tipoNegocio_coleta !== "3" && {
          "Unidades Consumidoras": [
            [
              <div
                key={1}
                className="w-full flex flex-row justify-center min-w-[700px]"
              >
                <table>
                  <thead>
                    <tr>
                      <th className="p-2 text-center">Nr.UC</th>
                      <th className="p-2 text-center">Tipo</th>
                      {tipoNegocio_coleta !== "3" && (
                        <th className="p-2 text-center">% Para esta UC</th>
                      )}
                      <th className="p-2 text-center">Consumo Médio em kW</th>
                      {tipoNegocio_coleta !== "3" && (
                        <>
                          <th className="p-2 text-center">
                            Valor Médio da COSIP
                          </th>
                          <th className="p-2 text-center">
                            Valor Médio de Outros Custos
                          </th>
                        </>
                      )}
                    </tr>
                  </thead>
                  <tbody>
                    {ucs
                      .filter((u: any) => u.valor != 0)
                      ?.slice()
                      .sort((a: any, b: any) => {
                        if (
                          a.isGeradora_uc_coleta === "1" &&
                          b.isGeradora_uc_coleta !== "1"
                        )
                          return -1;
                        if (
                          a.isGeradora_uc_coleta !== "1" &&
                          b.isGeradora_uc_coleta === "1"
                        )
                          return 1;
                        return 0;
                      })
                      ?.map((uc: any, indexUc: number) => (
                        <tr key={indexUc}>
                          <td className="text-center px-2 py-1">{uc.uc}</td>
                          <td className="text-center px-2 py-1">
                            {uc?.isAmpliacao_uc_coleta === "1"
                              ? "Ampliação"
                              : indexUc > 0
                                ? "Beneficiária"
                                : "Geradora"}
                          </td>
                          {tipoNegocio_coleta !== "3" && (
                            <td className="text-center px-2 py-1">{`${uc.porcentagem_uc_coleta} %`}</td>
                          )}
                          <td className="text-center px-2 py-1">
                            {FormatFields.formatarNumero(
                              +uc.valor == +uc.valor
                                ? +uc.valor
                                : uc.valor.reduce(
                                    (acc: number, curr: string) => acc + +curr,
                                    0,
                                  ) /
                                    uc.valor.filter(
                                      (val: number | string) => val !== "",
                                    ).length,
                            )}{" "}
                            kW
                          </td>
                          {tipoNegocio_coleta !== "3" && (
                            <>
                              <td className="text-center px-2 py-1">
                                {formatarValor(uc.cosip_uc_coleta)}
                              </td>
                              <td className="text-center px-2 py-1">
                                {formatarValor(uc.outros_custos_uc_coleta)}
                              </td>
                            </>
                          )}
                        </tr>
                      ))}
                  </tbody>
                </table>
              </div>,
            ],
          ],
        }),
      },
      ...(tipoNegocio_coleta === "3" && {
        "Dimensionamento do Sistema de Origem": {
          Geração: [
            [
              "Consumo Médio Mensal:",
              `${+calcTotalConsumo(ucs)} kWh` || "Não Informado",
            ],
            [
              "Geração Mensal:",
              `${estimativa_geracao_cliente?.toFixed(2)} kWh` ||
                "Não Informado",
            ],
            ["Abatimento Origem:", `${abatimentoCliente} %`],

            [
              "Geração anual:",
              <div key={1} className="flex flex-row gap-1">
                <div>{(+estimativa_geracao_cliente * 12).toFixed(2)} kWh</div>
                <Button
                  className="bg-transparent text-primary p-0"
                  type="button"
                  onClick={(e: any) => {
                    e.stopPropagation();
                    const estimativaMensal = Number(
                      estimativa_geracao_cliente || 0,
                    );
                    const resultado = (estimativaMensal * 12).toFixed(2);

                    const formula = `
                  \\text{Geração Estimada Anual (kWh)} \\\\
                  \\overset{\\text{Mensal}}{${estimativaMensal}} \\times \\overset{\\text{Meses}}{12} = ${resultado}
                `;

                    const formulaHtml = `<div style="display: flex; flex-direction: column; margin-bottom: 20px;">
                  ${katex.renderToString(formula, { throwOnError: false })}
                </div>`;

                    Swal.fire({
                      icon: "info",
                      showConfirmButton: false,
                      // title: "Cálculo da Geração Estimada Anual",
                      html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      ${formulaHtml}
                    </div>
                  `,
                    });
                  }}
                >
                  <InfoIcon size={24} />
                </Button>
              </div>,
            ],
          ],
          Módulos: [
            ["Quantidade de placas:", componentesModulosCliente?.qtd_item],
            // [
            //   "Valor do Fio B:",
            //   `R$ ${FormatFields.formatarNumeroPreciso(cod_coleta ? lastProposalInfo?.fiob_tarifa_proposta : fiob_tarifa)}`,
            // ],
            [
              "ID do Módulo:",
              componentesModulosCliente?.id_item ?? "Não Informado",
            ],
            [
              "Descrição do Módulo:",
              componentesModulosCliente?.descricao_item ?? "Não Informado",
            ],
            [
              "Potência do Módulo:",
              `${FormatFields.formatarNumero(componentesModulosCliente?.potencia_item)} W` ||
                "Não Informado",
            ],
            [
              "Garantia do Módulo:",
              componentesModulosCliente?.garantia_item
                ? `${componentesModulosCliente?.garantia_item / 12} anos`
                : "Não Informado",
            ],
            [
              "Período e Eficiência:",
              componentesModulosCliente?.anos_eficiencia_item &&
              componentesModulosCliente?.eficiencia_25anos_item
                ? `${componentesModulosCliente?.anos_eficiencia_item} anos - ${componentesModulosCliente?.eficiencia_25anos_item}%`
                : "Não Informado",
            ],
            [
              "Fabricante do Módulo:",
              fabricantes.find(
                (a: any) =>
                  a.id_fabricante ===
                  (cod_coleta
                    ? componentesModulosCliente?.codFabricante_item
                    : dadosAmpliacao.marcaModulo_ampliacao),
              )?.nome_fabricante ?? "Não Informado",
            ],
            // ["Modelo do Módulo:", modulo.modelo_item],
            [
              "Potência do Sistema:",
              <div key={1} className="flex flex-row gap-1">
                <div>
                  {FormatFields.formatarNumero(
                    (Number(componentesModulosCliente?.potencia_item) *
                      Number(componentesModulosCliente?.qtd_item)) /
                      1000,
                  )}{" "}
                  kWp
                </div>
                <Button
                  className="bg-transparent text-primary p-0"
                  type="button"
                  onClick={(e: any) => {
                    e.stopPropagation();
                    Swal.fire({
                      icon: "info",
                      showConfirmButton: false,
                      title: "Cálculo da Área Total Estimada dos Módulos",
                      html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      <div class="text-error italic">
                        Potência dos Módulos Wp * quantidade de módulos = Potência do Sistema Wp
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(componentesModulosCliente?.potencia_item)} Wp * ${componentesModulosCliente?.qtd_item} = ${FormatFields.formatarNumero(
                          +!cod_coleta
                            ? (Number(
                                componentesModulosCliente?.potencia_item,
                              ) *
                                Number(componentesModulosCliente?.qtd_item)) /
                                1000
                            : lastProposalInfo?.potenciaSistema_proposta * 1000,
                        )} Wp
                      </div>
                      <div>
                        =
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(
                          +!cod_coleta
                            ? (Number(
                                componentesModulosCliente?.potencia_item,
                              ) *
                                Number(componentesModulosCliente?.qtd_item)) /
                                1000
                            : lastProposalInfo?.potenciaSistema_proposta,
                        )} kWp
                      </div>
                    </div>
                  `,
                    });
                  }}
                >
                  <InfoIcon size={24} />
                </Button>
              </div>,
            ],
            [
              "Área do Módulo em m²:",
              componentesModulosCliente.altura_item &&
              componentesModulosCliente.largura_item
                ? `${FormatFields.formatarNumero(+componentesModulosCliente.altura_item * +componentesModulosCliente.largura_item)} m²`
                : "Não Informado",
            ],

            [
              "Orientação:",
              lastProposalInfo.ampliacao
                ?.map((dist: any) => getOrientacaoNome(dist.orientacao))
                .join(", "),
            ],

            [
              "Área Total Estimada em m²:",
              <div key={1} className="flex flex-row gap-1">
                <div>
                  {lastProposalInfo?.area_modulos_ocupada_proposta
                    ? `${lastProposalInfo?.area_modulos_ocupada_proposta} m² `
                    : "Não Informado"}{" "}
                </div>
                {lastProposalInfo?.area_modulos_ocupada_proposta && (
                  <Button
                    className="bg-transparent text-primary p-0"
                    type="button"
                    onClick={(e: any) => {
                      e.stopPropagation();
                      Swal.fire({
                        icon: "info",
                        showConfirmButton: false,
                        title: "Cálculo da Área Total Estimada dos Módulos",
                        html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      <div class="text-error italic">
                        Área dos módulos m² * quantidade de módulos = Área Total m²
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(area_modulo)} m² * ${qtd_modulos} = ${FormatFields.formatarNumero(+area_ocupada)} m²
                      </div>
                    </div>
                  `,
                      });
                    }}
                  >
                    <InfoIcon size={24} />
                  </Button>
                )}
              </div>,
            ],
          ],

          "Inversor(es)": [
            [
              <div key={1}>
                {renderTabelaInversores(tabelaInversoresOrigem)}
              </div>,
            ],
          ],

          "Unidades Consumidoras do projeto de Origem": [
            [
              <div key={1} className="w-full flex flex-row justify-center">
                <table>
                  <thead>
                    <tr>
                      <th className="p-2 text-center">Nr.UC</th>
                      <th className="p-2 text-center">Tipo</th>
                      {tipoNegocio_coleta !== "3" && (
                        <th className="p-2 text-center">% Para esta UC</th>
                      )}
                      <th className="p-2 text-center">Consumo Médio em kW</th>
                      {tipoNegocio_coleta !== "3" && (
                        <>
                          <th className="p-2 text-center">
                            Valor Médio da COSIP
                          </th>
                          <th className="p-2 text-center">
                            Valor Médio de Outros Custos
                          </th>
                        </>
                      )}
                    </tr>
                  </thead>
                  <tbody>
                    {ucs
                      .filter(
                        (u: any) =>
                          u.valor != 0 && u?.isAmpliacao_uc_coleta !== "1",
                      )
                      ?.slice()
                      .sort((a: any, b: any) => {
                        if (
                          a.isGeradora_uc_coleta === "1" &&
                          b.isGeradora_uc_coleta !== "1"
                        )
                          return -1;
                        if (
                          a.isGeradora_uc_coleta !== "1" &&
                          b.isGeradora_uc_coleta === "1"
                        )
                          return 1;
                        return 0;
                      })
                      ?.map((uc: any, indexUc: number) => (
                        <tr key={indexUc}>
                          <td className="text-center px-2 py-1">{uc.uc}</td>
                          <td className="text-center px-2 py-1">
                            {uc?.isAmpliacao_uc_coleta === "1"
                              ? "Ampliação"
                              : indexUc > 0
                                ? "Beneficiária"
                                : "Geradora"}
                          </td>
                          {tipoNegocio_coleta !== "3" && (
                            <td className="text-center px-2 py-1">{`${uc.porcentagem_uc_coleta} %`}</td>
                          )}
                          <td className="text-center px-2 py-1">
                            {FormatFields.formatarNumero(
                              +uc.valor == +uc.valor
                                ? +uc.valor
                                : uc.valor.reduce(
                                    (acc: number, curr: string) => acc + +curr,
                                    0,
                                  ) /
                                    uc.valor.filter(
                                      (val: number | string) => val !== "",
                                    ).length,
                            )}{" "}
                            kW
                          </td>
                          {tipoNegocio_coleta !== "3" && (
                            <>
                              <td className="text-center px-2 py-1">
                                {formatarValor(uc.cosip_uc_coleta)}
                              </td>
                              <td className="text-center px-2 py-1">
                                {formatarValor(uc.outros_custos_uc_coleta)}
                              </td>
                            </>
                          )}
                        </tr>
                      ))}
                  </tbody>
                </table>
              </div>,
            ],
          ],

          // }),
        },
      }),
      [`Dimensionamento do Sistema ${tipoNegocio_coleta === "3" ? " da Ampliação" : ""}`]:
        {
          Geração: [
            ...(tipoNegocio_coleta !== "3"
              ? [
                  ["Consumo Mensal real:", `${consumoRealBase} kWh`],
                  [
                    "Consumo com % Aumento:",
                    `${FormatFields.formatarNumero(consumoComAumento)} kWh`,
                  ],
                  ["Geração Mensal:", `${estimativa_geracao} kWh`],
                  ["Abatimento:", `${FormatFields.formatarNumero(
                    Number(
                      FormatFields.desformatarNumeros(abatimento ?? 0),
                    ).toFixed(2),
                  )} %`],
                  [
                    "Geração anual:",
                    <div key={1} className="flex flex-row gap-1">
                      <div>{(+estimativa_geracao * 12).toFixed(2)} kWh</div>
                      <Button
                        className="bg-transparent text-primary p-0"
                        type="button"
                        onClick={(e: any) => {
                          e.stopPropagation();
                          const estimativaMensal = Number(
                            estimativa_geracao || 0,
                          );
                          const resultado = (estimativaMensal * 12).toFixed(2);

                          const formula = `
                  \\text{Geração Estimada Anual (kWh)} \\\\
                  \\overset{\\text{Mensal}}{${estimativaMensal}} \\times \\overset{\\text{Meses}}{12} = ${resultado}
                `;

                          const formulaHtml = `<div style="display: flex; flex-direction: column; margin-bottom: 20px;">
                  ${katex.renderToString(formula, { throwOnError: false })}
                </div>`;

                          Swal.fire({
                            icon: "info",
                            showConfirmButton: false,
                            // title: "Cálculo da Geração Estimada Anual",
                            html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      ${formulaHtml}
                    </div>
                  `,
                          });
                        }}
                      >
                        <InfoIcon size={24} />
                      </Button>
                    </div>,
                  ],
                ]
              : [
                  ["Consumo Médio Total:", `${somaConsumos} kWh`],

                  ["Consumo de Ampliação:", `${consumoAmpliacao_cliente} kWh`],
                  [
                    "Geração Mensal:",
                    <>
                      {estimativa_geracao.toFixed(2)} kWh{" "}
                      {+estimativa_geracao < +consumoAmpliacao_cliente && (
                        <span
                          onClick={() => {}}
                          className="text-danger font-bold"
                        >
                          ATENÇÃO!!! O consumo de geração média é menor que a
                          estimada!
                        </span>
                      )}
                    </>,
                  ],
                  [
                    "% Geração/Consumo Ampliação:",
                    `${((+estimativa_geracao / +consumoAmpliacao_cliente) * 100).toFixed(2)}%`,
                  ],
                  [
                    "Abatimento:",
                    <div key={1} className="flex flex-row gap-1">
                      <div>
                        {((+estimativa_geracao / +somaConsumos) * 100).toFixed(
                          2,
                        )}{" "}
                        %
                      </div>
                      <Button
                        className="bg-transparent text-primary p-0"
                        type="button"
                        onClick={(e: any) => {
                          e.stopPropagation();
                          const somaConsumosValue = Number(somaConsumos || 0);
                          const estimativaGeracao = Number(
                            estimativa_geracao || 0,
                          );
                          const resultado = (
                            (estimativaGeracao / somaConsumosValue) *
                            100
                          ).toFixed(2);

                          const formula = `
                  \\text{Abatimento (\\%)} \\\\
                  \\frac{\\overset{\\text{Geração Mensal}}{${estimativaGeracao}}}{\\overset{\\text{Consumo Médio Total}}{${somaConsumosValue}}} \\times 100 = ${resultado}\\%
                `;

                          const formulaHtml = `<div style="display: flex; flex-direction: column; margin-bottom: 20px;">
                  ${katex.renderToString(formula, { throwOnError: false })}
                </div>`;

                          Swal.fire({
                            icon: "info",
                            showConfirmButton: false,
                            html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      ${formulaHtml}
                    </div>
                  `,
                          });
                        }}
                      >
                        <InfoIcon size={24} />
                      </Button>
                    </div>,
                  ],

                  [
                    "Geração anual:",
                    <div key={1} className="flex flex-row gap-1">
                      <div>{(+estimativa_geracao * 12).toFixed(2)} kWh</div>
                      <Button
                        className="bg-transparent text-primary p-0"
                        type="button"
                        onClick={(e: any) => {
                          e.stopPropagation();
                          const estimativaMensal = Number(
                            estimativa_geracao || 0,
                          );
                          const resultado = (estimativaMensal * 12).toFixed(2);

                          const formula = `
                  \\text{Geração Estimada Anual (kWh)} \\\\
                  \\overset{\\text{Mensal}}{${estimativaMensal}} \\times \\overset{\\text{Meses}}{12} = ${resultado}
                `;

                          const formulaHtml = `<div style="display: flex; flex-direction: column; margin-bottom: 20px;">
                  ${katex.renderToString(formula, { throwOnError: false })}
                </div>`;

                          Swal.fire({
                            icon: "info",
                            showConfirmButton: false,
                            // title: "Cálculo da Geração Estimada Anual",
                            html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      ${formulaHtml}
                    </div>
                  `,
                          });
                        }}
                      >
                        <InfoIcon size={24} />
                      </Button>
                    </div>,
                  ],
                  ["Obs da Ampliação:", `${dadosAmpliacao?.obs_ampliacao} `],
                ]),
          ],
          Módulos: [
            ["Quantidade de placas:", qtd_modulos],
            ["ID do Módulo:", modulo?.id_item ?? "Não Informado"],
            ["Descrição do Módulo:", modulo?.descricao_item ?? "Não Informado"],
            ...(tipoNegocio_coleta !== "3"
              ? [
                  [
                    "Valor do Fio B:",
                    `R$ ${FormatFields.formatarNumeroPreciso(fioBTarifa)}`,
                  ],
                ]
              : []),
            [
              "Potência do Módulo:",
              `${FormatFields.formatarNumero(potencia_modulo)} W`,
            ],
            [
              "Garantia do Módulo:",
              modulo?.garantia_item
                ? `${modulo?.garantia_item / 12} anos`
                : "Não Informado",
            ],
            [
              "Período e Eficiência:",
              modulo?.anos_eficiencia_item && modulo?.eficiencia_25anos_item
                ? `${modulo?.anos_eficiencia_item} anos - ${modulo?.eficiencia_25anos_item}%`
                : "Não Informado",
            ],
            [
              "Fabricante do Módulo:",
              fabricantes.find(
                (a: any) => a.id_fabricante === modulo?.codFabricante_item,
              )?.nome_fabricante,
            ],
            // ["Modelo do Módulo:", modulo.modelo_item],
            [
              "Potência do Sistema:",
              <div key={1} className="flex flex-row gap-1">
                <div>{FormatFields.formatarNumero(potencia_sistema)} kWp</div>
                <Button
                  className="bg-transparent text-primary p-0"
                  type="button"
                  onClick={(e: any) => {
                    e.stopPropagation();
                    Swal.fire({
                      icon: "info",
                      showConfirmButton: false,
                      title: "Cálculo da Área Total Estimada dos Módulos",
                      html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      <div class="text-error italic">
                        Potência dos Módulos Wp * quantidade de módulos = Potência do Sistema Wp
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(potencia_modulo)} Wp * ${qtd_modulos} = ${FormatFields.formatarNumero(+potencia_sistema * 1000)} Wp
                      </div>
                      <div>
                        =
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(+potencia_sistema)} kWp
                      </div>
                    </div>
                  `,
                    });
                  }}
                >
                  <InfoIcon size={24} />
                </Button>
              </div>,
            ],
            [
              "Área do Módulo em m²:",
              `${FormatFields.formatarNumero(area_modulo)} m²`,
            ],

            [
              "Orientação:",
              (
                distribuicaoDosModulos ||
                form?.control?._formValues?.distribuicaoDosModulos
              )
                ?.map((dist: any) => getOrientacaoNome(dist.orientacao))
                .join(", ") || "Não informado",
            ],

            [
              "Área Total Estimada em m²:",
              <div key={1} className="flex flex-row gap-1">
                <div>{area_ocupada?.toFixed(2)} m²</div>
                <Button
                  className="bg-transparent text-primary p-0"
                  type="button"
                  onClick={(e: any) => {
                    e.stopPropagation();
                    Swal.fire({
                      icon: "info",
                      showConfirmButton: false,
                      title: "Cálculo da Área Total Estimada dos Módulos",
                      html: `
                    <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                      <div class="text-error italic">
                        Área dos módulos m² * quantidade de módulos = Área Total m²
                      </div>
                      <div>
                        ${FormatFields.formatarNumero(area_modulo)} m² * ${qtd_modulos} = ${FormatFields.formatarNumero(+area_ocupada)} m²
                      </div>
                    </div>
                  `,
                    });
                  }}
                >
                  <InfoIcon size={24} />
                </Button>
              </div>,
            ],
            [
              "Geração por Módulo:",
              <div key={1} className="flex flex-row gap-1">
                <div>
                  {FormatFields.formatarNumero(
                    (+potencia_modulo *
                      (performance_ratio_parametro / 100) *
                      media_irradiacao_mensal *
                      (1 - +sombreamentos_coleta / 100) *
                      (100 - +perdaMedia)) /
                      100 /
                      1000,
                  )}
                </div>
                <Button
                  type="button"
                  className={` bg-primary flex flex-row gap-2 rounded-full p-0`}
                  onClick={(e: any) => {
                    e.stopPropagation();
                    handleSweetAlert({
                      icon: "info",
                      // title: "Cálculo Markup",
                      showDenyButton: false,
                      confirmButtonText: "Ok",
                      html: `
                                  <div class="flex flex-col gap-2">
                                    <div>
                                      <div class="font-bold">
                                        Geração por Módulo
                                      </div>
                                      <div class="italic text-meta-1">
                                        Potência do módulo * performance ratio * média da irradiação mensal * sombreamentos * perda média = Geração por Módulo
                                      </div>
                                      <div class="italic">
                                        ${new Intl.NumberFormat("pt-BR", {
                                          maximumSignificantDigits: 3,
                                        }).format(
                                          +potencia_modulo / 1000,
                                        )} kW * ${
                                          performance_ratio_parametro
                                        }% * ${FormatFields.formatarNumero(
                                          media_irradiacao_mensal,
                                        )} kWh/m² por mês * ${FormatFields.formatarNumero(
                                          100 - +sombreamentos_coleta,
                                        )}% * ${FormatFields.formatarNumero(
                                          100 - +perdaMedia,
                                        )}%
                                         = ${FormatFields.formatarNumero(
                                           (+potencia_modulo *
                                             (performance_ratio_parametro /
                                               100) *
                                             media_irradiacao_mensal *
                                             (1 - +sombreamentos_coleta / 100) *
                                             (100 - +perdaMedia)) /
                                             100 /
                                             1000,
                                         )} kWh
                                      </div>
                                    </div>
                                  </div>`,
                    });
                  }}
                >
                  <InfoIcon size={24} />
                </Button>
              </div>,
            ],
          ],
          ...((tipoNegocio_coleta !== "3" || tipo_ampliacao?.value === "1") && {
            "Inversor(es)": [
              [
                <div key={1}>
                  {renderTabelaInversores(tabelaInversoresProposta)}
                </div>,
              ],
            ],
            ...(((tipoNegocio_coleta === "3" && cod_coleta) ||
              tipoNegocio_coleta !== "3") && {
              "Capacidade de Módulos no(s) Inversor(es)": [
                ["Mínimo:", qtd_min_modulos],
                ["Máximo:", qtd_max_modulos],
              ],
            }),
          }),
          ...(tipoNegocio_coleta === "3" && {
            "Unidades Consumidoras de Ampliação": [
              [
                <div key={1} className="w-full flex flex-row justify-center ">
                  <table>
                    <thead>
                      <tr>
                        <th className="p-2 text-center">Nr.UC</th>
                        <th className="p-2 text-center">Tipo</th>
                        {tipoNegocio_coleta !== "3" && (
                          <th className="p-2 text-center">% Para esta UC</th>
                        )}
                        <th className="p-2 text-center">Consumo Médio em kW</th>
                        {tipoNegocio_coleta !== "3" && (
                          <>
                            <th className="p-2 text-center">
                              Valor Médio da COSIP
                            </th>
                            <th className="p-2 text-center">
                              Valor Médio de Outros Custos
                            </th>
                          </>
                        )}
                      </tr>
                    </thead>
                    <tbody>
                      {ucs
                        .filter(
                          (u: any) =>
                            u.valor != 0 && u?.isAmpliacao_uc_coleta === "1",
                        )
                        ?.slice()
                        .sort((a: any, b: any) => {
                          if (
                            a.isGeradora_uc_coleta === "1" &&
                            b.isGeradora_uc_coleta !== "1"
                          )
                            return -1;
                          if (
                            a.isGeradora_uc_coleta !== "1" &&
                            b.isGeradora_uc_coleta === "1"
                          )
                            return 1;
                          return 0;
                        })
                        ?.map((uc: any, indexUc: number) => (
                          <tr key={indexUc}>
                            <td className="text-center px-2 py-1">{uc.uc}</td>
                            <td className="text-center px-2 py-1">
                              {uc?.isAmpliacao_uc_coleta === "1"
                                ? "Ampliação"
                                : indexUc > 0
                                  ? "Beneficiária"
                                  : "Geradora"}
                            </td>
                            {tipoNegocio_coleta !== "3" && (
                              <td className="text-center px-2 py-1">{`${uc.porcentagem_uc_coleta} %`}</td>
                            )}
                            <td className="text-center px-2 py-1">
                              {FormatFields.formatarNumero(
                                +uc.valor == +uc.valor
                                  ? +uc.valor
                                  : uc.valor.reduce(
                                      (acc: number, curr: string) =>
                                        acc + +curr,
                                      0,
                                    ) /
                                      uc.valor.filter(
                                        (val: number | string) => val !== "",
                                      ).length,
                              )}{" "}
                              kW
                            </td>
                            {tipoNegocio_coleta !== "3" && (
                              <>
                                <td className="text-center px-2 py-1">
                                  {formatarValor(uc.cosip_uc_coleta)}
                                </td>
                                <td className="text-center px-2 py-1">
                                  {formatarValor(uc.outros_custos_uc_coleta)}
                                </td>
                              </>
                            )}
                          </tr>
                        ))}
                    </tbody>
                  </table>
                </div>,
              ],
            ],
          }),
        },
      ...(tipoNegocio_coleta === "3"
        ? (() => {
            const geracaoMensalAtual = n(estimativa_geracao_cliente);
            const geracaoMensalAmpliacao = n(estimativa_geracao);
            const geracaoMensalTotal =
              geracaoMensalAtual + geracaoMensalAmpliacao;
            const geracaoAnualTotal = (geracaoMensalTotal * 12).toFixed(2);
            // const geracaoAnualTotal = (estimativa_geracao * 12).toFixed(2);

            // Módulos (quantidade total)
            const qtdPlacasAtual = n(componentesModulosCliente?.qtd_item);
            const qtdPlacasAmpliacao = n(qtd_modulos);
            const qtdPlacasTotal = qtdPlacasAtual + qtdPlacasAmpliacao;
            // Potência do sistema (kWp) total
            const kwpAtual = cod_coleta
              ? n(lastProposalInfo?.potenciaSistema_proposta)
              : (n(componentesModulosCliente?.potencia_item) *
                  n(componentesModulosCliente?.qtd_item)) /
                1000;

            const kwpAmpliacao =
              n(potencia_sistema) ||
              (n(potencia_modulo) * n(qtd_modulos)) / 1000;
            const kwpTotal = kwpAtual + kwpAmpliacao;

            // Área total ocupada (m²)
            const areaAtual =
              n(lastProposalInfo?.area_modulos_ocupada_proposta) ||
              n(componentesModulosCliente?.altura_item) *
                n(componentesModulosCliente?.largura_item) *
                qtdPlacasAtual;

            const areaAmpliacao = n(area_ocupada);
            const areaTotal = areaAtual + areaAmpliacao;

            // Inversores (lista unificada)
            if (origem !== "view") {
              form.setValue("qtd_modulos_origem", qtdPlacasAtual);
              form.setValue("potencia_sistema_origem", kwpAtual);
              form.setValue("potencia_sistema_total", kwpTotal);

              form.setValue(
                "geracao_mensal_total_ampliacao",
                geracaoMensalTotal.toFixed(2),
              );
              form.setValue("geracao_anual_total_ampliacao", geracaoAnualTotal);
              form.setValue(
                "quantidade_modulos_total_ampliacao",
                qtdPlacasTotal,
              );
              form.setValue("potencia_sistema_total_ampliacao", kwpTotal);
            }
            const abatimento_total =
              (+geracaoMensalTotal / +somaConsumos) * 100;
            return {
              "Dimensionamento com a Junção dos Sistemas": {
                Geração: [
                  ["Consumo Médio Total:", `${somaConsumos} kWh`],
                  ["Geração Mensal:", `${geracaoMensalTotal.toFixed(2)} kWh`],
                  ["Abatimento:", `${abatimento_total.toFixed(2)} %`],

                  [
                    "Geração anual:",
                    <div key={1} className="flex flex-row gap-1">
                      <div>{geracaoAnualTotal} kWh</div>
                      <Button
                        className="bg-transparent text-primary p-0"
                        type="button"
                        onClick={(e: any) => {
                          e.stopPropagation();
                          Swal.fire({
                            icon: "info",
                            showConfirmButton: false,
                            html: `
                  <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                    <div style="margin-bottom: 8px;">Geração Estimada Anual (kWh)</div>
                    <div>
                      (${FormatFields.formatarNumero(geracaoMensalAtual)} + ${FormatFields.formatarNumero(geracaoMensalAmpliacao)}) x 12 = ${FormatFields.formatarNumero(geracaoAnualTotal)}
                    </div>
                  </div>
                `,
                          });
                        }}
                      >
                        <InfoIcon size={24} />
                      </Button>
                    </div>,
                  ],
                ],
                Módulos: [
                  ["Quantidade de placas:", qtdPlacasTotal],
                  [
                    "Potência do Módulo:",
                    componentesModulosCliente?.potencia_item &&
                    potencia_modulo &&
                    n(componentesModulosCliente?.potencia_item) !==
                      n(potencia_modulo)
                      ? "Diversos"
                      : `${FormatFields.formatarNumero(componentesModulosCliente?.potencia_item || potencia_modulo)} W`,
                  ],
                  [
                    "Fabricante do Módulo:",
                    (() => {
                      const fabAtual = fabricantes.find(
                        (a: any) =>
                          a.id_fabricante ===
                          (cod_coleta
                            ? componentesModulosCliente?.codFabricante_item
                            : dadosAmpliacao.marcaModulo_ampliacao),
                      )?.nome_fabricante;

                      const fabNovo = fabricantes.find(
                        (a: any) =>
                          a.id_fabricante === modulo?.codFabricante_item,
                      )?.nome_fabricante;

                      if (fabAtual && fabNovo && fabAtual !== fabNovo)
                        return "Diversos";
                      return fabAtual || fabNovo || "";
                    })(),
                  ],
                  [
                    "Potência do Sistema:",
                    <div key={1} className="flex flex-row gap-1">
                      <div>{FormatFields.formatarNumero(kwpTotal)} kWp</div>
                      <Button
                        className="bg-transparent text-primary p-0"
                        type="button"
                        onClick={(e: any) => {
                          e.stopPropagation();
                          Swal.fire({
                            icon: "info",
                            showConfirmButton: false,
                            title: "Cálculo da Potência Total do Sistema",
                            html: `
                  <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                    <div class="text-error italic">
                      kWp Total = kWp Atual + kWp Ampliação
                    </div>
                    <div>
                      ${FormatFields.formatarNumero(kwpAtual)} kWp + ${FormatFields.formatarNumero(kwpAmpliacao)} kWp = ${FormatFields.formatarNumero(kwpTotal)} kWp
                    </div>
                  </div>
                `,
                          });
                        }}
                      >
                        <InfoIcon size={24} />
                      </Button>
                    </div>,
                  ],
                  [
                    "Área Total Estimada em m²:",
                    <div key={1} className="flex flex-row gap-1">
                      <div>{FormatFields.formatarNumero(areaTotal)} m²</div>
                      <Button
                        className="bg-transparent text-primary p-0"
                        type="button"
                        onClick={(e: any) => {
                          e.stopPropagation();
                          Swal.fire({
                            icon: "info",
                            showConfirmButton: false,
                            title: "Cálculo da Área Total Estimada dos Módulos",
                            html: `
                  <div style="display: flex; flex-direction: column; align-items: center; font-size: 1.2rem; padding: 10px;">
                    <div class="text-error italic">
                      Área Total = Área Atual + Área Ampliação
                    </div>
                    <div>
                      ${FormatFields.formatarNumero(areaAtual)} m² + ${FormatFields.formatarNumero(areaAmpliacao)} m² = ${FormatFields.formatarNumero(areaTotal)} m²
                    </div>
                  </div>
                `,
                          });
                        }}
                      >
                        <InfoIcon size={24} />
                      </Button>
                    </div>,
                  ],
                ],
                "Inversor(es)": [
                  [
                    <div key={1}>
                      {tipoNegocio_coleta === "3" &&
                      (tabelaInversoresOrigem || []).length > 0
                        ? renderTabelaInversores(
                            mergeInversores(
                              tabelaInversoresProposta,
                              tabelaInversoresOrigem,
                            ),
                          )
                        : renderTabelaInversores(tabelaInversoresProposta)}
                    </div>,
                  ],
                ],
              },
            };
          })()
        : {}),
    };
  }
  const contentRef = useRef<HTMLDivElement>(null);
  const printWrapperRef = useRef<HTMLDivElement>(null);
  const [simuladorHTML, setSimuladorHTML] = useState("");
  const [isGerandoPDF, setIsGerandoPDF] = useState(false);
  //

  // Limite conservador de área de canvas: celulares (iOS/Android) descartam
  // canvas muito grandes e devolvem imagem vazia, deixando o PDF em branco.
  const MAX_AREA_CANVAS = 12_000_000;
  // Tempo máximo aguardando o html2canvas; sem isso o botão fica "processando" para sempre.
  const TIMEOUT_CANVAS = 60_000;

  function comTimeout<T>(promessa: Promise<T>, ms: number): Promise<T> {
    return new Promise<T>((resolve, reject) => {
      const timer = setTimeout(
        () => reject(new Error("TIMEOUT_GERACAO_PDF")),
        ms
      );
      promessa.then(
        (valor) => {
          clearTimeout(timer);
          resolve(valor);
        },
        (erro) => {
          clearTimeout(timer);
          reject(erro);
        }
      );
    });
  }

  // Entrega o arquivo no celular: compartilhar > nova aba > link de download.
  // O `pdf.save()` puro é ignorado por vários navegadores móveis (e por WebView/PWA),
  // dando a impressão de que o PDF "não foi gerado".
  async function entregarArquivo(blob: Blob, nomeArquivo: string) {
    const arquivo =
      typeof File !== "undefined"
        ? new File([blob], nomeArquivo, { type: "application/pdf" })
        : null;

    const navegador: any = navigator;
    if (arquivo && navegador?.canShare?.({ files: [arquivo] })) {
      try {
        await navegador.share({ files: [arquivo], title: nomeArquivo });
        return;
      } catch (erro: any) {
        // AbortError = usuário cancelou o compartilhamento; não cai para o download.
        if (erro?.name === "AbortError") return;
      }
    }

    const url = URL.createObjectURL(blob);
    const link = document.createElement("a");
    link.href = url;
    link.download = nomeArquivo;
    link.rel = "noopener";
    link.target = "_blank";
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);

    if (isMobile) {
      // No celular o download automático costuma ser bloqueado: oferece o link
      // explícito, que sempre funciona porque parte de um clique do usuário.
      handleSweetAlert({
        icon: "success",
        title: "PDF gerado",
        showDenyButton: false,
        confirmButtonText: "Fechar",
        html: `
          <div style="text-align:center">
            <p>Se o download não iniciar automaticamente, toque no botão abaixo.</p>
            <a href="${url}" download="${nomeArquivo}" target="_blank" rel="noopener"
               style="display:inline-block;margin-top:10px;padding:10px 18px;border-radius:8px;background:#3c50e0;color:#fff;text-decoration:none">
              Abrir / baixar o PDF
            </a>
          </div>
        `,
      });
    }

    // Mantém a URL viva o suficiente para o navegador/visualizador abrir o arquivo.
    setTimeout(() => URL.revokeObjectURL(url), 120_000);
  }

  // Gera um arquivo .pdf a partir do conteúdo do resumo, permitindo que o
  // vendedor faça o download e compartilhe com o cliente/gerente (inclusive no celular).
  const handleGerarPDF = async () => {
    const content = contentRef.current;
    if (!content || isGerandoPDF) return;

    setIsGerandoPDF(true);
    // Deixa o spinner aparecer antes do trabalho pesado, que travaria a tela.
    await new Promise((resolve) => requestAnimationFrame(() => resolve(null)));

    // Anexa o resultado do simulador ao conteúdo (mesmo comportamento da impressão)
    const anexouSimulador =
      refResultSimulador && refResultSimulador.parentNode !== content;
    try {
      if (anexouSimulador) {
        content.appendChild(refResultSimulador);
      }

      // Fontes ainda carregando fazem o html2canvas medir o texto errado.
      await (document as any).fonts?.ready?.catch?.(() => null);

      const largura = content.scrollWidth || content.offsetWidth || 800;
      const altura = content.scrollHeight || content.offsetHeight || 1000;

      // Escala: boa leitura no PDF, sem estourar a memória do aparelho.
      const escalaLegibilidade = Math.min(2, Math.max(1, 1400 / largura));
      const escalaMaxArea = Math.sqrt(
        MAX_AREA_CANVAS / Math.max(largura * altura, 1)
      );
      const escala = Math.max(0.6, Math.min(escalaLegibilidade, escalaMaxArea));

      const canvas = await comTimeout(
        html2canvas(content, {
          scale: escala,
          useCORS: true,
          backgroundColor: "#ffffff",
          imageTimeout: 15_000,
          logging: false,
        }),
        TIMEOUT_CANVAS
      );

      const imgData = canvas.toDataURL("image/jpeg", 0.92);
      if (!imgData || imgData.length < 100) {
        // Canvas recusado pelo aparelho (limite de memória/tamanho).
        throw new Error("CANVAS_VAZIO");
      }

      const pdf = new jsPDF({
        orientation: "portrait",
        unit: "mm",
        format: "a4",
      });

      const pageWidth = pdf.internal.pageSize.getWidth();
      const pageHeight = pdf.internal.pageSize.getHeight();
      const imgWidth = pageWidth;
      const imgHeight = (canvas.height * imgWidth) / canvas.width;

      // Pagina a imagem quando ela é maior que uma página A4
      let heightLeft = imgHeight;
      let position = 0;
      pdf.addImage(imgData, "JPEG", 0, position, imgWidth, imgHeight);
      heightLeft -= pageHeight;
      while (heightLeft > 0) {
        position -= pageHeight;
        pdf.addPage();
        pdf.addImage(imgData, "JPEG", 0, position, imgWidth, imgHeight);
        heightLeft -= pageHeight;
      }

      const nomeArquivo =
        origem === "simulador" ? "resumo-simulacao.pdf" : "resumo-proposta.pdf";

      await entregarArquivo(pdf.output("blob"), nomeArquivo);
    } catch (error: any) {
      const timeout = error?.message === "TIMEOUT_GERACAO_PDF";
      const canvasVazio = error?.message === "CANVAS_VAZIO";

      handleSweetAlert({
        icon: "error",
        title: "Não foi possível gerar o PDF",
        showDenyButton: false,
        confirmButtonText: "Ok",
        html:
          timeout || canvasVazio
            ? `
              <div style="text-align:left">
                <p>${
                  timeout
                    ? "A geração passou do tempo limite neste aparelho."
                    : "Este aparelho não conseguiu montar a imagem do resumo (limite de memória do navegador)."
                }</p>
                <p style="margin-top:8px"><b>O que fazer:</b></p>
                <ul style="margin-left:18px">
                  <li>Feche outras abas/aplicativos e tente de novo;</li>
                  <li>Use o botão de impressão (ícone da impressora) e escolha
                      <b>Salvar como PDF</b> no próprio celular;</li>
                  <li>Ou gere o PDF pelo computador.</li>
                </ul>
              </div>
            `
            : "Não foi possível gerar o PDF do resumo. Tente novamente.",
      });
      console.error("Erro ao gerar o PDF do resumo:", error);
    } finally {
      if (anexouSimulador && refResultSimulador?.parentNode === content) {
        content.removeChild(refResultSimulador);
      }
      setIsGerandoPDF(false);
    }
  };

  // refResultSimulador
  const handlePrint = useReactToPrint({
    content: () => contentRef.current,
    onBeforePrint: () => {
      if (refResultSimulador?.parentNode === contentRef.current) {
        contentRef.current!.removeChild(refResultSimulador);
      }
    },
    pageStyle: `
      @media print {
        body {
          zoom: 0.8;
        }
        .print-content {
          transform: scale(0.87);
          transform-origin: top left;
        }
      }
    `,
    onAfterPrint: () => {
      // Remover o refResultSimulador depois da impressão
      if (refResultSimulador?.parentNode === contentRef.current) {
        contentRef.current!.removeChild(refResultSimulador);
      }
    },
  });

  return (
    <div>
      <div className="w-full flex justify-end gap-2">
        <Button
          type="button"
          className={` bg-primary flex flex-row gap-2 items-center`}
          loading={isGerandoPDF}
          onClick={(e: any) => {
            e.stopPropagation();
            handleGerarPDF();
          }}
        >
          <FileDown size={20} />
          <span className="max-sm:hidden">Gerar PDF</span>
        </Button>
        <Button
          type="button"
          className={` bg-primary flex flex-row gap-2`}
          onClick={(e: any) => {
            e.stopPropagation();
            if (refResultSimulador && contentRef) {
              contentRef.current!.appendChild(refResultSimulador);
            }
            handlePrint(e);
          }}
        >
          <Printer />
        </Button>
      </div>

      {isLoadedResumo ? (
        <div
          className="flex flex-col gap-5 p-6 bg-white dark:bg-boxdark rounded-lg  max-sm:p-4 print-content"
          ref={contentRef}
        >
          {origem_dados_default ? (
            <div
              className={`flex flex-row gap-3 items-start rounded-lg border-l-4 p-4 ${
                origem_dados_default.tipo === "PROPOSTA_EXISTENTE"
                  ? "border-warning bg-warning bg-opacity-10"
                  : "border-primary bg-primary bg-opacity-10"
              }`}
            >
              <InfoIcon size={24} className="shrink-0 mt-0.5" />
              <div className="flex flex-col gap-1">
                <span className="font-bold dark:text-white">
                  Como esta proposta foi gerada
                </span>
                <span className="text-sm dark:text-white">
                  {origem_dados_default.descricao}
                </span>
              </div>
            </div>
          ) : null}

          {Object.keys(resumoDados).map((origemDados, keyOrigemDados) => {
            const dadosOrigemDados = resumoDados[origemDados];
            return (
              <div key={keyOrigemDados} className="pb-3">
                <div className="w-full text-center pb-2">
                  <h2 className="text-2xl font-bold  dark:text-white mb-2 max-sm:text-xl">
                    {origemDados}
                  </h2>
                  <div className="h-1 w-20 bg-primary mx-auto rounded-full"></div>
                </div>
                <div className="flex flex-row flex-wrap gap-4">
                  {Object.keys(dadosOrigemDados).map(
                    (conjuntoDados, keyConjuntoDados) => {
                      const infosDados = dadosOrigemDados[conjuntoDados];
                      return (
                        <div
                          key={keyConjuntoDados}
                          className="bg-secondary/10 dark:bg-graydark p-4 rounded-lg  flex-1 min-w-[350px] overflow-auto w-fit"
                        >
                          <table className="w-fit" style={{ margin: "0 auto" }}>
                            <thead>
                              <tr>
                                <th colSpan={2}>
                                  <h4
                                    className="font-semibold text-lg text-center text-primary dark:text-primarylight mb-3 max-w-[240px]"
                                    style={{ margin: "0 auto" }}
                                  >
                                    {conjuntoDados}
                                  </h4>
                                </th>
                              </tr>
                            </thead>
                            <tbody>
                              {infosDados.map((infoDados, keyInfoDados) => {
                                const [headDado, valueDado] = infoDados;
                                return (
                                  <tr key={keyInfoDados}>
                                    {headDado && (
                                      <td
                                        colSpan={
                                          infosDados.every((d) => d.length == 1)
                                            ? 2
                                            : 1
                                        }
                                        className="font-medium text-graydark dark:text-gray-2 px-2 py-1 text-right border-b border-gray-2 dark:border-gray"
                                      >
                                        {headDado}
                                      </td>
                                    )}
                                    {valueDado && (
                                      <td className=" dark:text-stroke p-1 border-b border-gray-2 dark:border-gray">
                                        {valueDado}
                                      </td>
                                    )}
                                  </tr>
                                );
                              })}
                            </tbody>
                          </table>
                        </div>
                      );
                    },
                  )}
                </div>
              </div>
            );
          })}
          {/* O Simulador já envia apexOptions/apexSeries de Geração e de RSI e
              agora também a tabela_rsi — só o `origem !== "simulador"` impedia
              de renderizar. Mostrar os mesmos gráficos/tabela da Proposta. */}
          {tipoNegocio_coleta !== "3" && (
            <>
              {/* Gráfico de Geração */}
              <div className="bg-white  p-4 rounded-lg shadow-sm border border-gray-2 dark:border-gray">
                <h3 className="font-bold text-lg text-center  dark:text-white mb-4">
                  Gráfico de Geração
                </h3>
                <div className="absolute -z-99999 w-[2000px] h-[2000px] opacity-0">
                  <ReactApexChart
                    // options={apexOptionsGraficoGeracao}
                    options={{
                      ...apexOptionsGraficoGeracao,
                      chart: {
                        ...apexOptionsGraficoGeracao.chart,
                        id: `${apexOptionsGraficoGeracao.chart.id}_`,
                      },
                    }}
                    series={apexSeriesGraficoGeracao}
                    type="bar"
                    height={380}
                  />
                </div>
                <ReactApexChart
                  options={apexOptionsGraficoGeracao}
                  series={apexSeriesGraficoGeracao}
                  type="bar"
                  height={350}
                />
              </div>

              {/* Gráfico RSI */}
              <div className="bg-white  p-4 rounded-lg shadow-sm border border-gray-2 dark:border-gray">
                <h3 className="font-bold text-lg text-center  dark:text-white mb-4">
                  Gráfico do RSI
                </h3>
                <div className="absolute -z-99999 w-[2000px] h-[2000px] opacity-0">
                  <ReactApexChart
                    options={{
                      ...apexOptionsGraficoRsi,
                      chart: {
                        ...apexOptionsGraficoRsi.chart,
                        id: `${apexOptionsGraficoRsi.chart.id}_`,
                      },
                    }}
                    series={apexSeriesGraficoRsi}
                    type="bar"
                    height={380}
                  />
                </div>
                <ReactApexChart
                  options={apexOptionsGraficoRsi}
                  series={apexSeriesGraficoRsi}
                  type="bar"
                  height={350}
                />
              </div>

              {/* Tabela RSI */}
              <div className=" p-6 rounded-lg overflow-x-auto flex flex-col items-stretch">
                <h3 className="font-bold text-xl text-center  dark:text-white mb-6">
                  Tabela do RSI
                </h3>

                <table className="text-sm max-sm:text-xs">
                  <thead>
                    <tr className="dark:text-white">
                      {rsi_table.map((infoRetorno: any, index: number) => (
                        <th key={index} className="p-1">
                          {infoRetorno.title}
                        </th>
                      ))}
                    </tr>
                  </thead>
                  <tbody>
                    {tabela_rsi?.map((retornoAtual: any, index: number) => (
                      <tr
                        key={index}
                        className={`${index % 2 == 0 ? "bg-black/10 dark:bg-white/5" : "bg-transparent"} dark:text-bodydark1`}
                      >
                        {rsi_table.map((infoRetorno, i) => (
                          <td
                            key={i}
                            className={`text-center p-1 ${
                              [
                                "tarifa_energia",
                                "receita_energia",
                                "tarifa_scee",
                                "receita_scee",
                                "receita_bruta",
                                "opex",
                                "seguro",
                                "receita_liquida",
                                "fluxo_caixa",
                              ].includes(infoRetorno.value)
                                ? retornoAtual[infoRetorno.value] < 0
                                  ? "text-error"
                                  : "text-primary"
                                : ""
                            }`}
                          >
                            {infoRetorno.type == "year"
                              ? +getDateBrasil({
                                  day: undefined,
                                  month: undefined,
                                  year: "numeric",
                                  hour: undefined, // Define a hora como undefined para excluí-la
                                  minute: undefined, // Define os minutos como undefined para excluí-los
                                  second: undefined, // Define os segundos como undefined para excluí-los
                                }) + index
                              : infoRetorno.type == "kWh"
                                ? retornoAtual[infoRetorno.value]?.toFixed(0)
                                : infoRetorno.value == "tarifa_energia"
                                  ? "R$ " +
                                    parseFloat(retornoAtual[infoRetorno.value])
                                      .toFixed(6)
                                      .replace(".", ",")
                                  : formatarValor(
                                      retornoAtual[infoRetorno.value],
                                    )}
                          </td>
                        ))}
                      </tr>
                    ))}
                  </tbody>
                </table>
              </div>
            </>
          )}
        </div>
      ) : (
        <div className="flex justify-center w-full mt-19">
          <LoaderSun />
        </div>
      )}
    </div>
  );
}
