import { z } from 'zod'

// User validation schemas - localized
export const createUserRegistrationSchema = (locale: string = 'ro') => {
  const messages = {
    ro: {
      invalidEmail: 'Email invalid',
      emailMinLength: 'Email-ul trebuie să aibă cel puțin 3 caractere',
      emailMaxLength: 'Email-ul trebuie să aibă maximum 254 caractere',
      passwordMinLength: 'Parola trebuie să aibă cel puțin 8 caractere',
      passwordMaxLength: 'Parola trebuie să aibă maximum 128 caractere',
      passwordComplexity: 'Parola trebuie să conțină cel puțin o literă mică, o literă mare și o cifră',
      nameMinLength: 'Numele trebuie să aibă cel puțin 2 caractere',
      nameMaxLength: 'Numele trebuie să aibă maximum 100 caractere'
    },
    en: {
      invalidEmail: 'Invalid email',
      emailMinLength: 'Email must be at least 3 characters',
      emailMaxLength: 'Email must be maximum 254 characters',
      passwordMinLength: 'Password must be at least 8 characters',
      passwordMaxLength: 'Password must be maximum 128 characters',
      passwordComplexity: 'Password must contain at least one lowercase letter, one uppercase letter and one digit',
      nameMinLength: 'Name must be at least 2 characters',
      nameMaxLength: 'Name must be maximum 100 characters'
    }
  }

  const msg = messages[locale as keyof typeof messages] || messages.ro

  return z.object({
    email: z.string()
      .email(msg.invalidEmail)
      .min(3, msg.emailMinLength)
      .max(254, msg.emailMaxLength),
    password: z.string()
      .min(8, msg.passwordMinLength)
      .max(128, msg.passwordMaxLength)
      .regex(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/, msg.passwordComplexity),
    name: z.string()
      .min(2, msg.nameMinLength)
      .max(100, msg.nameMaxLength)
      .optional()
  })
}

export const createUserLoginSchema = (locale: string = 'ro') => {
  const messages = {
    ro: {
      invalidEmail: 'Email invalid',
      passwordRequired: 'Parola este obligatorie'
    },
    en: {
      invalidEmail: 'Invalid email',
      passwordRequired: 'Password is required'
    }
  }

  const msg = messages[locale as keyof typeof messages] || messages.ro

  return z.object({
    email: z.string().email(msg.invalidEmail),
    password: z.string().min(1, msg.passwordRequired)
  })
}

// Backward compatibility - default to Romanian
export const userRegistrationSchema = createUserRegistrationSchema('ro')
export const userLoginSchema = createUserLoginSchema('ro')

// Chat validation schemas
export const chatMessageSchema = z.object({
  messages: z.array(z.object({
    role: z.enum(['user', 'assistant'], { required_error: 'Rolul este obligatoriu' }),
    content: z.string()
      .min(1, 'Conținutul mesajului este obligatoriu')
      .max(2000, 'Mesajul trebuie să aibă maximum 2000 caractere')
  })).min(1, 'Cel puțin un mesaj este obligatoriu'),
  verseContext: z.string()
    .max(1000, 'Contextul versetului trebuie să aibă maximum 1000 caractere')
    .optional()
})

// Prayer validation schemas
export const prayerRequestSchema = z.object({
  content: z.string()
    .min(10, 'Cererea de rugăciune trebuie să aibă cel puțin 10 caractere')
    .max(1000, 'Cererea de rugăciune trebuie să aibă maximum 1000 caractere')
    .trim(),
  isAnonymous: z.boolean().default(true)
})

// Bookmark validation schemas
export const bookmarkSchema = z.object({
  verseId: z.string()
    .uuid('ID-ul versetului trebuie să fie valid')
    .min(1, 'ID-ul versetului este obligatoriu'),
  note: z.string()
    .max(500, 'Nota trebuie să aibă maximum 500 caractere')
    .optional(),
  color: z.string()
    .regex(/^#[0-9A-F]{6}$/i, 'Culoarea trebuie să fie un cod hex valid')
    .default('#FFD700')
})

// Note validation schemas
export const noteSchema = z.object({
  verseId: z.string()
    .uuid('ID-ul versetului trebuie să fie valid')
    .min(1, 'ID-ul versetului este obligatoriu'),
  content: z.string()
    .min(1, 'Conținutul notei este obligatoriu')
    .max(2000, 'Nota trebuie să aibă maximum 2000 caractere')
    .trim()
})

// Search validation schemas
export const searchSchema = z.object({
  q: z.string()
    .min(1, 'Termenul de căutare este obligatoriu')
    .max(200, 'Termenul de căutare trebuie să aibă maximum 200 caractere')
    .trim(),
  limit: z.coerce.number()
    .min(1, 'Limita trebuie să fie cel puțin 1')
    .max(50, 'Limita trebuie să fie maximum 50')
    .default(10)
})

// Bible navigation validation schemas
export const chapterSchema = z.object({
  book: z.coerce.number()
    .min(1, 'ID-ul cărții trebuie să fie cel puțin 1')
    .max(66, 'ID-ul cărții trebuie să fie maximum 66'),
  chapter: z.coerce.number()
    .min(1, 'Numărul capitolului trebuie să fie cel puțin 1')
    .max(150, 'Numărul capitolului trebuie să fie maximum 150')
})

// User preferences validation schemas
export const userPreferenceSchema = z.object({
  key: z.string()
    .min(1, 'Cheia preferinței este obligatorie')
    .max(50, 'Cheia preferinței trebuie să aibă maximum 50 caractere'),
  value: z.string()
    .max(500, 'Valoarea preferinței trebuie să aibă maximum 500 caractere')
})

// Reading history validation schemas
export const readingHistorySchema = z.object({
  bookId: z.coerce.number()
    .min(1, 'ID-ul cărții trebuie să fie cel puțin 1')
    .max(66, 'ID-ul cărții trebuie să fie maximum 66'),
  chapterNum: z.coerce.number()
    .min(1, 'Numărul capitolului trebuie să fie cel puțin 1')
    .max(150, 'Numărul capitolului trebuie să fie maximum 150'),
  verseNum: z.coerce.number()
    .min(1, 'Numărul versetului trebuie să fie cel puțin 1')
    .max(200, 'Numărul versetului trebuie să fie maximum 200')
    .optional()
})

// Export types for TypeScript
export type UserRegistration = z.infer<typeof userRegistrationSchema>
export type UserLogin = z.infer<typeof userLoginSchema>
export type ChatMessage = z.infer<typeof chatMessageSchema>
export type PrayerRequest = z.infer<typeof prayerRequestSchema>
export type BookmarkData = z.infer<typeof bookmarkSchema>
export type NoteData = z.infer<typeof noteSchema>
export type SearchParams = z.infer<typeof searchSchema>
export type ChapterParams = z.infer<typeof chapterSchema>
export type UserPreference = z.infer<typeof userPreferenceSchema>
export type ReadingHistory = z.infer<typeof readingHistorySchema>