import * as v from 'valibot'
import { describe, expect, it } from 'vitest'
import {
  completeProfileSchema,
  forgotPasswordSchema,
  loginSchema,
  registerSchema,
  resetPasswordSchema,
} from '../auth'

function validate<T extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: T, data: unknown) {
  return v.safeParse(schema, data)
}

describe('loginSchema', () => {
  it('accepts valid login data', () => {
    const result = validate(loginSchema, { login: 'user@test.com', password: 'secret' })
    expect(result.success).toBe(true)
  })

  it('rejects empty login', () => {
    const result = validate(loginSchema, { login: '', password: 'secret' })
    expect(result.success).toBe(false)
  })

  it('rejects empty password', () => {
    const result = validate(loginSchema, { login: 'user', password: '' })
    expect(result.success).toBe(false)
  })

  it('accepts optional remember field', () => {
    const result = validate(loginSchema, { login: 'user', password: 'secret', remember: true })
    expect(result.success).toBe(true)
  })
})

describe('registerSchema', () => {
  const validData = {
    username: 'testuser',
    first_name: 'Test',
    last_name: 'User',
    email: 'test@example.com',
    password: 'password123',
    password_confirmation: 'password123',
  }

  it('accepts valid registration data', () => {
    const result = validate(registerSchema, validData)
    expect(result.success).toBe(true)
  })

  it('rejects username shorter than 3 characters', () => {
    const result = validate(registerSchema, { ...validData, username: 'ab' })
    expect(result.success).toBe(false)
  })

  it('rejects username with spaces', () => {
    const result = validate(registerSchema, { ...validData, username: 'test user' })
    expect(result.success).toBe(false)
  })

  it('accepts username with dashes and underscores', () => {
    const result = validate(registerSchema, { ...validData, username: 'test-user_123' })
    expect(result.success).toBe(true)
  })

  it('rejects invalid email', () => {
    const result = validate(registerSchema, { ...validData, email: 'not-an-email' })
    expect(result.success).toBe(false)
  })

  it('rejects password shorter than 8 characters', () => {
    const result = validate(registerSchema, { ...validData, password: 'short', password_confirmation: 'short' })
    expect(result.success).toBe(false)
  })

  it('rejects mismatched passwords', () => {
    const result = validate(registerSchema, { ...validData, password_confirmation: 'different123' })
    expect(result.success).toBe(false)
  })

  it('rejects empty first name', () => {
    const result = validate(registerSchema, { ...validData, first_name: '' })
    expect(result.success).toBe(false)
  })

  it('rejects empty last name', () => {
    const result = validate(registerSchema, { ...validData, last_name: '' })
    expect(result.success).toBe(false)
  })
})

describe('forgotPasswordSchema', () => {
  it('accepts valid email', () => {
    const result = validate(forgotPasswordSchema, { email: 'test@example.com' })
    expect(result.success).toBe(true)
  })

  it('rejects empty email', () => {
    const result = validate(forgotPasswordSchema, { email: '' })
    expect(result.success).toBe(false)
  })

  it('rejects invalid email', () => {
    const result = validate(forgotPasswordSchema, { email: 'not-email' })
    expect(result.success).toBe(false)
  })
})

describe('resetPasswordSchema', () => {
  const validData = {
    email: 'test@example.com',
    password: 'newpassword123',
    password_confirmation: 'newpassword123',
  }

  it('accepts valid reset data', () => {
    const result = validate(resetPasswordSchema, validData)
    expect(result.success).toBe(true)
  })

  it('rejects mismatched passwords', () => {
    const result = validate(resetPasswordSchema, { ...validData, password_confirmation: 'different' })
    expect(result.success).toBe(false)
  })

  it('rejects password shorter than 8 characters', () => {
    const result = validate(resetPasswordSchema, { ...validData, password: 'short', password_confirmation: 'short' })
    expect(result.success).toBe(false)
  })

  it('rejects invalid email', () => {
    const result = validate(resetPasswordSchema, { ...validData, email: 'bad' })
    expect(result.success).toBe(false)
  })
})

describe('completeProfileSchema', () => {
  const validData = {
    username: 'newuser',
    first_name: 'New',
    last_name: 'User',
  }

  it('accepts valid profile data', () => {
    const result = validate(completeProfileSchema, validData)
    expect(result.success).toBe(true)
  })

  it('rejects username shorter than 3 characters', () => {
    const result = validate(completeProfileSchema, { ...validData, username: 'ab' })
    expect(result.success).toBe(false)
  })

  it('rejects username with special characters', () => {
    const result = validate(completeProfileSchema, { ...validData, username: 'user@name' })
    expect(result.success).toBe(false)
  })

  it('rejects empty first name', () => {
    const result = validate(completeProfileSchema, { ...validData, first_name: '' })
    expect(result.success).toBe(false)
  })

  it('rejects empty last name', () => {
    const result = validate(completeProfileSchema, { ...validData, last_name: '' })
    expect(result.success).toBe(false)
  })
})