import { z } from "zod";
import { civilities } from "../../data/user";

// --------------------------------------------------------------------------------------------------

const electedMemberSchemaBase = {
  civility: z.enum(civilities, {
    required_error: "La civilité et obligatoire",
    invalid_type_error: "La civilité est invalide",
  }),
  lastName: z
    .string({ required_error: "Le nom est obligatoire" })
    .min(1, "Le nom est obligatoire")
    .max(250, "250 caractères au maximum"),
  firstName: z
    .string({ required_error: "Le prénom est obligatoire" })
    .min(1, "Le prénom est obligatoire")
    .max(250, "250 caractères au maximum"),

  positionId: z
    .string({ required_error: "La fonction est obligatoire" })
    .min(1, "La fonction est obligatoire"),

  phoneNumber: z
    .string({ required_error: "Le numéro de téléphone est obligatoire" })
    .refine((value) => /^0[67]\d{8}$/.test(value), {
      message: "Le numéro de téléphone est invalide (06******** ou 07********)",
    }),
  adresse: z.string().max(250, "250 caractères au maximum"),

  email: z
    .string({ required_error: "L'adresse mail est obligatoire" })
    .email({ message: "L'adresse mail est invalide" })
    .max(250, "250 caractères au maximum"),

  collegeId: z
    .string({ required_error: "Le collège est obligatoire" })
    .min(1, { message: "Le collège est obligatoire" }),

  provinceId: z
    .string({ required_error: "La province est obligatoire" })
    .min(1, { message: "La province est obligatoire" }),

  mandateId: z
    .string({ required_error: "Le mondat est obligatoire" })
    .min(1, { message: "Le mondat est obligatoire" }),

  commissions: z.array(z.string()),
  details: z.string().max(4000, "4000 caractères au maximum"),
};

export const electedMemberSchema = z.object({
  ...electedMemberSchemaBase,
  password: z
    .string({ required_error: "Le mot de passe est obligatoire" })
    .min(8, { message: "8 caractères au minimum" })
    .refine((value) => /^(?=.*[a-z])/.test(value), {
      message: "Le mot de passe doit contenir au moins une lettre minuscule",
    })
    .refine((value) => /^(?=.*[A-Z])/.test(value), {
      message: "Le mot de passe doit contenir au moins une lettre majuscule",
    })
    .refine((value) => /^(?=.*\d)/.test(value), {
      message: "Le mot de passe doit contenir au moins un chiffre",
    })
    .refine((value) => /^(?=.*[^\da-zA-Z])/.test(value), {
      message: "Le mot de passe doit contenir au moins un caractère spécial",
    }),
});

export type ElectedMemberSchema = z.infer<typeof electedMemberSchema>;

// --------------------------------------------------------------------------------

export const editElectedMemberSchema = z.object({
  ...electedMemberSchemaBase,
});

export type EditElectedMemberSchema = z.infer<typeof editElectedMemberSchema>;

// --------------------------------------------------------------------------------

export const emailSchema = z.object({
  electedMembers: z
    .array(z.string())
    .min(1, { message: "Vous devez selectionner au moins un membre elu" }),
  subject: z
    .string({ required_error: "L'objet est obligatoire" })
    .min(1, "L'objet est obligatoire")
    .max(500, "500 caractères au maximum"),
  body: z
    .string({ required_error: "Le message est obligatoire" })
    .min(1, "Le message est obligatoire"),
});

export type EmailSchema = z.infer<typeof emailSchema>;

// --------------------------------------------------------------------------------------------------

export const electedMemebrActiveSchema = z.object({
  active: z.boolean(),
});

export type ElectedMemebrActiveSchema = z.infer<
  typeof electedMemebrActiveSchema
>;

//----------------------------------------------------------------------------------------

export const editElectedMemberPasswordSchema = z.object({
  password: z
    .string({ required_error: "Le mot de passe est obligatoire" })
    .min(8, { message: "8 caractères au minimum" })
    .refine((value) => /^(?=.*[a-z])/.test(value), {
      message: "Le mot de passe doit contenir au moins une lettre minuscule",
    })
    .refine((value) => /^(?=.*[A-Z])/.test(value), {
      message: "Le mot de passe doit contenir au moins une lettre majuscule",
    })
    .refine((value) => /^(?=.*\d)/.test(value), {
      message: "Le mot de passe doit contenir au moins un chiffre",
    })
    .refine((value) => /^(?=.*[^\da-zA-Z])/.test(value), {
      message: "Le mot de passe doit contenir au moins un caractère spécial",
    }),
});

export type EditElectedMemberPasswordSchema = z.infer<
  typeof editElectedMemberPasswordSchema
>;
//----------------------------------------------------------------------------------------

export const notificationSchema = z.object({
  electedMembers: z
    .array(z.string())
    .min(1, { message: "Vous devez selectionner au moins un membre élu" }),
  content: z
    .string({ required_error: "Le message est obligatoire" })
    .min(1, "Le message est obligatoire")
    .max(500, "500 caractères au maximum"),
});

export type NotificationSchema = z.infer<typeof notificationSchema>;

//---------------------------------------------------------------------------------

export const smsSchema = z.object({
  electedMembers: z
    .array(z.string())
    .min(1, { message: "Vous devez selectionner au moins un membre élu" }),
  content: z
    .string({ required_error: "Le message est obligatoire" })
    .min(1, "Le message est obligatoire")
    .max(500, "500 caractères au maximum"),
});

export type SmsSchema = z.infer<typeof smsSchema>;

//---------------------------------------------------------------------------------
