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

// Mock electron's ipcMain
vi.mock('electron', () => ({
  ipcMain: {
    handle: vi.fn(),
    removeHandler: vi.fn()
  }
}))

// Import after mocking
import {
  registerHandler,
  registerHandlers,
  removeHandler,
  removeAllHandlers,
  getRegisteredHandlers,
  isHandlerRegistered
} from '../electron/modules/ipc-registry'
import { ipcMain } from 'electron'

describe('ipc-registry', () => {
  beforeEach(() => {
    // Clear all registered handlers before each test
    removeAllHandlers()
    vi.clearAllMocks()
  })

  describe('registerHandler', () => {
    it('should register a handler', () => {
      const handler = vi.fn()
      registerHandler('test-channel', handler)

      expect(ipcMain.handle).toHaveBeenCalledWith('test-channel', handler)
      expect(isHandlerRegistered('test-channel')).toBe(true)
    })

    it('should replace existing handler with same name', () => {
      const handler1 = vi.fn()
      const handler2 = vi.fn()

      registerHandler('test-channel', handler1)
      registerHandler('test-channel', handler2)

      expect(ipcMain.removeHandler).toHaveBeenCalledWith('test-channel')
      expect(ipcMain.handle).toHaveBeenCalledTimes(2)
    })
  })

  describe('registerHandlers', () => {
    it('should register multiple handlers', () => {
      const handlers = {
        'channel-1': vi.fn(),
        'channel-2': vi.fn(),
        'channel-3': vi.fn()
      }

      registerHandlers(handlers)

      expect(ipcMain.handle).toHaveBeenCalledTimes(3)
      expect(isHandlerRegistered('channel-1')).toBe(true)
      expect(isHandlerRegistered('channel-2')).toBe(true)
      expect(isHandlerRegistered('channel-3')).toBe(true)
    })
  })

  describe('removeHandler', () => {
    it('should remove a registered handler', () => {
      const handler = vi.fn()
      registerHandler('test-channel', handler)

      removeHandler('test-channel')

      expect(ipcMain.removeHandler).toHaveBeenCalledWith('test-channel')
      expect(isHandlerRegistered('test-channel')).toBe(false)
    })

    it('should do nothing for non-existent handler', () => {
      removeHandler('non-existent')

      expect(ipcMain.removeHandler).not.toHaveBeenCalled()
    })
  })

  describe('removeAllHandlers', () => {
    it('should remove all registered handlers', () => {
      registerHandler('channel-1', vi.fn())
      registerHandler('channel-2', vi.fn())
      registerHandler('channel-3', vi.fn())

      removeAllHandlers()

      expect(ipcMain.removeHandler).toHaveBeenCalledTimes(3)
      expect(getRegisteredHandlers()).toHaveLength(0)
    })
  })

  describe('getRegisteredHandlers', () => {
    it('should return all registered handler names', () => {
      registerHandler('channel-1', vi.fn())
      registerHandler('channel-2', vi.fn())

      const handlers = getRegisteredHandlers()

      expect(handlers).toContain('channel-1')
      expect(handlers).toContain('channel-2')
      expect(handlers).toHaveLength(2)
    })

    it('should return empty array when no handlers registered', () => {
      const handlers = getRegisteredHandlers()

      expect(handlers).toHaveLength(0)
    })
  })

  describe('isHandlerRegistered', () => {
    it('should return true for registered handler', () => {
      registerHandler('test-channel', vi.fn())

      expect(isHandlerRegistered('test-channel')).toBe(true)
    })

    it('should return false for non-registered handler', () => {
      expect(isHandlerRegistered('non-existent')).toBe(false)
    })
  })
})