export const userNameValidator =
    (entityName: string) =>
    (_: unknown, value: string | undefined): Promise<void> => {
        if (!value) {
          return Promise.reject(new Error(`Please Enter ${entityName} Name`));
        }
        if (!/^[A-Za-z ]*$/.test(value)) {
          return Promise.reject(new Error('Please Enter Alphabets Only'));
        }
        if (value.length > 50) {
          return Promise.reject(new Error('Maximum 50 Characters Allowed'));
        }
        if (value.length < 2) {
          return Promise.reject(new Error('Minimum 2 Characters Required'));
        }
        if (value.trim() !== value || value.includes('  ')) {
          return Promise.reject(new Error('Only Single Spaces Allowed In Between Words'));
        }
        return Promise.resolve();
      };
export const leadUserNameValidator =
    (entityName: string) =>
    (_: unknown, value: string | undefined): Promise<void> => {
        if (!value) {
          return Promise.reject(new Error(`Please Enter ${entityName} Name`));
        }
        // if (!/^[A-Za-z ]*$/.test(value)) {
        //     return Promise.reject(new Error('Please Enter Alphabets Only'))
        // }
        if (value.length > 50) {
          return Promise.reject(new Error('Maximum 50 Characters Allowed'));
        }
        if (value.length < 2) {
          return Promise.reject(new Error('Minimum 2 Characters Required'));
        }
        // if (value.trim() !== value || value.includes('  ')) {
        //     return Promise.reject(new Error('Only Single Spaces Allowed In Between Words'))
        // }
        return Promise.resolve();
      };

export const userEmailValidator =
    (entityName: string, required: boolean = true) =>
    (_: unknown, value: string | undefined): Promise<void> => {
        if (required) {
          if (!value) {
            return Promise.reject(new Error(`Please Enter ${entityName} an Email Address`));
          }
        }
        if (
          value &&
            !/^[a-zA-Z0-9]+([_.-]+[a-zA-Z0-9]+)*@([A-Za-z0-9]+[-_]?[A-Za-z0-9]+)+(\.[a-zA-Z]{2,})+$/.test(
              value
            )
        ) {
          return Promise.reject(new Error('Please Enter a Valid Email'));
        }
        if (value && value.length > 70) {
          return Promise.reject(new Error('Email Must be at Most 70 Characters Long'));
        }
        return Promise.resolve();
      };

export const userPhoneNoValidator =
  (entityName: string, required: boolean = true) =>
  (_: unknown, value: { number: string } | string | undefined): Promise<void> => {
    // If value is an object, grab its `.number`.
    const phone =
      typeof value === 'object' && value !== null
        ? value.number
        : (value as string | undefined) ?? '';

    // “required” check on the extracted phone string
    if (required && !phone) {
      return Promise.reject(new Error(`Please enter ${entityName} phone number.`));
    }

    // regex and length checks against the phone string
    const phoneRegex = /^\+?\d[\d\s-]*$/;
    if (phone && (!phoneRegex.test(phone) || phone.length < 5 || phone.length > 20)) {
      return Promise.reject(
        new Error(
          `${entityName} number must be between 5 and 20 characters long and may include digits, spaces, and hyphens. Only the optional "+" sign is allowed at the beginning.`
        )
      );
    }
    return Promise.resolve();
  };

export const userEmployeePhoneNoValidator =
    (entityName: string, required: boolean = true) =>
    (_: unknown, value: string | undefined): Promise<void> => {
        if (required) {
          if (!value) {
            return Promise.reject(new Error(`Please Enter ${entityName} Phone No.`));
          }
        }
        // if (value && value.length > 12) {
        //     return Promise.reject(new Error('Maximum 12 Digits Allowed'))
        // }
        // if (value && value.length < 10) {
        //     return Promise.reject(new Error('Minimum 10 Digits Required'))
        // }
        if (value && !/^\d{10}$|^\d{12}$/.test(value)) {
          return Promise.reject(new Error('Please Enter Numeric Value Only 10 or 12 digits'));
        }

        return Promise.resolve();
      };

