import { describe, it, expect, vi, beforeEach } from 'vitest'
import { login, getInfo, logout, changePassword } from '@/api/login'
import * as request from '@/utils/request'

// Mock request module
vi.mock('@/utils/request', () => ({
  get: vi.fn(),
  post: vi.fn()
}))

describe('Login API', () => {
  beforeEach(() => {
    vi.clearAllMocks()
  })

  describe('login', () => {
    it('should call POST /admin/auth/login with credentials', async () => {
      const mockResponse = {
        code: 200,
        message: 'success',
        data: {
          token: 'test-token',
          tokenType: 'Bearer',
          expiresIn: 3600,
          admin: {
            id: 1,
            username: 'admin',
            nickname: 'Admin',
            role: 'admin'
          }
        }
      }
      vi.mocked(request.post).mockResolvedValue(mockResponse)

      const result = await login({ username: 'admin', password: 'password123' })

      expect(request.post).toHaveBeenCalledWith('/admin/auth/login', {
        username: 'admin',
        password: 'password123'
      })
      expect(result.code).toBe(200)
      expect(result.data.token).toBe('test-token')
    })

    it('should handle login failure', async () => {
      const mockResponse = {
        code: 401,
        message: '用户名或密码错误',
        data: null
      }
      vi.mocked(request.post).mockResolvedValue(mockResponse)

      const result = await login({ username: 'wrong', password: 'wrong' })

      expect(result.code).toBe(401)
      expect(result.message).toBe('用户名或密码错误')
    })
  })

  describe('getInfo', () => {
    it('should call GET /admin/auth/info', async () => {
      const mockResponse = {
        code: 200,
        message: 'success',
        data: {
          id: 1,
          username: 'admin',
          nickname: 'Admin',
          role: 'admin',
          lastLoginAt: '2024-01-01T00:00:00Z'
        }
      }
      vi.mocked(request.get).mockResolvedValue(mockResponse)

      const result = await getInfo()

      expect(request.get).toHaveBeenCalledWith('/admin/auth/info')
      expect(result.code).toBe(200)
      expect(result.data.username).toBe('admin')
    })
  })

  describe('logout', () => {
    it('should call POST /admin/auth/logout', async () => {
      const mockResponse = {
        code: 200,
        message: 'success',
        data: null
      }
      vi.mocked(request.post).mockResolvedValue(mockResponse)

      const result = await logout()

      expect(request.post).toHaveBeenCalledWith('/admin/auth/logout')
      expect(result.code).toBe(200)
    })
  })

  describe('changePassword', () => {
    it('should call POST /admin/auth/password with password data', async () => {
      const mockResponse = {
        code: 200,
        message: '密码修改成功',
        data: null
      }
      vi.mocked(request.post).mockResolvedValue(mockResponse)

      const result = await changePassword({
        oldPassword: 'oldpass',
        newPassword: 'newpass'
      })

      expect(request.post).toHaveBeenCalledWith('/admin/auth/password', {
        oldPassword: 'oldpass',
        newPassword: 'newpass'
      })
      expect(result.code).toBe(200)
    })

    it('should handle wrong old password', async () => {
      const mockResponse = {
        code: 400,
        message: '原密码错误',
        data: null
      }
      vi.mocked(request.post).mockResolvedValue(mockResponse)

      const result = await changePassword({
        oldPassword: 'wrongpass',
        newPassword: 'newpass'
      })

      expect(result.code).toBe(400)
      expect(result.message).toBe('原密码错误')
    })
  })
})