import { z } from "zod";
// Registration schema
export const registerSchema = (t: (key: string) => string) =>
  z
    .object({
      // first_name: z.string().min(1, t("validation.first_name")),
      // last_name: z.string().min(1, t("validation.last_name")),
      // username: z.string().min(1, t("validation.username")),
      first_name: z.string().nonempty(t("validation.first_name")).min(3, t("validation.first_name_min")).max(30, t("validation.first_name_max")),
      last_name: z.string().nonempty(t("validation.last_name")).min(3, t("validation.last_name_min")).max(30, t("validation.last_name_max")),
      username: z.string().nonempty(t("validation.username")).min(3, t("validation.username_min")).max(30, t("validation.username_max")),
      phone_number: z.string().nonempty(t("validation.phone_numben_required")).min(7, t("validation.phone_number")),
      // email: z.string().email(t("validation.email_required")),

      email: z
        .string()
        .min(1, t("validation.email_required")) // shows when field is empty
        .email(t("validation.email_invalid")), // shows when format is wrong
      password: z
        .string()
        .nonempty(t("validation.password_requied"))
        .min(8, t("validation.password_min_length"))
        .regex(
          /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&]).+$/,
          t("validation.password_requirements")
        )
        .min(1, t("validation.password_required")),
      password_confirmation: z
        .string()
        .min(1, t("validation.password_confirmation")),
    })
    .refine((data) => data.password === data.password_confirmation, {
      path: ["password_confirmation"],
      message: t("validation.password_not_match"),
    });

// Login schema
export const loginSchema = (t: (key: string) => string) =>
  z.object({
    email_or_phone: z.string().min(1, t("validation.email_required")).email(t("validation.email_invalid")),
    password: z.string().min(1, t("validation.password_required")),
  });

// Forgot password schema
export const forgotPasswordSchema = (t: (key: string) => string) =>
  z.object({
    email_or_phone: z.string().min(1, t("validation.user_email_required")).email(t("validation.email_invalid")),
  });

// Reset password schema
export const resetPasswordSchema = (t: (key: string) => string) =>
  z
    .object({
      // oldPassword: z.string().min(1, t('validation.password_confirmation')),
      password: z
        .string()
         .min(1, t("validation.password_required"))
        .min(8, t("validation.password_min_length"))
        .regex(
          /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$/,
          t("validation.password_requirements")
        ),
      password_confirmation: z
        .string()
        .min(1, t("validation.password_confirmation")),
    })
    .refine((data) => data.password === data.password_confirmation, {
      path: ["password_confirmation"],
      message: t("validation.password_not_match"),
    });

// Reset password schema logged in
export const resetPasswordSchemaLoggedin = (t: (key: string) => string) =>
  z
    .object({
      current_password: z.string().min(1, t("validation.old_password_required")),
      password: z
        .string()
        .min(8, t("validation.password_min_length"))
        .regex(
          /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$/,
          t("validation.password_requirements")
        )
        .min(1, t("validation.password_required")),
      password_confirmation: z
        .string()
        .min(1, t("validation.password_confirmation")),
    })
    .refine((data) => data.password === data.password_confirmation, {
      path: ["password_confirmation"],
      message: t("validation.password_not_match"),
    })
    .refine((data) => data.password !== data.current_password, {
      path: ["password"],
      message: t("validation.new_password_same_as_old"),
    });

// Profile schema
export const profileSchema = (t: (key: string) => string) =>
  z.object({
    //first_name: z.string().min(1, t("validation.first_name_required")).regex(/^[A-Za-z\u0600-\u06FF\s]+$/,t("validation.letters_and_spaces_only")) .max(150, t("validation.max_length_150")),
    middle_name: z.string().optional(),
    //last_name: z.string().min(1, t("validation.last_name_required")).max(150, t("validation.max_length_150")),
    //username: z.string().min(1, t("validation.username_required")),
    first_name: z.string().nonempty(t("validation.first_name")).min(3, t("validation.first_name_min")).max(30, t("validation.first_name_max")),
    last_name: z.string().nonempty(t("validation.last_name")).min(3, t("validation.last_name_min")).max(30, t("validation.last_name_max")),
    username: z.string().nonempty(t("validation.username")).min(3, t("validation.username_min")).max(30, t("validation.username_max")),

    email: z.string().email(t("validation.valid_email")),

    phone: z
      .string()
      .regex(/^[+]?[0-9]{8,15}$/, t("validation.valid_phone"))
      .optional(),

      short_address: z.string().min(1, t("validation.short_address_required")).max(8, t("validation.short_address_max_length")),
      building_name: z.string().min(1, t("validation.building_name_required")).max(6, t("validation.building_name_max_length")),
      street: z.string().min(1, t("validation.street_required")),
      secondary_number: z.string().min(1, t("validation.secondary_number_required")).max(6, t("validation.secondary_number_max_length")),
      district: z.string().min(1, t("validation.district_required")),

    address_line_1: z.string().min(1, t("validation.address_line_1_required")),
    address_line_2: z.string().optional(),

    state: z.object({
      value: z.string().min(1, t("validation.state_required")),
      label: z.string().min(1, t("validation.state_required")),
    }),

    city: z.object({
      value: z.string().min(1, t("validation.city_required")),
      label: z.string().min(1, t("validation.city_required")),
    }),

    postal_code: z.string()
      .min(3, t("validation.postal_code_min_length"))
      .max(6, t("validation.postal_code_max_length")),

    address_phone: z
      .string()
      .regex(/^[+]?[0-9]{8,15}$/, t("validation.valid_phone"))
      .optional(),
    latitude: z
      .string()
      .min(1, t("validation.latitude_required")),

    longitude: z
      .string()
      .min(1, t("validation.longitude_required")),
  });

