import * as Yup from "yup";
import { useTranslation } from "../Hooks/useTranslate";

export const YupObject = (schemaObject) => Yup.object().shape(schemaObject);

export const EmailSchema = (messages) => {
  const { emailRequired, emailInvalid = "Please enter valid email" } = messages;
  // return Yup.string().email(emailInvalid).required(emailRequired);
  return Yup.string()
    .email(emailInvalid)
    .required(emailRequired)
    .test("is-valid-domain", emailInvalid, (value) => {
      if (!value) return false;
      const domainPattern = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
      return domainPattern.test(value);
    });
};

export const RequiredField = (message) => {
  return Yup.string().trim().required(message);
};

export const RequiredIntegerField = (messages) => {
  const { nameRequired, nameContain } = messages;
  return Yup.string().matches(/^\d+$/, nameContain).required(nameRequired);
};

export const OnlyIntegerFieldNoRequired = (messages) => {
  const { nameContain, zeroFieldMessage } = messages;

  return Yup.string().test(
    "is-empty-or-positive-integer",
    nameContain,
    function (value) {
      // Allow empty value
      if (value === "" || value === undefined || value === null) {
        return true; // No validation when it's empty
      }

      // Check if the value is a valid positive integer
      const numberValue = parseInt(value, 10);
      if (numberValue === 0) {
        return this.createError({ message: zeroFieldMessage });
      }

      // Check if it's a positive integer
      if (Number.isInteger(numberValue) && numberValue > 0) {
        return true; // Valid positive integer
      }

      // If the value is not a valid positive integer, return the default message
      return this.createError({ message: nameContain });
    }
  );
};

export const RequiredIntegerWithDecimalField = (messages) => {
  const { nameRequired, nameContain } = messages;
  return Yup.string()
    .matches(/^\d+(\.\d+)?$/, nameContain)
    .required(nameRequired)
    .test("min-value", "Budget must be greater than 0.", (value) => {
      return Number(value) >= 1;
    });
};

export const ObjectValidation = (message1, message2) => {
  return Yup.object().shape({
    label: Yup.string().required(message1),
    value: Yup.string().required(message2),
  });
};

export const RequiredWithOnlyAlphabetField = (messages) => {
  const { nameRequired, nameContain } = messages;
  return Yup.string()
    .required(nameRequired)
    .matches(/^(?!\s*$)(?!.*\s{2,})[a-zA-Z]+(?:\s[a-zA-Z]+)*$/, nameContain);
};

export const PhoneNumberSchemaNoRequired = (messages) => {
  const { mobileNumberInvalid } = messages;
  return Yup.string().min(8, mobileNumberInvalid).max(16, mobileNumberInvalid);
};

export const PhoneNumberSchemaRequired = (messages) => {
  const { mobileNumberRequired, mobileNumberInvalid } = messages;
  return Yup.string()
    .required(mobileNumberRequired)
    .min(8, mobileNumberInvalid)
    .max(16, mobileNumberInvalid);
};

export const PasswordRexRequired = (messages) => {
  const { passwordRequired, passwordContain } = messages;
  return Yup.string()
    .required(passwordRequired)
    .matches(/^.{8,}$/, passwordContain);
};

export const PasswordConfirmationSchema = (message) => {
  return Yup.string().oneOf([Yup.ref("password"), undefined], message);
};

// export const PasswordRexWithoutRequired = Yup.string().matches(
//     /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,})/,
//     "Must Contain 8 Characters, One Uppercase, One Lowercase, One Number and One Special Case Character"
// )

// export const PasswordRexRequired = Yup.string().required('Password is required').matches(
//     /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,})/,
//     "Must Contain 8 Characters, One Uppercase, One Lowercase, One Number and One Special Case Character"
// )

export const PasswordRexWithoutRequired = Yup.string().matches(
  /^.{8,}$/,
  "Must Contain 8 Characters"
);

export const OnlyIntegerField = () => {
  return Yup.number().integer().required();
};

export const PasswordSchema = Yup.string()
  .min(8, "Too Short!")
  .max(20, "Too Long!")
  .required();

export const AcceptTermsConditionSchema = Yup.boolean().oneOf(
  [true],
  "You must accept the terms and conditions"
);

export const PhoneNumberSchema = Yup.string()
  .min(8, "Please enter valid number")
  .max(16, "Please enter valid number")
  .required();

const urlValidationSchema = Yup.string().matches(
  /((https?):\/\/)?(www\.)?[a-z0-9]+(\.[a-z]{2,}){1,3}(#?\/?[a-zA-Z0-9#]+)*\/?(\?[a-zA-Z0-9-_]+=[a-zA-Z0-9-%]+&?)?$/,
  "Enter a valid URL!"
);

export const URLArraySchema = Yup.array()
  .of(urlValidationSchema)
  .required("Array is required")
  .min(1, "Array cannot be empty");

export const RequiredArraySchema = Yup.array().min(1);

export const PermissionSchema = Yup.array().of(
  Yup.object().shape({
    limits: Yup.number()
      .min(0, "Minimum limit is 0")
      .required("Limit is required"),
    feature_name: Yup.string().required("Feature name is required"),
    // description: Yup.string().required("Description is required"),
  })
);

export const DateRangeRequiredField = (message) => {
  return Yup.array()
    .test("dates-complete", message, (dates) => {
      return (
        dates && dates.length === 2 && dates[0] !== null && dates[1] !== null
      );
    })
    .nullable();
};

export const DateRequiredField = (message) => {
  return Yup.date().required(message);
};