ValidationService

import { ValidationService } from '@pzeta/vue-form'

export class ValidationService {
  // Valida un valore con regole pipe-separated
  static validate(value: unknown, rules: string): ValidationResult

  // Valida, traduce e restituisce tutto in un'operazione
  static validateAndTranslate(
    value: unknown,
    rules: string,
    t: TranslateFunction,
  ): TranslatedValidationResult

  // Valida con messaggi leggibili senza i18n
  static validateWithFallback(value: unknown, rules: string): TranslatedValidationResult

  // Traduce una singola chiave errore
  static translateError(error: string, t: TranslateFunction): string

  // Traduce un array di chiavi errore
  static translateErrors(errors: string[], t: TranslateFunction): string[]

  // Estrae il messaggio fallback da una chiave i18n (senza t())
  static extractFallback(key: string): string

  // Registra un validatore custom
  static registerValidator(name: string, validator: Validator): void

  // Lista tutti i validatori disponibili
  static getAvailableValidators(): string[]
}

export interface ValidationResult {
  isValid: boolean
  errors: string[]  // chiavi i18n (es. "validation.core.required")
}

export interface TranslatedValidationResult extends ValidationResult {
  translatedErrors: string[]  // messaggi tradotti/leggibili
}

export type TranslateFunction = (
  key: string,
  params?: Record<string, string | number>,
) => string

'required|email'
'required|min:8|max:100'
'required|integer|between:1,100'
'required|codicefiscale'

'required|pattern:^(cat|dog)$' // alternanza nella regex
'enum:a|b,c'                   // valori ammessi: "a|b" e "c"

ValidationService.validate('mario@rossi.it', 'required|emial')
// browser / produzione:            { isValid: false, errors: ['validation.core.unknownValidator|name:emial'] }
// Node con NODE_ENV=development:   Error: ValidationService: validatore "emial" non trovato

"validation.categoria.chiave"              // senza parametri
"validation.core.min|min:5"               // con un parametro
"validation.core.between|min:1,max:100"   // con più parametri

const result = ValidationService.validate('test@example.com', 'required|email')
// { isValid: true, errors: [] }

const invalid = ValidationService.validate('', 'required|email')
// { isValid: false, errors: ['validation.core.required'] }

const tooShort = ValidationService.validate('ab', 'required|min:5')
// { isValid: false, errors: ['validation.core.minString|min:5'] }

import { useI18n } from '@pzeta/vue-i18n'

const { t } = useI18n()

const result = ValidationService.validateAndTranslate(
  '',
  'required|email',
  t,
)
// {
//   isValid: false,
//   errors: ['validation.core.required'],
//   translatedErrors: ['Questo campo è obbligatorio'],
// }

const result = ValidationService.validateWithFallback('', 'required|min:8')
// {
//   isValid: false,
//   errors: ['validation.core.required'],
//   translatedErrors: ['Required'],
// }

const { t } = useI18n()

// Singolo errore con parametro
const msg = ValidationService.translateError('validation.core.minString|min:5', t)
// "Il campo deve contenere almeno 5 caratteri"

// Array di errori
const msgs = ValidationService.translateErrors(
  ['validation.core.required', 'validation.format.email'],
  t,
)
// ['Questo campo è obbligatorio', 'Inserisci un indirizzo email valido']

ValidationService.extractFallback('validation.core.required')
// "Required"

ValidationService.extractFallback('validation.core.minString|min:5')
// "Min 5"

import { ValidationService } from '@pzeta/vue-form'
import type { Validator } from '@pzeta/vue-form'

// Validatore senza parametri
const codiceBudget: Validator = {
  fn: (value: unknown) => {
    const isValid = typeof value === 'string' && /^BDG-\d{4}-[A-Z]{2}$/.test(value)
    return {
      isValid,
      errors: isValid ? [] : ['validation.custom.codiceBudget'],
    }
  },
  parameterized: false,
}

ValidationService.registerValidator('codiceBudget', codiceBudget)

// Validatore con parametro (sintassi `nome:parametro`)
ValidationService.registerValidator('divisibleBy', {
  fn: (value, divisor) => {
    const num = Number(value)
    const div = Number(divisor)
    const isValid = !Number.isNaN(num) && !Number.isNaN(div) && num % div === 0
    return {
      isValid,
      errors: isValid ? [] : [`validation.custom.divisibleBy|divisor:${divisor ?? ''}`],
    }
  },
  parameterized: true,
})

// Ora disponibili nelle regole
ValidationService.validate('BDG-2024-AB', 'required|codiceBudget')
ValidationService.validate(15, 'divisibleBy:5')

const validatori = ValidationService.getAvailableValidators()
console.log(validatori)
// ['required', 'min', 'max', 'email', 'url', 'integer', ..., 'codiceBudget']

import { ValidationService } from '@pzeta/vue-form'
import { useI18n } from '@pzeta/vue-i18n'

const { t } = useI18n()

const validateForm = (formData: { email: string; password: string }) => {
  const emailResult = ValidationService.validateAndTranslate(
    formData.email,
    'required|email',
    t,
  )

  const passwordResult = ValidationService.validateAndTranslate(
    formData.password,
    'required|min:8|password',
    t,
  )

  return {
    isValid: emailResult.isValid && passwordResult.isValid,
    errors: {
      email: emailResult.translatedErrors,
      password: passwordResult.translatedErrors,
    },
  }
}

import { ValidationService } from '@pzeta/vue-form'

export class AnagraficaService {
  validateInput(data: { codiceFiscale: string; email: string }) {
    const cfResult = ValidationService.validateWithFallback(
      data.codiceFiscale,
      'required|codicefiscale',
    )

    const emailResult = ValidationService.validateWithFallback(
      data.email,
      'required|email',
    )

    if (!cfResult.isValid || !emailResult.isValid) {
      throw new Error([
        ...cfResult.translatedErrors,
        ...emailResult.translatedErrors,
      ].join(', '))
    }
  }
}

// Registrazione validatore (forma { fn, parameterized })
ValidationService.registerValidator('partitaIvaOrCf', {
  fn: (value: unknown) => {
    if (typeof value !== 'string' || value.trim() === '') {
      return { isValid: false, errors: ['validation.core.required'] }
    }
    const cfResult = ValidationService.validate(value, 'codicefiscale')
    const pivaResult = ValidationService.validate(value, 'partitaiva')
    const isValid = cfResult.isValid || pivaResult.isValid
    return {
      isValid,
      errors: isValid ? [] : ['validation.italian.cfOrPiva'],
    }
  },
  parameterized: false,
})

// Uso nelle regole
ValidationService.validate('RSSMRA80A01H501U', 'required|partitaIvaOrCf')
// { isValid: true, errors: [] }