// Address schema
export const addressSchema = (t: (key: string) => string) =>
  z.object({
    short_address: z.string().min(1, t("validation.short_address_required")).max(8, t("validation.short_address_max_length")),
    building_name: z.string().min(1, t("validation.building_name_required")).max(6, t("validation.building_name_max_length")),
    street: z.string().min(1, t("validation.street_required")),
    secondary_number: z.string().min(1, t("validation.secondary_number_required")).max(6, t("validation.secondary_number_max_length")),
    district: z.string().min(1, t("validation.district_required")),
    address_line_1: z.string().min(1, t("validation.address_line_1_required")),
    address_line_2: z.string().optional(),
    state: z.object({
      value: z.string().min(1, t("validation.state_required")),
      label: z.string().min(1, t("validation.state_required")),
    }),

    city: z.object({
      value: z.string().min(1, t("validation.city_required")),
      label: z.string().min(1, t("validation.city_required")),
    }),

    postal_code: z.string()
      .min(3, t("validation.postal_code_min_length"))
      .max(6, t("validation.postal_code_max_length")),
    phone: z.string().regex(/^[+]?[0-9]{8,15}$/, t("validation.valid_phone")),
    address_type: z.enum(['shipping', 'billing', 'warehouse', 'office', 'profile', 'other']),
    isPrimary: z.boolean().default(false).optional(),
  });

export const requestProductSchema = (t: (key: string) => string) =>
  z.object({
    title: z.string().min(2, t("validation.title_required") + "."),
    description: z.string().min(5, t("validation.description_required") + "."),
    categories: z.array(z.string()).min(1, t("validation.category_required") + "."),
  });

export const contactSchema = (t: (key: string) => string) =>
  z.object({
    mainReason: z.string().min(1, t("validation.main_reason_required") + "."),
    subReason: z.string().min(1, t("validation.sub_reason_required") + "."),
    firstName: z.string().min(1, t("validation.first_name") + "."),
    lastName: z.string().min(1, t("validation.last_name") + "."),
    email: z.string().email(t("validation.email_required") + "."),
    phone_number: z
      .string()
      .regex(/^[+]?[0-9]{8,15}$/, t("validation.valid_phone")),
    description: z.string().min(1, t("validation.description_required") + "."),
  });
export const createPaymentSchema = (t: (key: string) => string) =>
  z.object({
    paymentMethod: z.string().min(1, t("methodRequired")),

    cardholderName: z.string().min(1, t("cardholderRequired")),

    cardNumber: z
      .string()
      .min(1, t("cardNumberRequired"))
      .transform((val) => val.replace(/\s/g, ""))
      .refine((val) => /^\d{16,}$/.test(val), {
        message: t("cardNumberInvalid"),
      }),

    expiryMonth: z
      .string()
      .min(1, t("expiryMonthRequired"))
      .refine((val) => {
        const num = Number(val);
        return num >= 1 && num <= 12;
      }, t("expiryMonthInvalid")),

    expiryYear: z.string().min(1, t("expiryYearRequired")),

    cvc: z
      .string()
      .min(3, t("cvcMin"))
      .max(4, t("cvcMax"))
      .regex(/^\d+$/, t("cvcNumeric")),
  });


// Infer types from schemas if needed
export type RegisterSchemaType = z.infer<ReturnType<typeof registerSchema>>;
export type LoginSchemaType = z.infer<ReturnType<typeof loginSchema>>;
export type ForgotPasswordSchemaType = z.infer<
  ReturnType<typeof forgotPasswordSchema>
>;
export type ResetPasswordSchemaType = z.infer<
  ReturnType<typeof resetPasswordSchema>
>;
export type ResetPasswordSchemaLoggedinType = z.infer<
  ReturnType<typeof resetPasswordSchemaLoggedin>
>;
export type ProfileSchemaType = z.infer<ReturnType<typeof profileSchema>>;
export type AddressSchemaType = z.infer<ReturnType<typeof addressSchema>>;
export type RequestProductSchemaType = z.infer<
  ReturnType<typeof requestProductSchema>
>;
export type ContactSchemaType = z.infer<ReturnType<typeof contactSchema>>;
export type PaymentFormValues = z.infer<ReturnType<typeof createPaymentSchema>>;