import { useI18n } from "vue-i18n";

const checaMoeda = (moeda) => {
  let currencyOptions = {};

  if (moeda == 1) {
    currencyOptions = {
      locale:          "pt-BR",
      currency:        "BRL",
      currencyDisplay: "symbol",

      hideCurrencySymbolOnFocus:          false,
      hideGroupingSeparatorOnFocus:       false,
      hideNegligibleDecimalDigitsOnFocus: false,
      autoDecimalDigits:                  true,
      useGrouping:                        true,
      accountingSign:                     false,
    };
  } else if (moeda == 2) {
    currencyOptions = {
      currency:        "PYG",
      locale:          "es-PY",
      valueAsInteger:  true,
      distractionFree: true,
      precision:       0,
      autoDecimalMode: true,

      valueRange: { min: 0 },

      allowNegative: true,
    };
  } else if (moeda == 3) {
    currencyOptions = {
      locale:          "en-US",
      currency:        "USD",
      currencyDisplay: "symbol",

      hideCurrencySymbolOnFocus:          true,
      hideGroupingSeparatorOnFocus:       true,
      hideNegligibleDecimalDigitsOnFocus: false,
      autoDecimalDigits:                  true,
      useGrouping:                        true,
      accountingSign:                     false,
    };
  }

  return currencyOptions;
};

const excerpt = (string, size = 30) => {
  if (size == null) return string;

  if (string.length > size) {
    string = string.substring(0, size) + "...";
  }

  return string;
};

// formatters

// formatters de data e hora

const convertDateTime = (dateTimeString) => {
  const dateTime = new Date(dateTimeString);

  const options = {
    timeZone: "America/Sao_Paulo",
    day:      "2-digit",
    month:    "2-digit",
    year:     "numeric",
    hour:     "2-digit",
    minute:   "2-digit",
    second:   "2-digit",
  };

  const formattedDateTime = dateTime
    .toLocaleString("pt-BR", options)
    .replace(",", "");

  return formattedDateTime;
};

const formatDateDMYtoYMD = (date, time) => {
  if (!date) throw new Error(useI18n().t("validation.rules.required"));

  const testDate =
    /^([0-2][0-9]|(3)[0-1])(\/)(((0)[0-9])|((1)[0-2]))(\/)\d{4}$/;

  if (testDate.test(date) === false)
    throw new Error(useI18n().t("validation.rules.date"));

  const [day, month, year] = date.split("/");

  return `${year}-${month}-${day} ${time ? time : ""}`;
};

const formatDateYMDtoDMY = (dateTime) => {
  const [datePart, timePart] = dateTime.split(" ");

  const [year, month, day] = datePart.split("-");

  const formattedDate = `${day}/${month}/${year}`;

  if (timePart) {
    const [hours, minutes, seconds] = timePart.split(":");

    const formattedTime = `${hours}:${minutes}:${seconds}`;

    return `${formattedDate} ${formattedTime}`;
  }

  return formattedDate;
};

// formatters de moeda e number

const convertToCents = (value) => {
  if (value === null || value === undefined || value === "") return null;

  if (typeof value === "number") {
    return Math.round(value * 100);
  }

  if (typeof value === "string") {
    const cleanValue = value.replace(/[R$\s.]/g, "").replace(",", ".");

    const numericValue = parseFloat(cleanValue);

    return isNaN(numericValue) ? null : Math.round(numericValue * 100);
  }

  return null;
};

const formatCurrency = (value) => {
  return new Intl.NumberFormat("pt-BR", {
    style:    "currency",
    currency: "BRL",
    minimumFractionDigits: 2,
  }).format(Number(value ?? 0));
};

const formatCurrencyCompact = (value) => {
  return new Intl.NumberFormat("pt-BR", {
    style:    "currency",
    currency: "BRL",
    notation: "compact",
    maximumFractionDigits: 1,
  }).format(Number(value ?? 0));
};

const formatDecimal = (value) => {
  return Number(value ?? 0).toLocaleString("pt-BR", {
    minimumFractionDigits: 1,
    maximumFractionDigits: 1,
  });
};

const formatInteger = (value) => {
  return Number(value ?? 0).toLocaleString("pt-BR");
};

const formatPercent = (value, digits = 2) => {
  return `${Number(value ?? 0).toFixed(digits).replace(".", ",")}%`;
};

// filters

const filterCurrency = (value) => {
  if (value) {
    value = parseFloat(value);

    return value.toLocaleString("pt-BR", {
      style:    "currency",
      currency: "BRL",
    });
  }

  return value;
};

const filterUnidadeMedida = (value) => {
  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
};

// validators

const validaData = (date) => {
  const regex = /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/\d{4}$/;

  return regex.test(date);
};

const validaHora = (time) => {
  const regex = /^([0-1][0-9]|2[0-3]):[0-5][0-9]$/;

  return regex.test(time);
};

const validaDataHora = (dataHora) => {
  const regex =
    /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/\d{4}\s([0-1][0-9]|2[0-3]):[0-5][0-9]$/;

  return regex.test(dataHora);
};

// outros

const truncatedName = (name) => {
  if (name.length <= 15) return name;

  const extension      = name.split(".").pop();
  const nameWithoutExt = name.substring(0, name.lastIndexOf("."));

  return `${nameWithoutExt.substring(0, 8)}...${extension}`;
};

export const maskCpf = (cpf) => {
  if (!cpf) {
    return "";
  }

  const cleanedCpf = String(cpf).replace(/\D/g, "");

  if (cleanedCpf.length !== 11) {
    console.warn(
      "CPF inválido fornecido para a máscara. Retornando valor original.",
    );

    return cpf;
  }

  const firstPart = cleanedCpf.slice(0, 3);
  const lastPart  = cleanedCpf.slice(9, 11);

  return `${firstPart}.***.***-${lastPart}`;
};

export {
  checaMoeda,
  convertDateTime,
  convertToCents,
  excerpt,
  filterCurrency,
  filterUnidadeMedida,
  formatCurrency,
  formatCurrencyCompact,
  formatDateDMYtoYMD,
  formatDateYMDtoDMY,
  formatDecimal,
  formatInteger,
  formatPercent,
  truncatedName,
  validaData,
  validaDataHora,
  validaHora,
};