import Input from "@/components/Forms/Input";
import InputGroup from "@/components/Forms/InputGroup";
import InputSelectComponent from "@/components/Forms/InputSelect";
import { listarInstBancarias } from "@/requests/CRUD/InstBancarias/listarInstBancarias";
import { listarMeiosPagamento } from "@/requests/CRUD/MeiosPagamento/listarMeioPagamento";
import { GetForm } from "@/utils";
import { useEffect, useMemo, useRef, useState } from "react";
import Swal from "sweetalert2";
import * as yup from "yup";

const MEIOS_EXTRAS_VAZIO: any[] = [];

const resolverCodInstituicaoMeio = (
  defaultValues: any,
  instituicoesBancarias: any[] = [],
) => {
  const direto = extrairValorCampo(
    defaultValues?.cod_inst_bancaria_meio_recebimento ??
      defaultValues?.id_inst_bancaria,
  );

  if (direto !== undefined && direto !== null && String(direto).trim() !== "") {
    return String(direto);
  }

  const nomeBanco = String(
    defaultValues?.nome_inst_bancaria ??
      defaultValues?.banco_meio_recebimento ??
      "",
  ).trim();

  if (!nomeBanco || !instituicoesBancarias.length) {
    return "";
  }

  const porNome = instituicoesBancarias.find(
    (inst) =>
      String(inst.nome_inst_bancaria).toLowerCase() === nomeBanco.toLowerCase(),
  );

  return porNome ? String(porNome.id_inst_bancaria) : "";
};

const extrairValorCampo = (valor: any) => {
  if (valor && typeof valor === "object" && "value" in valor) {
    return valor.value;
  }
  return valor;
};

const obterInstituicaoBancaria = (
  codInst: any,
  instituicoesBancarias: any[] = [],
) =>
  instituicoesBancarias.find(
    (inst) => String(inst.id_inst_bancaria) === String(extrairValorCampo(codInst)),
  );

const obterCodCompensacaoInstituicao = (
  codInst: any,
  instituicoesBancarias: any[] = [],
  meio?: any,
) => {
  if (meio?.codCompensacao_inst_bancaria) {
    return String(meio.codCompensacao_inst_bancaria).trim();
  }

  return String(
    obterInstituicaoBancaria(codInst, instituicoesBancarias)
      ?.codCompensacao_inst_bancaria ?? "",
  ).trim();
};

export const sanitizarPayloadMeioPagamento = (
  data: any,
  instituicoesBancarias: any[] = [],
) => {
  const tipo = normalizarTipoMeio(extrairValorCampo(data?.tipo_meio_recebimento));
  const pagarPara = normalizarPagarPara(
    extrairValorCampo(data?.pagarPara_meio_recebimento),
  );

  const payload: Record<string, any> = {
    codIndicador_meio_recebimento: data?.codIndicador_meio_recebimento,
    tipo_meio_recebimento: tipo,
  };

  if (data?.id_meio_recebimento) {
    payload.id_meio_recebimento = data.id_meio_recebimento;
  }

  if (data?.status_meio_recebimento !== undefined) {
    payload.status_meio_recebimento = data.status_meio_recebimento;
  }

  if (tipo === "1") {
    const codInst = extrairValorCampo(data?.cod_inst_bancaria_meio_recebimento);
    const instituicao = obterInstituicaoBancaria(codInst, instituicoesBancarias);

    payload.pagarPara_meio_recebimento = pagarPara;
    payload.cod_inst_bancaria_meio_recebimento = codInst;
    payload.banco_meio_recebimento = String(
      instituicao?.nome_inst_bancaria ?? data?.banco_meio_recebimento ?? "",
    ).trim();
    payload.tipoChavePix_meio_recebimento = extrairValorCampo(
      data?.tipoChavePix_meio_recebimento,
    );
    payload.chavePix_meio_recebimento = String(
      data?.chavePix_meio_recebimento ?? "",
    ).trim();
    payload.nomeTitular_meio_recebimento = String(
      data?.nomeTitular_meio_recebimento ?? "",
    ).trim();
    payload.agencia_meio_recebimento = "";
    payload.contaCorrente_meio_recebimento = "";
  } else if (tipo === "2") {
    const codInst = extrairValorCampo(data?.cod_inst_bancaria_meio_recebimento);
    const instituicao = obterInstituicaoBancaria(codInst, instituicoesBancarias);

    payload.pagarPara_meio_recebimento = pagarPara;
    payload.cod_inst_bancaria_meio_recebimento = codInst;
    payload.banco_meio_recebimento = String(
      instituicao?.nome_inst_bancaria ?? data?.banco_meio_recebimento ?? "",
    ).trim();
    payload.agencia_meio_recebimento = String(
      data?.agencia_meio_recebimento ?? "",
    ).trim();
    payload.contaCorrente_meio_recebimento = String(
      data?.contaCorrente_meio_recebimento ?? "",
    ).trim();
    payload.nomeTitular_meio_recebimento = String(
      data?.nomeTitular_meio_recebimento ?? "",
    ).trim();
  }

  return payload;
};

