import Input from "@/components/Forms/Input";
import InputGroup from "@/components/Forms/InputGroup";
import InputSelectComponent from "@/components/Forms/InputSelect";
import { listarUsuarios } from "@/requests/CRUD/Usuario/listarUsuarios";
import { useEffect, useState } from "react";

type ItemRegra = {
  considerarName: string;
  valorName: string;
  labelValor: string;
  mascara: "numero" | "numerico";
  prefix?: string;
};

const ITENS_REGRA: ItemRegra[] = [
  {
    considerarName: "considerar_potencia_sistema_aprovacao_parametro",
    valorName: "potencia_sistema_aprovacao_parametro",
    labelValor: "Potência do Sistema >= (kWp)",
    mascara: "numero",
  },
  {
    considerarName: "considerar_potencia_inversor_aprovacao_parametro",
    valorName: "potencia_inversor_aprovacao_parametro",
    labelValor: "Potência do Inversor >= (kW)",
    mascara: "numero",
  },
  {
    considerarName: "considerar_qtde_modulos_aprovacao_parametro",
    valorName: "qtde_modulos_aprovacao_parametro",
    labelValor: "Qtde de módulos >=",
    mascara: "numerico",
  },
  {
    considerarName: "considerar_qtde_inversores_aprovacao_parametro",
    valorName: "qtde_inversores_aprovacao_parametro",
    labelValor: "Qtde de Inversores >=",
    mascara: "numerico",
  },
  {
    considerarName: "considerar_valor_proposta_aprovacao_parametro",
    valorName: "valor_proposta_aprovacao_parametro",
    labelValor: "Valor da Proposta >=",
    mascara: "numero",
    prefix: "R$",
  },
];

const flagConsiderar = (value: any): boolean => {
  if (value === true || value === 1) return true;
  const normalizado = String(value ?? "0").toLowerCase().trim();
  return normalizado === "1" || normalizado === "true";
};

/**
 * "Regra de Aprovação Proposta" tem 3 opções: "0" Sem Regra,
 * "1" Com Regra Composta (AND) e "2" Com Regra Individual (OR).
 * Qualquer valor diferente de "0" exibe os critérios da regra.
 */
const possuiRegraConfigurada = (value: any): boolean => {
  const normalizado = String(value ?? "0").trim();
  return normalizado === "1" || normalizado === "2";
};

const EXPLICACAO_REGRA_APROVACAO = `
  <div style="text-align:left">
    <p><b>Sem Regra:</b> a proposta não passa por nenhuma validação especial de aprovação.</p>
    <p style="margin-top:8px"><b>Com Regra Individual:</b> a aprovação é bloqueada se QUALQUER UM dos critérios marcados como "Considerar" for atingido isoladamente (fator OU/OR entre os critérios).</p>
    <p style="margin-top:8px"><b>Com Regra Composta:</b> a aprovação só é bloqueada quando TODOS os critérios marcados como "Considerar" forem atingidos ao mesmo tempo (fator E/AND entre os critérios).</p>
  </div>
`;

const limparSchemaCampo = (form: any, campo: string) => {
  form.setYupSchema((prev: any) => {
    const fields: any = prev.fields;
    delete fields[campo];
    prev.fields = fields;
    return prev;
  });
};

/**
 * Uma linha "Considerar X" + valor correspondente.
 * Marcado: exige valor. Desmarcado: zera, desregistra e oculta o valor.
 */
