// addCompanyFormSchema.ts
import { emailField, phoneField } from "@/schema/common.schema";
import * as z from "zod";

export const preprocessNumber = (val: unknown) => {
  if (val == null || val === "") return undefined;

  const num = typeof val === "string" ? Number(val.trim()) : Number(val);
  return Number.isNaN(num) ? undefined : num;
};

// Step 1: Basic Details
export const step1Schema = z.object({
  name: z
    .string({
      required_error: "Company name is required",
    })
    .min(2, { message: "Company name must be at least 2 characters." }),

  gstNumber: z
    .string()
    .length(15)
    .trim()
    .optional()
    .refine(
      (val) =>
        !val || /^\d{2}[A-Z]{5}\d{4}[A-Z]{1}[A-Z\d]{1}Z[A-Z\d]{1}$/.test(val),
      { message: "Invalid GST Number" }
    ),

  panNumber: z
    .string()
    .length(10)
    .trim()
    .optional()
    .refine((val) => !val || /^[A-Z]{5}[0-9]{4}[A-Z]{1}$/.test(val), {
      message: "Invalid PAN Number",
    }),

  companyType: z.string().min(1, {
    message: "Company type is required",
  }),

  websiteUrl: z
    .string()
    .trim()
    .optional()
    .refine(
      (val) => !val || /^https?:\/\/[\w\-]+(\.[\w\-]+)+[/#?]?.*$/.test(val),
      { message: "Invalid URL" }
    ),

  logo: z
    .any()
    .optional()
    .refine((file) => !file || (file instanceof File && file.size > 0), {
      message: "Invalid logo file",
    }),

  color: z.string().optional(),
});

// Step 2: Location Details
export const step2Schema = z.object({
  address: z

    .string({
      required_error: "Address is required",
    })
    .min(1, {
      message: "Address is required",
    }),
  city: z.string().min(1, "City is required"),
  state: z.string().min(1, "State is required"),
  country: z.string().min(1, "Country is required"),
  pincode: z.preprocess(
    preprocessNumber,
    z
      .number({
        required_error: "Pincode is required",
        invalid_type_error: "Pincode must be a number",
      })
      .int()
      .min(100000, { message: "Pincode must be 6 digits" })
      .max(999999, { message: "Pincode must be 6 digits" })
  ),
});

// Step 3: Admin Details
export const step3Schema = z.object({
  firstName: z.string({
    required_error: "First name is required",
  }),
  lastName: z.string({
    required_error: "Last name is required",
  }),
  email: emailField({
    required: true,
  }),
  phone: phoneField(),
});

// Step 4: Plan Details (Base schema without superRefine)

export const step4Schema = z.object({
  maxUserCount: z.preprocess(
    preprocessNumber,
    z
      .number({
        required_error: "Maximum user count is required",
        invalid_type_error: "Maximum user count must be a number",
      })
      .positive("Maximum user count must be greater than 0")
  ),
  planValidityUnit: z.enum(["days", "months", "years"], {
    required_error: "Plan validity unit is required",
  }),
  planValidity: z.preprocess(
    preprocessNumber,
    z
      .number({
        required_error: "Plan validity is required",
        invalid_type_error: "Plan validity must be a number",
      })
      .positive("Plan validity must be greater than 0")
  ),
  price: z.preprocess(
    preprocessNumber,
    z
      .number({
        required_error: "Price is required",
        invalid_type_error: "Price must be a number",
      })
      .positive("Price must be greater than 0")
  ),
  discount: z.preprocess(
    preprocessNumber,
    z
      .number({ invalid_type_error: "Discount must be a number" })
      .max(100, "Discount cannot exceed 100%")
      .optional()
  ),
  tax: z.string().optional(),
  whatsAppCredit: z.preprocess(
    preprocessNumber,
    z.number({
      required_error: "WhatsApp credit is required",
      invalid_type_error: "WhatsApp credit must be a number",
    })
  ),
  smsCredit: z.preprocess(
    preprocessNumber,
    z.number(
      {
        required_error: "SMS credit is required",
        invalid_type_error: "SMS credit must be a number",
      }
    )
  ),
  emailCredit: z.preprocess(
    preprocessNumber,
    z.number({
      required_error: "Email credit is required",
      invalid_type_error: "Email credit must be a number",
    })
  ),
  finalPrice: z.preprocess(
    preprocessNumber,
    z.number({
      required_error: "Final Price is required",
      invalid_type_error: "Final Price must be a number",
    })
  ),
});

// Complete schema with validation
export const schema = step1Schema
  .merge(step2Schema)
  .merge(step3Schema)
  .merge(step4Schema)
  .superRefine((data, ctx) => {
    const { planValidity, planValidityUnit } = data;
    const validityValue = Number(planValidity);

    // Validate that planValidity is a valid number
    if (isNaN(validityValue) || validityValue <= 0) {
      ctx.addIssue({
        path: ["planValidity"],
        code: z.ZodIssueCode.custom,
        message: "Plan validity must be a positive number",
      });
      return;
    }

    // Validate limits based on unit
    // if (planValidityUnit === "days" && validityValue > 30) {
    //   ctx.addIssue({
    //     path: ["planValidity"],
    //     code: z.ZodIssueCode.custom,
    //     message: "Plan validity cannot exceed 30 days",
    //   });
    // }

    // if (planValidityUnit === "months" && validityValue > 12) {
    //   ctx.addIssue({
    //     path: ["planValidity"],
    //     code: z.ZodIssueCode.custom,
    //     message: "Plan validity cannot exceed 12 months",
    //   });
    // }

    // if (planValidityUnit === "years" && validityValue > 5) {
    //   ctx.addIssue({
    //     path: ["planValidity"],
    //     code: z.ZodIssueCode.custom,
    //     message: "Plan validity cannot exceed 5 years",
    //   });
    // }

    // Validate numeric fields
    const numericFields = ["maxUserCount", "price", "tax"];
    numericFields.forEach((field) => {
      const value = Number(data[field as keyof typeof data]);
      if (isNaN(value) || value < 0) {
        ctx.addIssue({
          path: [field],
          code: z.ZodIssueCode.custom,
          message: `${field} must be a valid non-negative number`,
        });
      }
    });

    // Validate discount percentage
    const discountValue = Number(data.discount);
    if (!isNaN(discountValue) && discountValue > 100) {
      ctx.addIssue({
        path: ["discount"],
        code: z.ZodIssueCode.custom,
        message: "Discount cannot exceed 100%",
      });
    }
  });