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

// Mock the MongoDB connection
const mockDistinct = vi.fn()
const mockCollection = {
  distinct: mockDistinct,
}

vi.mock('@adonisjs/core/services/logger', () => ({
  default: { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
}))

// Mock BaseModel's getDb to return our mock collection
vi.mock('../../../database/base_model.js', () => ({
  BaseModel: class {
    static collectionName = 'devices'
    static getCollection() { return mockCollection }
    static getDb() { return { collection: () => mockCollection } }
  },
}))

import DeviceModel from '../../../app/models/device.js'

describe('DeviceModel.distinctCriteriaValues', () => {
  beforeEach(() => {
    vi.clearAllMocks()
  })

  it('returns distinct manufacturers, ouis and productClasses', async () => {
    mockDistinct
      .mockResolvedValueOnce(['Sagemcom', 'Huawei'])
      .mockResolvedValueOnce(['F8B7FF', '202BC1'])
      .mockResolvedValueOnce(['Livebox 4', 'BM632w'])

    const result = await DeviceModel.distinctCriteriaValues()

    expect(mockDistinct).toHaveBeenCalledTimes(3)
    expect(mockDistinct).toHaveBeenCalledWith('deviceId.manufacturer')
    expect(mockDistinct).toHaveBeenCalledWith('deviceId.oui')
    expect(mockDistinct).toHaveBeenCalledWith('deviceId.productClass')

    expect(result.manufacturers).toEqual(['Huawei', 'Sagemcom'])
    expect(result.ouis).toEqual(['202BC1', 'F8B7FF'])
    expect(result.productClasses).toEqual(['BM632w', 'Livebox 4'])
  })

  it('filters out null and non-string values', async () => {
    mockDistinct
      .mockResolvedValueOnce(['Sagemcom', null, undefined, '', 123])
      .mockResolvedValueOnce([null, 'F8B7FF'])
      .mockResolvedValueOnce(['Livebox 4', null])

    const result = await DeviceModel.distinctCriteriaValues()

    expect(result.manufacturers).toEqual(['Sagemcom'])
    expect(result.ouis).toEqual(['F8B7FF'])
    expect(result.productClasses).toEqual(['Livebox 4'])
  })

  it('returns empty arrays when no devices exist', async () => {
    mockDistinct
      .mockResolvedValueOnce([])
      .mockResolvedValueOnce([])
      .mockResolvedValueOnce([])

    const result = await DeviceModel.distinctCriteriaValues()

    expect(result.manufacturers).toEqual([])
    expect(result.ouis).toEqual([])
    expect(result.productClasses).toEqual([])
  })

  it('sorts results alphabetically', async () => {
    mockDistinct
      .mockResolvedValueOnce(['Zyxel', 'Arcadyan', 'Sagemcom'])
      .mockResolvedValueOnce(['FFFFFF', 'AAAAAA', 'CCCCCC'])
      .mockResolvedValueOnce(['Router Z', 'Box A', 'Modem C'])

    const result = await DeviceModel.distinctCriteriaValues()

    expect(result.manufacturers).toEqual(['Arcadyan', 'Sagemcom', 'Zyxel'])
    expect(result.ouis).toEqual(['AAAAAA', 'CCCCCC', 'FFFFFF'])
    expect(result.productClasses).toEqual(['Box A', 'Modem C', 'Router Z'])
  })
})