const ItemRegraRow = ({
  item,
  form,
  defaultValues,
}: {
  item: ItemRegra;
  form: any;
  defaultValues: any;
}) => {
  const [considerar, setConsiderar] = useState(
    flagConsiderar(defaultValues?.[item.considerarName])
  );

  useEffect(() => {
    setConsiderar(flagConsiderar(defaultValues?.[item.considerarName]));
  }, [defaultValues?.[item.considerarName]]);

  useEffect(() => {
    form.setValue(item.considerarName, considerar ? "1" : "0", {
      shouldDirty: true,
    });

    if (!considerar) {
      form.setValue(item.valorName, "", { shouldDirty: true });
      form.control.unregister([item.valorName], {
        keepError: false,
        keepValue: false,
      });
      limparSchemaCampo(form, item.valorName);
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [considerar]);

  const handleConsiderarChange = (checked: boolean) => {
    setConsiderar(checked);
    form.setValue(item.considerarName, checked ? "1" : "0", {
      shouldDirty: true,
    });

    if (!checked) {
      form.setValue(item.valorName, "", { shouldDirty: true });
      form.control.unregister([item.valorName], {
        keepError: false,
        keepValue: false,
      });
      limparSchemaCampo(form, item.valorName);
    }
  };

  const labelBase = item.labelValor.split(" >=")[0];

  return (
    <InputGroup className="flex flex-col md:flex-row md:items-end gap-2 md:gap-3">
      <Input
        name={item.considerarName}
        label={`Considerar ${labelBase}`}
        formulario={form}
        type="checkbox"
        checked={considerar}
        onChange={(e: any) => handleConsiderarChange(e.target.checked)}
        width="w-full md:w-56"
      />
      {considerar && (
        <Input
          name={item.valorName}
          label={item.labelValor}
          formulario={form}
          mascara={item.mascara}
          prefix={item.prefix}
          defaultValue={defaultValues?.[item.valorName]}
          width="w-full md:w-40"
          required
          error={`Informe o valor de "${labelBase}"`}
        />
      )}
    </InputGroup>
  );
};

const RegrasTab = ({ form, defaultValues }: any) => {
  const [usuarios, setUsuarios] = useState<
    { label: string; value: string | number }[]
  >([]);
  const [comRegra, setComRegra] = useState(
    possuiRegraConfigurada(defaultValues?.regra_aprovacao_proposta_parametro)
  );

  useEffect(() => {
    setComRegra(
      possuiRegraConfigurada(defaultValues?.regra_aprovacao_proposta_parametro)
    );
  }, [defaultValues?.regra_aprovacao_proposta_parametro]);

  useEffect(() => {
    listarUsuarios().then((res: any) => {
      setUsuarios(
        (res || []).map((usuario: any) => ({
          label: usuario.nome_usuario,
          value: String(usuario.id_usuario),
        }))
      );
    });
  }, []);

  useEffect(() => {
    if (comRegra) return;

    ITENS_REGRA.forEach((item) => {
      form.setValue(item.considerarName, "0", { shouldDirty: true });
      form.setValue(item.valorName, "", { shouldDirty: true });
      form.control.unregister([item.valorName], {
        keepError: false,
        keepValue: false,
      });
      limparSchemaCampo(form, item.valorName);
    });
    form.setValue("usuarios_aprovacao_proposta_parametro", null, {
      shouldDirty: true,
    });
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [comRegra]);

  return (
    <div className="w-full flex flex-col gap-4.5 px-2">
      <InputGroup className="flex flex-wrap gap-4">
        <InputSelectComponent
          name="regra_aprovacao_proposta_parametro"
          label="Regra de Aprovação Proposta"
          formulario={form}
          width="w-full md:w-64"
          options={[
            { label: "Sem Regra", value: "0" },
            { label: "Com Regra Individual", value: "2" },
            { label: "Com Regra Composta", value: "1" },
          ]}
          defaultValue={
            defaultValues?.regra_aprovacao_proposta_parametro ?? "0"
          }
          onChange={(e: any) => {
            setComRegra(possuiRegraConfigurada(e?.value));
          }}
          infoMessage={EXPLICACAO_REGRA_APROVACAO}
        />
      </InputGroup>

      {comRegra && (
        <>
          {ITENS_REGRA.map((item) => (
            <ItemRegraRow
              key={item.valorName}
              item={item}
              form={form}
              defaultValues={defaultValues}
            />
          ))}

          <InputGroup className="flex flex-wrap gap-4">
            <InputSelectComponent
              isMulti
              name="usuarios_aprovacao_proposta_parametro"
              label="Usuários que poderão Aprovar"
              formulario={form}
              width="w-full md:w-96"
              options={usuarios}
              defaultValue={
                defaultValues?.usuarios_aprovacao_proposta_parametro
              }
              placeholder="Selecione um ou mais usuários"
            />
          </InputGroup>
        </>
      )}
    </div>
  );
};

export default RegrasTab;