const normalizarTipoMeio = (valor: any) => {
  const bruto = extrairValorCampo(valor);
  const tipo = String(bruto ?? "").trim();

  if (tipo === "0" || tipo === "Dinheiro") return "0";
  if (tipo === "1" || tipo === "Pix") return "1";
  if (
    tipo === "2" ||
    tipo === "Transferência/Depósito Bancário" ||
    tipo === "Transferencia/Deposito Bancario"
  ) {
    return "2";
  }

  return tipo;
};

const normalizarPagarPara = (valor: any) => {
  const bruto = extrairValorCampo(valor);
  if (bruto === 0 || bruto === "0" || bruto === "Indicador") return "0";
  if (bruto === 1 || bruto === "1" || bruto === "Outra pessoa") return "1";
  return String(bruto ?? "");
};

export const validarMeioPagamento = (
  data: any,
  meiosExistentes: any[] = [],
  idMeioAtual?: string | number,
  instituicoesBancarias: any[] = [],
) => {
  const tipo = normalizarTipoMeio(extrairValorCampo(data?.tipo_meio_recebimento));

  if (!tipo) {
    return "Selecione um método de recebimento.";
  }

  const outrosMeios = meiosExistentes.filter(
    (meio) => String(meio.id_meio_recebimento) !== String(idMeioAtual ?? ""),
  );

  if (tipo === "0") {
    const jaTemDinheiro = outrosMeios.some(
      (meio) => normalizarTipoMeio(meio.tipo_meio_recebimento) === "0",
    );
    if (jaTemDinheiro) {
      return "Dinheiro só pode ser cadastrado uma vez por indicador.";
    }
    return null;
  }

  const pagarPara = normalizarPagarPara(
    extrairValorCampo(data?.pagarPara_meio_recebimento),
  );
  if (!pagarPara) {
    return "Selecione se o pagamento é em nome do indicador ou de outra pessoa.";
  }

  if (tipo === "1") {
    const codInst = extrairValorCampo(data?.cod_inst_bancaria_meio_recebimento);
    if (!codInst) {
      return "Selecione a instituição bancária.";
    }

    if (!obterInstituicaoBancaria(codInst, instituicoesBancarias)) {
      return "Instituição bancária inválida.";
    }

    if (!extrairValorCampo(data?.tipoChavePix_meio_recebimento)) {
      return "Selecione o tipo de chave PIX.";
    }
    if (!String(data?.chavePix_meio_recebimento ?? "").trim()) {
      return "Informe a chave PIX.";
    }
    if (!String(data?.nomeTitular_meio_recebimento ?? "").trim()) {
      return "Informe o nome do titular.";
    }

    const chavePix = String(data.chavePix_meio_recebimento).trim().toLowerCase();
    const pixDuplicado = outrosMeios.some((meio) => {
      if (normalizarTipoMeio(meio.tipo_meio_recebimento) !== "1") return false;
      return (
        String(meio.chavePix_meio_recebimento ?? "")
          .trim()
          .toLowerCase() === chavePix
      );
    });

    if (pixDuplicado) {
      return "Esta chave PIX já foi cadastrada para este indicador.";
    }

    return null;
  }

  if (tipo === "2") {
    const codInst = extrairValorCampo(data?.cod_inst_bancaria_meio_recebimento);
    if (!codInst) {
      return "Selecione a instituição bancária.";
    }

    if (!obterInstituicaoBancaria(codInst, instituicoesBancarias)) {
      return "Instituição bancária inválida.";
    }

    const camposTransferencia = [
      { campo: "agencia_meio_recebimento", mensagem: "Informe a agência." },
      {
        campo: "contaCorrente_meio_recebimento",
        mensagem: "Informe a conta corrente.",
      },
      {
        campo: "nomeTitular_meio_recebimento",
        mensagem: "Informe o nome do titular.",
      },
    ];

    for (const { campo, mensagem } of camposTransferencia) {
      if (!String(data?.[campo] ?? "").trim()) {
        return mensagem;
      }
    }

    const codCompensacao = obterCodCompensacaoInstituicao(
      codInst,
      instituicoesBancarias,
    );
    const agencia = String(data?.agencia_meio_recebimento ?? "").trim();
    const conta = String(data?.contaCorrente_meio_recebimento ?? "").trim();

    const transferenciaDuplicada = outrosMeios.some((meio) => {
      if (normalizarTipoMeio(meio.tipo_meio_recebimento) !== "2") return false;

      const compensacaoOutro = obterCodCompensacaoInstituicao(
        meio.cod_inst_bancaria_meio_recebimento,
        instituicoesBancarias,
        meio,
      );

      return (
        compensacaoOutro !== "" &&
        compensacaoOutro === codCompensacao &&
        String(meio.agencia_meio_recebimento ?? "").trim() === agencia &&
        String(meio.contaCorrente_meio_recebimento ?? "").trim() === conta
      );
    });

    if (transferenciaDuplicada) {
      return "Esta combinação de código do banco, agência e conta já foi cadastrada para este indicador.";
    }
  }

  return null;
};

