import { describe, it, expect, vi, beforeEach } from 'vitest'

const { mockGet, mockPost, mockPut, mockDel } = vi.hoisted(() => ({
  mockGet: vi.fn(),
  mockPost: vi.fn(),
  mockPut: vi.fn(),
  mockDel: vi.fn(),
}))

vi.mock('axios', () => ({
  default: {
    create: vi.fn(() => ({
      get: mockGet,
      post: mockPost,
      put: mockPut,
      delete: mockDel,
      interceptors: {
        request: { use: vi.fn() },
        response: { use: vi.fn() },
      },
    })),
  },
}))

import request from '@/utils/request'

describe('request utility', () => {
  beforeEach(() => {
    vi.clearAllMocks()
  })

  describe('get', () => {
    it('should call axios.get with url and params wrapped', async () => {
      mockGet.mockResolvedValue({ data: { code: 200, data: 'test' } })
      const result = await request.get('/test', { id: 1 })
      expect(mockGet).toHaveBeenCalledWith('/test', { params: { id: 1 } })
      expect(result).toEqual({ code: 200, data: 'test' })
    })

    it('should default to empty params object', async () => {
      mockGet.mockResolvedValue({ data: { code: 200, data: 'test' } })
      await request.get('/test')
      expect(mockGet).toHaveBeenCalledWith('/test', { params: {} })
    })

    it('should reject when response code is not 200', async () => {
      mockGet.mockResolvedValue({ data: { code: 400, message: 'Bad request' } })
      await expect(request.get('/test')).rejects.toEqual({ code: 400, message: 'Bad request' })
    })
  })

  describe('post', () => {
    it('should call axios.post with url, data, and empty config', async () => {
      mockPost.mockResolvedValue({ data: { code: 200, data: 'created' } })
      const result = await request.post('/test', { name: 'foo' })
      expect(mockPost).toHaveBeenCalledWith('/test', { name: 'foo' }, {})
      expect(result).toEqual({ code: 200, data: 'created' })
    })

    it('should pass config when provided', async () => {
      mockPost.mockResolvedValue({ data: { code: 200, data: 'ok' } })
      await request.post('/test', null, { params: { id: 1 } })
      expect(mockPost).toHaveBeenCalledWith('/test', null, { params: { id: 1 } })
    })

    it('should reject when response code is not 200', async () => {
      mockPost.mockResolvedValue({ data: { code: 500, message: 'Server error' } })
      await expect(request.post('/test')).rejects.toEqual({ code: 500, message: 'Server error' })
    })
  })

  describe('put', () => {
    it('should call axios.put with url, data, and empty config', async () => {
      mockPut.mockResolvedValue({ data: { code: 200, data: 'updated' } })
      const result = await request.put('/test/1', { name: 'bar' })
      expect(mockPut).toHaveBeenCalledWith('/test/1', { name: 'bar' }, {})
      expect(result).toEqual({ code: 200, data: 'updated' })
    })
  })

  describe('del', () => {
    it('should call axios.delete with url and params wrapped', async () => {
      mockDel.mockResolvedValue({ data: { code: 200, data: 'deleted' } })
      const result = await request.del('/test/1')
      expect(mockDel).toHaveBeenCalledWith('/test/1', { params: {} })
      expect(result).toEqual({ code: 200, data: 'deleted' })
    })

    it('should merge params into config spread for axios.delete', async () => {
      mockDel.mockResolvedValue({ data: { code: 200, data: 'ok' } })
      // del(url, params={reason:'test'}, config={timeout:1000})
      // => axios.delete(url, { params: { reason:'test' }, timeout: 1000 })
      await request.del('/test/1', { reason: 'test' }, { timeout: 1000 })
      expect(mockDel).toHaveBeenCalledWith('/test/1', { params: { reason: 'test' }, timeout: 1000 })
    })
  })

  describe('generic request', () => {
    it('should dispatch GET with params', async () => {
      mockGet.mockResolvedValue({ data: { code: 200, data: 'ok' } })
      const result = await request.request('get', '/test', { id: 1 })
      expect(mockGet).toHaveBeenCalledWith('/test', { params: { id: 1 } })
      expect(result).toEqual({ code: 200, data: 'ok' })
    })

    it('should dispatch POST with data', async () => {
      mockPost.mockResolvedValue({ data: { code: 200, data: 'ok' } })
      await request.request('post', '/test', { name: 'foo' })
      expect(mockPost).toHaveBeenCalledWith('/test', { name: 'foo' }, {})
    })

    it('should dispatch DELETE with params', async () => {
      mockDel.mockResolvedValue({ data: { code: 200, data: 'ok' } })
      await request.request('delete', '/test/1', null)
      expect(mockDel).toHaveBeenCalledWith('/test/1', { params: null })
    })

    it('should throw for unsupported method', () => {
      expect(() => request.request('patch', '/test', null)).toThrow('该功能暂不可用，请刷新后重试')
    })
  })
})