import { describe, expect, it } from "vitest"

import {
  buildCreateUserSchema,
  buildResetUserPasswordSchema,
  buildSetUserActiveSchema,
  buildUpdateUserSchema,
  createUserSchema,
  defaultUserSchemaCopy,
  type UserSchemaCopy,
  updateUserSchema,
} from "@/schemas/user.schema"

const esCopy: UserSchemaCopy = {
  usernameRequired: "El usuario es obligatorio",
  nameRequired: "El nombre es obligatorio",
  emailInvalid: "Correo electrónico no válido",
  passwordMinLength: "La contraseña debe tener al menos 8 caracteres",
  userIdRequired: "El ID de usuario es obligatorio",
}

const validCreateData = {
  username: "admin",
  name: "Admin User",
  email: "admin@example.test",
  password: "password1",
  role: "ADMIN" as const,
  isActive: true,
}

const validUpdateData = {
  id: "user-id",
  username: "admin",
  name: "Admin User",
  email: "admin@example.test",
  role: "ADMIN" as const,
  isActive: true,
}

describe("user schema localization", () => {
  it("buildCreateUserSchema with default copy produces same validation as createUserSchema", () => {
    const result = buildCreateUserSchema(defaultUserSchemaCopy).safeParse({
      username: "",
      name: "",
      email: "bad",
      password: "short",
      role: "INVALID",
      isActive: true,
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors
      expect(errors.username).toContain("Username is required")
      expect(errors.name).toContain("Name is required")
      expect(errors.email).toContain("Invalid email")
      expect(errors.password).toContain(
        "Password must be at least 8 characters",
      )
      // role error comes from z.enum, not our copy
      expect(errors.role).toBeDefined()
    }
  })

  it("buildCreateUserSchema with Spanish copy produces Spanish error messages", () => {
    const result = buildCreateUserSchema(esCopy).safeParse({
      username: "",
      name: "",
      email: "bad",
      password: "short",
      role: "INVALID",
      isActive: true,
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors
      expect(errors.username).toContain(esCopy.usernameRequired)
      expect(errors.name).toContain(esCopy.nameRequired)
      expect(errors.email).toContain(esCopy.emailInvalid)
      expect(errors.password).toContain(esCopy.passwordMinLength)
    }
  })

  it("buildUpdateUserSchema with default copy produces same validation as updateUserSchema", () => {
    const result = buildUpdateUserSchema(defaultUserSchemaCopy).safeParse({
      id: "",
      username: "",
      name: "",
      email: "bad",
      role: "INVALID",
      isActive: true,
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors
      expect(errors.id).toContain("User id is required")
      expect(errors.username).toContain("Username is required")
      expect(errors.name).toContain("Name is required")
      expect(errors.email).toContain("Invalid email")
    }
  })

  it("buildUpdateUserSchema with Spanish copy produces Spanish error messages", () => {
    const result = buildUpdateUserSchema(esCopy).safeParse({
      id: "",
      username: "",
      name: "",
      email: "bad",
      role: "INVALID",
      isActive: true,
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors
      expect(errors.id).toContain(esCopy.userIdRequired)
      expect(errors.username).toContain(esCopy.usernameRequired)
      expect(errors.name).toContain(esCopy.nameRequired)
      expect(errors.email).toContain(esCopy.emailInvalid)
    }
  })

  it("buildSetUserActiveSchema with default copy validates id requirement", () => {
    const result = buildSetUserActiveSchema(defaultUserSchemaCopy).safeParse({
      id: "",
      isActive: true,
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      expect(result.error.flatten().fieldErrors.id).toContain(
        "User id is required",
      )
    }
  })

  it("buildResetUserPasswordSchema with default copy validates password and id", () => {
    const result = buildResetUserPasswordSchema(
      defaultUserSchemaCopy,
    ).safeParse({
      id: "",
      password: "short",
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors
      expect(errors.id).toContain("User id is required")
      expect(errors.password).toContain(
        "Password must be at least 8 characters",
      )
    }
  })

  it("default exports match builder with default copy for valid data", () => {
    expect(createUserSchema.safeParse(validCreateData).success).toBe(true)
    expect(
      buildCreateUserSchema(defaultUserSchemaCopy).safeParse(validCreateData)
        .success,
    ).toBe(true)

    expect(updateUserSchema.safeParse(validUpdateData).success).toBe(true)
    expect(
      buildUpdateUserSchema(defaultUserSchemaCopy).safeParse(validUpdateData)
        .success,
    ).toBe(true)
  })
})