export const obterTituloErroMeioPagamento = (mensagem: string) => {
  const msgLower = mensagem.toLowerCase();
  if (
    msgLower.includes("chave pix") ||
    msgLower.includes("dinheiro só pode") ||
    msgLower.includes("já foi cadastrada") ||
    msgLower.includes("ja foi cadastrada") ||
    msgLower.includes("código do banco") ||
    msgLower.includes("codigo do banco") ||
    msgLower.includes("combinação de")
  ) {
    return "Método De Pagamento Já Existe!";
  }
  return "Campos obrigatórios";
};

export const exibirErroValidacaoMeioPagamento = async (mensagem: string) => {
  await Swal.fire({
    icon: "error",
    title: obterTituloErroMeioPagamento(mensagem),
    text: mensagem,
  });
};

const FormMeioRecebimento = ({
  defaultValues,
  onSubmitFunction,
  indicador,
  meiosPagamentoExistentes = [],
  listdata,
  children,
}: any) => {
  const { handleSubmit: handleSubmitMeioPagamento, ...formMeioPagamento } =
    GetForm();
  const [metodoRecebimento, setMetodoRecebimento] = useState(
    normalizarTipoMeio(defaultValues?.tipo_meio_recebimento),
  );
  const [pagarPara, setPagarPara] = useState(
    normalizarPagarPara(defaultValues?.pagarPara_meio_recebimento),
  );
  const [metodoRecebimentoPix, setMetodoRecebimentoPix] = useState(
    defaultValues?.tipoChavePix_meio_recebimento,
  );
  const [meiosExistentes, setMeiosExistentes] = useState<any[]>([]);
  const [instituicoesBancarias, setInstituicoesBancarias] = useState<any[]>([]);
  const [instituicaoSelecionada, setInstituicaoSelecionada] = useState(() =>
    resolverCodInstituicaoMeio(defaultValues, []),
  );
  const meiosExtrasRef = useRef<any[]>(MEIOS_EXTRAS_VAZIO);
  const instituicaoFormSincronizadaRef = useRef<string | null>(null);

  useEffect(() => {
    let ativo = true;

    listarInstBancarias().then((instituicoes) => {
      if (!ativo) return;
      setInstituicoesBancarias(instituicoes ?? []);
    });

    return () => {
      ativo = false;
    };
  }, []);

  const codInstituicaoResolvido = useMemo(
    () => resolverCodInstituicaoMeio(defaultValues, instituicoesBancarias),
    [
      defaultValues?.id_meio_recebimento,
      defaultValues?.cod_inst_bancaria_meio_recebimento,
      defaultValues?.id_inst_bancaria,
      defaultValues?.banco_meio_recebimento,
      defaultValues?.nome_inst_bancaria,
      instituicoesBancarias,
    ],
  );

  const opcoesInstituicoesBancarias = useMemo(
    () =>
      instituicoesBancarias
        .filter(
          (instituicao) =>
            String(instituicao.status_inst_bancaria) !== "0" ||
            String(instituicao.id_inst_bancaria) === codInstituicaoResolvido,
        )
        .sort(
          (a, b) =>
            Number(a?.codCompensacao_inst_bancaria ?? 0) -
            Number(b?.codCompensacao_inst_bancaria ?? 0),
        )
        .map((instituicao) => ({
          value: String(instituicao.id_inst_bancaria),
          label: `${instituicao.id_inst_bancaria} - ${instituicao.nome_inst_bancaria}`,
          idInstituicao: instituicao.id_inst_bancaria,
          nomeInstituicao: instituicao.nome_inst_bancaria,
          codCompensacao: instituicao.codCompensacao_inst_bancaria,
        })),
    [instituicoesBancarias, codInstituicaoResolvido],
  );

  const codigoCompensacaoSelecionado = useMemo(() => {
    const instituicao = instituicoesBancarias.find(
      (item) => String(item.id_inst_bancaria) === String(instituicaoSelecionada),
    );

    if (instituicao?.codCompensacao_inst_bancaria) {
      return instituicao.codCompensacao_inst_bancaria;
    }

    if (
      defaultValues?.codCompensacao_inst_bancaria &&
      String(instituicaoSelecionada) === String(codInstituicaoResolvido)
    ) {
      return defaultValues.codCompensacao_inst_bancaria;
    }

    return "";
  }, [
    instituicaoSelecionada,
    instituicoesBancarias,
    defaultValues?.codCompensacao_inst_bancaria,
    codInstituicaoResolvido,
  ]);

  useEffect(() => {
    instituicaoFormSincronizadaRef.current = null;
    setInstituicaoSelecionada(codInstituicaoResolvido || "");
  }, [defaultValues?.id_meio_recebimento, codInstituicaoResolvido]);

  useEffect(() => {
    const idMeio = String(defaultValues?.id_meio_recebimento ?? "novo");
    const cod = codInstituicaoResolvido;

    if (!cod) {
      return;
    }

    setInstituicaoSelecionada(cod);

    if (
      !opcoesInstituicoesBancarias.length ||
      instituicaoFormSincronizadaRef.current === idMeio
    ) {
      return;
    }

    const opcao = opcoesInstituicoesBancarias.find(
      (opcaoInst) => String(opcaoInst.value) === String(cod),
    );

    if (opcao) {
      formMeioPagamento.setValue("cod_inst_bancaria_meio_recebimento", opcao);
      instituicaoFormSincronizadaRef.current = idMeio;
    }
  }, [
    defaultValues?.id_meio_recebimento,
    codInstituicaoResolvido,
    opcoesInstituicoesBancarias,
  ]);

  const limparCamposTransferencia = () => {
    formMeioPagamento.setValue("agencia_meio_recebimento", "");
    formMeioPagamento.setValue("contaCorrente_meio_recebimento", "");
  };

  const limparCamposPix = () => {
    formMeioPagamento.setValue("tipoChavePix_meio_recebimento", "");
    formMeioPagamento.setValue("chavePix_meio_recebimento", "");
    setMetodoRecebimentoPix(undefined);
  };

  const limparCamposInstituicao = () => {
    formMeioPagamento.setValue("cod_inst_bancaria_meio_recebimento", "");
    setInstituicaoSelecionada("");
    instituicaoFormSincronizadaRef.current = null;
  };

  const sincronizarSchemaFormulario = () => {
    const camposSchema: Record<string, yup.AnySchema> = {
      tipo_meio_recebimento: yup
        .string()
        .transform((valor) =>
          valor && typeof valor === "object" && "value" in valor
            ? String(valor.value)
            : String(valor ?? ""),
        )
        .required("Selecione um método de recebimento"),
    };

    const camposParaRemover: string[] = [];

    if (metodoRecebimento === "1" || metodoRecebimento === "2") {
      camposSchema.pagarPara_meio_recebimento = yup
        .string()
        .transform((valor) =>
          valor && typeof valor === "object" && "value" in valor
            ? String(valor.value)
            : String(valor ?? ""),
        )
        .required("Selecione se é em nome do indicador");
    } else {
      camposParaRemover.push("pagarPara_meio_recebimento");
    }

    if ((metodoRecebimento === "1" || metodoRecebimento === "2") && pagarPara) {
      camposSchema.cod_inst_bancaria_meio_recebimento = yup
        .string()
        .transform((valor) =>
          valor && typeof valor === "object" && "value" in valor
            ? String(valor.value)
            : String(valor ?? ""),
        )
        .required("Selecione a instituição bancária");
    } else {
      camposParaRemover.push("cod_inst_bancaria_meio_recebimento");
    }

    if (metodoRecebimento === "1" && pagarPara) {
      camposSchema.tipoChavePix_meio_recebimento = yup
        .string()
        .transform((valor) =>
          valor && typeof valor === "object" && "value" in valor
            ? String(valor.value)
            : String(valor ?? ""),
        )
        .required("Digite um tipo de chave");
      camposSchema.chavePix_meio_recebimento = yup
        .string()
        .required("Digite uma chave pix");
      camposSchema.nomeTitular_meio_recebimento = yup
        .string()
        .required("Digite nome do Títular");
      camposParaRemover.push(
        "agencia_meio_recebimento",
        "contaCorrente_meio_recebimento",
      );
    } else if (metodoRecebimento === "2" && pagarPara) {
      camposSchema.agencia_meio_recebimento = yup
        .string()
        .required("Digite uma agência");
      camposSchema.contaCorrente_meio_recebimento = yup
        .string()
        .required("Digite uma conta corrente");
      camposSchema.nomeTitular_meio_recebimento = yup
        .string()
        .required("Digite nome do Títular");
      camposParaRemover.push(
        "tipoChavePix_meio_recebimento",
        "chavePix_meio_recebimento",
      );
    } else {
      camposParaRemover.push(
        "tipoChavePix_meio_recebimento",
        "chavePix_meio_recebimento",
        "nomeTitular_meio_recebimento",
        "agencia_meio_recebimento",
        "contaCorrente_meio_recebimento",
      );
    }

    if (metodoRecebimento === "0") {
      camposParaRemover.push(
        "cod_inst_bancaria_meio_recebimento",
        "pagarPara_meio_recebimento",
        "nomeTitular_meio_recebimento",
        "tipoChavePix_meio_recebimento",
        "chavePix_meio_recebimento",
        "agencia_meio_recebimento",
        "contaCorrente_meio_recebimento",
      );
    }

    if (camposParaRemover.length > 0) {
      formMeioPagamento.unregister(camposParaRemover);
    }

    formMeioPagamento.setYupSchema(yup.object().shape(camposSchema));
    camposParaRemover.forEach((campo) =>
      formMeioPagamento.clearErrors(campo),
    );
  };

  useEffect(() => {
    sincronizarSchemaFormulario();
  }, [metodoRecebimento, pagarPara]);

  meiosExtrasRef.current =
    meiosPagamentoExistentes.length > 0
      ? meiosPagamentoExistentes
      : Array.isArray(listdata) && listdata.length > 0
        ? listdata
        : MEIOS_EXTRAS_VAZIO;

  useEffect(() => {
    const mesclarMeios = (meiosApi: any[] = []) => {
      const ids = new Set<string>();
      const mesclados: any[] = [];

      [...meiosApi, ...meiosExtrasRef.current].forEach((meio) => {
        const chave = meio?.id_meio_recebimento
          ? String(meio.id_meio_recebimento)
          : JSON.stringify(meio);

        if (ids.has(chave)) return;
        ids.add(chave);
        mesclados.push(meio);
      });

      setMeiosExistentes(mesclados);
    };

    if (!indicador?.id_indicador) {
      mesclarMeios([]);
      return;
    }

    let ativo = true;

    listarMeiosPagamento().then((meios) => {
      if (!ativo) return;

      const meiosIndicador = (meios || []).filter(
        (meio: any) =>
          String(meio.codIndicador_meio_recebimento) ===
          String(indicador.id_indicador),
      );
      mesclarMeios(meiosIndicador);
    });

    return () => {
      ativo = false;
    };
  }, [indicador?.id_indicador, listdata, meiosPagamentoExistentes]);

  useEffect(() => {
    if (pagarPara === "0" && indicador) {
      formMeioPagamento.setValue(
        "nomeTitular_meio_recebimento",
        indicador.nome_indicador,
      );
      formMeioPagamento.setValue(
        "chavePix_meio_recebimento",
        metodoRecebimentoPix === "email"
          ? indicador.email_indicador
          : metodoRecebimentoPix === "cpf"
            ? indicador.cpfCnpj_indicador
            : metodoRecebimentoPix === "celular"
              ? indicador.telefone_indicador
              : "",
      );
    } else if (pagarPara === "1") {
      if (!defaultValues?.nomeTitular_meio_recebimento) {
        formMeioPagamento.setValue("nomeTitular_meio_recebimento", "");
      }
      if (!defaultValues?.chavePix_meio_recebimento) {
        formMeioPagamento.setValue("chavePix_meio_recebimento", "");
      }
    }
  }, [
    pagarPara,
    metodoRecebimentoPix,
    indicador?.id_indicador,
    indicador?.nome_indicador,
    indicador?.email_indicador,
    indicador?.cpfCnpj_indicador,
    indicador?.telefone_indicador,
    defaultValues?.nomeTitular_meio_recebimento,
    defaultValues?.chavePix_meio_recebimento,
  ]);

  const handleSubmit = async (data: any) => {
    const dadosFormulario = {
      ...data,
      tipo_meio_recebimento:
        extrairValorCampo(data?.tipo_meio_recebimento) ?? metodoRecebimento,
      pagarPara_meio_recebimento:
        extrairValorCampo(data?.pagarPara_meio_recebimento) ?? pagarPara,
      tipoChavePix_meio_recebimento:
        extrairValorCampo(data?.tipoChavePix_meio_recebimento) ??
        metodoRecebimentoPix,
      cod_inst_bancaria_meio_recebimento:
        extrairValorCampo(data?.cod_inst_bancaria_meio_recebimento) ??
        (instituicaoSelecionada || codInstituicaoResolvido),
    };

    const payload = sanitizarPayloadMeioPagamento(
      {
        ...dadosFormulario,
        codIndicador_meio_recebimento:
          data?.codIndicador_meio_recebimento ?? indicador?.id_indicador,
      },
      instituicoesBancarias,
    );

    const erroValidacao = validarMeioPagamento(
      payload,
      meiosExistentes,
      defaultValues?.id_meio_recebimento,
      instituicoesBancarias,
    );

    if (erroValidacao) {
      await exibirErroValidacaoMeioPagamento(erroValidacao);
      return;
    }

    return onSubmitFunction(payload);
  };

  return (
    <form
      onSubmit={handleSubmitMeioPagamento(handleSubmit)}
      className="mt-5"
    >
      <InputGroup align="center">
        <InputSelectComponent
          label="Método de Recebimento"
          name="tipo_meio_recebimento"
          formulario={formMeioPagamento}
          width="w-[350px]"
          error="Selecione um método de recebimento"
          required
          options={[
            { value: "0", label: "Dinheiro" },
            { value: "1", label: "Pix" },
            {
              value: "2",
              label: "Transferência/Depósito em Instituição Financeira",
            },
          ]}
          onChange={(e: any) => {
            const novoMetodo = e.value;
            const metodoAnterior = metodoRecebimento;
            setMetodoRecebimento(novoMetodo);

            if (novoMetodo === "0" || metodoAnterior === "0") {
              setPagarPara("");
              formMeioPagamento.setValue("pagarPara_meio_recebimento", "");
            }

            if (novoMetodo === "0") {
              limparCamposInstituicao();
              limparCamposTransferencia();
              limparCamposPix();
              formMeioPagamento.setValue("nomeTitular_meio_recebimento", "");
            } else if (novoMetodo === "1") {
              limparCamposTransferencia();
            } else if (novoMetodo === "2") {
              limparCamposPix();
            }
          }}
          defaultValue={normalizarTipoMeio(
            defaultValues?.tipo_meio_recebimento,
          )}
          skipEffect
        />
      </InputGroup>
      {(metodoRecebimento === "1" || metodoRecebimento === "2") && (
        <InputGroup align="center">
          <InputSelectComponent
            label="Pagar Para"
            name="pagarPara_meio_recebimento"
            formulario={formMeioPagamento}
            width="w-[350px]"
            error="Selecione se é em nome do indicador"
            required
            dynamic
            options={[
              { value: "0", label: "Indicador" },
              { value: "1", label: "Outra pessoa" },
            ]}
            onChange={(e: any) => {
              setPagarPara(e.value);
            }}
            defaultValue={normalizarPagarPara(
              defaultValues?.pagarPara_meio_recebimento,
            )}
            skipEffect
          />
        </InputGroup>
      )}

      {(metodoRecebimento === "1" || metodoRecebimento === "2") && pagarPara && (
        <InputGroup>
          <InputSelectComponent
            key={`inst-banc-${defaultValues?.id_meio_recebimento ?? "novo"}-${opcoesInstituicoesBancarias.length}`}
            label="Instituição Bancária"
            name="cod_inst_bancaria_meio_recebimento"
            formulario={formMeioPagamento}
            error="Selecione a instituição bancária"
            required
            dynamic
            width="w-full"
            options={opcoesInstituicoesBancarias}
            defaultValue={instituicaoSelecionada || undefined}
            onChange={(opcao: any) => {
              const valor = String(opcao?.value ?? "");
              setInstituicaoSelecionada(valor);
              instituicaoFormSincronizadaRef.current = String(
                defaultValues?.id_meio_recebimento ?? "novo",
              );
              formMeioPagamento.setValue(
                "cod_inst_bancaria_meio_recebimento",
                opcao || "",
              );
            }}
            formatOptionLabel={(option: any, { context }) =>
              context === "value" ? (
                <span>
                  {option.idInstituicao} - {option.nomeInstituicao}
                  {option.codCompensacao ? ` (Código: ${option.codCompensacao})` : ""}
                </span>
              ) : (
                <div className="flex flex-col leading-tight py-0.5">
                  <span>
                    {option.idInstituicao} - {option.nomeInstituicao}
                  </span>
                  <span className="text-[11px] text-gray-500 dark:text-gray-400">
                    Código: {option.codCompensacao || "—"}
                  </span>
                </div>
              )
            }
          />

          <Input
            label="Código"
            name="codigo_instituicao_bancaria_exibicao"
            formulario={formMeioPagamento}
            disabled
            defaultValue={codigoCompensacaoSelecionado}
            key={`codigo-${instituicaoSelecionada}`}
          />
        </InputGroup>
      )}

      {metodoRecebimento === "1" && pagarPara && (
        <InputGroup>
          <InputSelectComponent
            label="Tipo de Chave"
            name="tipoChavePix_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite um tipo de chave"
            required
            dynamic
            options={[
              { value: "email", label: "E-mail" },
              { value: "cpf", label: "CPF/CNPJ" },
              { value: "celular", label: "Celular" },
              { value: "aleatoria", label: "Chave Aleatória" },
            ]}
            onChange={(e: any) => {
              formMeioPagamento.setValue("chavePix_meio_recebimento", "");
              setMetodoRecebimentoPix(e.value);
            }}
            defaultValue={defaultValues?.tipoChavePix_meio_recebimento}
            skipEffect
          />

          <Input
            label="Chave Pix"
            name="chavePix_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite uma chave pix"
            type={metodoRecebimentoPix === "email" ? "email" : ""}
            required
            dynamic
            disabled={pagarPara === "0" && metodoRecebimentoPix === "cpf"}
            defaultValue={
              pagarPara === "0" && metodoRecebimentoPix === "cpf"
                ? indicador?.cpfCnpj_indicador
                : defaultValues?.chavePix_meio_recebimento
            }
            mascara={
              metodoRecebimentoPix === "cpf"
                ? "cpfCnpj"
                : metodoRecebimentoPix === "celular"
                  ? "telefone"
                  : metodoRecebimentoPix === "aleatoria"
                    ? "letrasNumeros"
                    : undefined
            }
          />

          <Input
            label="Nome do Títular"
            name="nomeTitular_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite nome do Títular"
            required
            dynamic
            defaultValue={
              pagarPara === "0" && !defaultValues?.nomeTitular_meio_recebimento
                ? indicador?.nome_indicador
                : defaultValues?.nomeTitular_meio_recebimento
            }
          />
        </InputGroup>
      )}

      {metodoRecebimento === "2" && pagarPara && (
        <InputGroup>
          <Input
            label="Instituição Financeira"
            name="banco_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite uma instituição financeira"
            required
            mascara="letras"
            defaultValue={
              defaultValues && defaultValues["banco_meio_recebimento"]
            }
          />

          <Input
            label="Nº da Agência"
            name="agencia_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite uma agência"
            required
            dynamic
            mascara="numerico"
            defaultValue={defaultValues?.agencia_meio_recebimento}
          />

          <Input
            label="Nº da Conta Corrente"
            name="contaCorrente_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite uma conta corrente"
            required
            dynamic
            mascara="numerico"
            defaultValue={defaultValues?.contaCorrente_meio_recebimento}
          />

          <Input
            label="Nome do Títular"
            name="nomeTitular_meio_recebimento"
            formulario={formMeioPagamento}
            error="Digite nome do Títular"
            required
            dynamic
            defaultValue={
              pagarPara === "0" && !defaultValues?.nomeTitular_meio_recebimento
                ? indicador?.nome_indicador
                : defaultValues?.nomeTitular_meio_recebimento
            }
          />
        </InputGroup>
      )}
      {children}
    </form>
  );
};
export default FormMeioRecebimento;