export const changeNewPasswordValidator =  (_: unknown, value: string | undefined): Promise<void> => {
  if (!value) {
    return Promise.reject(new Error('Please Enter New Password'));
  }
  if (value.length > 128) {
    return Promise.reject(new Error('Password Must be at Most 128 Characters Long'));
  }
  if (value.length < 8) {
    return Promise.reject(new Error('Password Must be at Least 8 Characters Long'));
  }
  if (!/^(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&#*^()_+=])[A-Za-z\d@$!%*?&#*^()_+=]+$/.test(value)) {
    return Promise.reject(
      new Error('Must Enter at Least 1 Uppercase Letter, 1 Number, and 1 Special Character')
    );
  }
  return Promise.resolve();
};

export const changeOldPasswordValidator =  (_: unknown, value: string | undefined): Promise<void> => {
  if (!value) {
    return Promise.reject(new Error('Please Enter Old Password'));
  }
  if (value.length > 128) {
    return Promise.reject(new Error('Password Must be at Most 128 Characters Long'));
  }
  if (value.length < 8) {
    return Promise.reject(new Error('Password Must be at Least 8 Characters Long'));
  }
  if (!/^(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&#*^()_+=])[A-Za-z\d@$!%*?&#*^()_+=]+$/.test(value)) {
    return Promise.reject(
      new Error('Must Enter at Least 1 Uppercase Letter, 1 Number, and 1 Special Character')
    );
  }
  return Promise.resolve();
};

export const leadsValidator =  (_: unknown, value: string | undefined): Promise<void> => {
  if (value === undefined || value === null || value === '') {
    return Promise.reject(new Error('Please Enter Field Sales Leads'));
  }
  const valueString = String(value);

  if (!/^\d+$/.test(valueString)) {
    return Promise.reject(new Error('Please enter a valid number. No letters or symbols allowed.'));
  }
  if (valueString.length > 2) {
    return Promise.reject(new Error('Maximum 2 Digits Allowed'));
  }

  return Promise.resolve();
};

export const salesLeadsValidator = (entityName: string, required: boolean = true) => {
  return (_: unknown, value: string): Promise<void> => {
    // Trim the value if it's a string to check for empty spaces
    value = value?.trim();

    if (required && !value) {
      return Promise.reject(new Error(`Please Enter ${entityName} Leads`));
    }
    if (value?.length > 2) {
      return Promise.reject(new Error('Maximum 2 Digits Allowed'));
    }
    if (value && !/^[1-9]\d?$/.test(value)) {
      return Promise.reject(new Error('Please Enter a Numeric Value Greater Than 0'));
    }

    return Promise.resolve();
  };
};

export const configurationNameValidator =
    (entityName: string) =>
      (_: unknown, value: string): Promise<void> => {
        if (!value) {
          return Promise.reject(new Error(`Please Enter ${entityName} Name`));
        }
        if (!/^[A-Za-z0-9. ]*$/.test(value)) {
          return Promise.reject(new Error('Please Enter Alphanumeric Only'));
        }
        if (value.length > 50) {
          return Promise.reject(new Error('Maximum 50 Characters Allowed'));
        }
        if (value.length < 2) {
          return Promise.reject(new Error('Minimum 2 Characters Required'));
        }
        if (value.trim() !== value || value.includes('  ')) {
          return Promise.reject(new Error('Only Single Spaces Allowed In Between Words'));
        }
        return Promise.resolve();
      };

// export const configurationNameValidator =
//     (entityName: string) =>
//     (_: any, value: string): Promise<void> => {
//         if (!value) {
//             return Promise.reject(new Error(`Please Enter ${entityName} Name`))
//         }
//         // Check if the value has a correct form for alphanumeric or decimal number
//         if (!/^[A-Za-z0-9 ]+(\.[0-9]+)?[A-Za-z]*$/.test(value)) {
//             return Promise.reject(
//                 new Error('Please Enter Alphanumeric or Numeric Decimal Values Only')
//             )
//         }
//         if (value.length > 50) {
//             return Promise.reject(new Error('Maximum 50 Characters Allowed'))
//         }
//         if (value.length < 2) {
//             return Promise.reject(new Error('Minimum 2 Characters Required'))
//         }
//         if (value.trim() !== value || value.includes('  ')) {
//             return Promise.reject(new Error('Only Single Spaces Allowed In Between Words'))
//         }
//         // Check if the number of decimal points is acceptable (one or none in a correct place)
//         if ((value.match(/\./g) || []).length > 1) {
//             return Promise.reject(new Error('Only One Decimal Point Allowed In A Number'))
//         }
//         return Promise.resolve()
//     }

export const ticketSizeValidator =
    () =>
      (_: unknown, value: string): Promise<void> => {
        if (!value) {
          return Promise.reject(new Error('Please Enter Ticket Size'));
        }
        if (value && (isNaN((Number(value))) || Number(value) <= 0)) {
          return Promise.reject(new Error('Please Enter a Numeric Value Greater Than 0.'));
        }
        if (value && value.length < 3) {
          return Promise.reject(new Error('Minimum 3 Digits Required'));
        }
        if (value && value.length > 12) {
          return Promise.reject(new Error('Maximum 12 Digits Allowed'));
        }
        return Promise.resolve();
      };

export const leadRemarkValidator =
    (entityName: string, required: boolean = true) =>
      (_: unknown, value: string): Promise<void> => {
        if (!value) {
          if (required) {
            return Promise.reject(new Error(`Please Enter a ${entityName}`));
          }
          return Promise.resolve();
        }
        // if (!/^[A-Za-z0-9.\n\r ]*$/.test(value)) {
        //     return Promise.reject(new Error('Please Enter Alphanumeric Only'));
        // }

        if (value.length > 2500) {
          return Promise.reject(new Error('Maximum 2500 Characters Allowed'));
        }
        if (value.length < 2) {
          return Promise.reject(new Error('Minimum 2 Characters Required'));
        }
        // if (value.trim() !== value || value.includes('  ')) {
        //     return Promise.reject(new Error('Only Single Spaces Allowed In Between Words'))
        // }
        return Promise.resolve();
      };

export const leadBudgetValidator =
    (entityName: string) =>
      (_: unknown, value: string): Promise<void> => {
        if (!value) {
          return Promise.reject(new Error(`Please Enter ${entityName} Budget`));
        }
        if (!/^\d+(\.\d+)?$/.test(value)) {
          return Promise.reject(new Error('Please Enter Numeric Value Only'));
        }
        const numericValue = parseInt(value, 10);
        if (numericValue <= 0) {
          return Promise.reject(new Error('Please Enter a Numeric Value Greater Than 0'));
        }
        if (value.length > 12) {
          return Promise.reject(new Error('Maximum 12 Characters Allowed'));
        }
        if (value.length < 3) {
          return Promise.reject(new Error('Minimum 3 Characters Required'));
        }
        return Promise.resolve();
      };

export const salaryValidator =
    () =>
      (_: unknown, value: string): Promise<void> => {
        if (!value) {
          return Promise.reject(new Error('Please Enter Salary'));
        }
        if (typeof value === 'string' && value?.includes('.')) {
          return Promise.reject(new Error('Decimal Values Are Not Allowed'));
        }
        if (!/^\d+$/.test(value)) {
          return Promise.reject(new Error('Please Enter Numeric Value Only'));
        }
        if (value?.length < 4) {
          return Promise.reject(new Error('Minimum 4 Digits required For Salary'));
        }
        if (value?.length > 10) {
          return Promise.reject(new Error('Maximum 10 Digits Allowed For Salary'));
        }
        return Promise.resolve();
      };

export const cityDropDownValidator =  (_: unknown, value: number[]): Promise<void> => {

  if (!value || value.length === 0) {
    return Promise.reject(new Error('Please select city'));
  }
  return Promise.resolve();
}

export const reportingToValidator = (_: unknown, value: number[]): Promise<void> => {
  if (!value || value.length === 0) {
    return Promise.reject(new Error('Please select reporting to'));
  }
  return Promise.resolve();
}

// export const subordinateToValidator = (_: unknown, value: number[]): Promise<void> => {
//   if (!value || value.length === 0) {
//     return Promise.reject(new Error('Please select subordinate(s)'));
//   }
//   return Promise.resolve();
// }