import { z } from "zod";

// Step 1: Basic Info validation
export const basicInfoSchema = z.object({
  campaignName: z
    .string()
    .min(3, "Campaign name must be at least 3 characters")
    .max(100, "Campaign name must not exceed 100 characters"),
  campaignDescription: z.string().optional(),
  campaignLink: z.string().url("Must be a valid URL"),
});

// Step 2: Targeting validation
export const targetingSchema = z.object({
  targetCities: z.array(z.string()).min(1, "Please select at least one city"),
  targetAreas: z.array(z.string()).optional(),
  userIds: z.array(z.string()).min(1, "No relevant users found."),
  budgetRange: z
    .array(z.number())
    .length(2, "Budget range must have min and max values")
    .refine(
      (range) => range[0] < range[1],
      "Minimum budget must be less than maximum budget"
    )
    .refine((range) => range[0] >= 0, "Budget values must be positive"),
  mainCategory: z.string().min(1, "Please select a main category"),
  propertyCategories: z
    .array(z.string())
    .min(1, "Please select at least one property category"),
});

// Step 3: Mediums validation
export const mediumsSchema = z.object({
  communication: z
    .array(z.string())
    .min(1, "Please select at least one communication channel"),
});

// Step 4: Templates validation
export const templatesSchema = z.object({
  templates: z.record(z.string()).refine(
    (templates) => {
      // Check if at least one template is selected for each communication channel
      return Object.values(templates).some(
        (template) => template && template.length > 0
      );
    },
    {
      message: "Please select at least one template",
    }
  ),
});

// Step 5: Team Assignment validation
export const teamAssignmentSchema = z.object({
  selectedTeam: z.string().min(1, "Please select a team"),
});

// Step 6: Schedule validation
export const scheduleSchema = z
  .object({
    scheduleType: z.enum(["immediate", "schedule"]),
    scheduleDate: z.date().nullable(),
    scheduleTime: z.string(),
    targetingStrategy: z.enum(["all", "spread"]),
    spreadDays: z.number().min(1).max(30),
  })
  .refine(
    (data) => {
      if (data.scheduleType === "schedule") {
        return data.scheduleDate !== null;
      }
      return true;
    },
    {
      message: "Please select a schedule date",
      path: ["scheduleDate"],
    }
  )
  .refine(
    (data) => {
      if (data.scheduleType === "schedule" && data.scheduleDate) {
        const scheduledDateTime = new Date(
          `${data.scheduleDate}T${data.scheduleTime}`
        );
        return scheduledDateTime > new Date();
      }
      return true;
    },
    {
      message: "Scheduled date and time must be in the future",
      path: ["scheduleDate"],
    }
  )
  .refine(
    (data) => {
      if (data.targetingStrategy === "spread") {
        return data.spreadDays >= 1;
      }
      return true;
    },
    {
      message: "Please specify spread duration (minimum 1 day)",
      path: ["spreadDays"],
    }
  );

// Complete form schema (for final validation)
// export const campaignFormSchema = z.object({
//   ...basicInfoSchema.shape,
//   ...targetingSchema.shape,
//   ...mediumsSchema.shape,
//   ...templatesSchema.shape,
//   ...teamAssignmentSchema.shape,
//   ...scheduleSchema.shape,
// });

export const campaignFormSchema = basicInfoSchema
  .and(targetingSchema)
  .and(mediumsSchema)
  .and(templatesSchema)
  .and(teamAssignmentSchema)
  .and(scheduleSchema);

export type CampaignFormValues = z.infer<typeof campaignFormSchema>;

// Step validation mapping
export const stepValidationSchemas = {
  1: basicInfoSchema,
  2: targetingSchema,
  3: mediumsSchema,
  4: templatesSchema,
  5: teamAssignmentSchema,
  6: scheduleSchema,
} as const;