// tests/main/services/keybinding-redteam-r2-16.test.ts
// 레드팀 r2-16 회귀 테스트 (데스크톱 어댑터).
//  1) globalShortcut 은 macOS 에서만, 켜진 기능의 바인딩만 예약한다 — Windows 에서 키를 빼앗지 않는다.
//  2) 마우스 hold 바인딩은 누름 중 수정자를 더 눌러도 mouseup 에서 release 된다.
//  3) 사용자가 비운 액션([])은 다른 액션 저장 · 재시작 뒤에도 비어 있다.

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { globalShortcut, ipcMain } from 'electron'
import { uIOhook } from 'uiohook-napi'
import type { UiohookMouseEvent } from 'uiohook-napi'
import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
import { MouseButton, createDefaultBindingMap } from '@d3ro/core/keybinding'
import type { KeyBinding, KeyBindingMap } from '@d3ro/core/types'
import type { IPCResult } from '@d3ro/core/errors'
import {
  acceleratorsToReserve,
  bindingToAccelerator,
  isKeyBindingActionFeatureEnabled
} from '../../../src/main/services/keybinding-accelerator-policy'
import type { ReservableBinding } from '../../../src/main/services/keybinding-accelerator-policy'
import {
  configGet,
  configSet,
  initInMemoryConfig,
  loadKeyBindings,
  resetInMemoryConfig
} from '../../../src/main/services/ConfigService'
import { getKeyBindingService } from '../../../src/main/services/KeyBindingService'
import type { KeyBindingTriggerPayload } from '../../../src/main/services/KeyBindingService'
import { registerKeyBindingHandlers } from '../../../src/main/ipc/keybinding-handlers'

const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')

function setPlatform(platform: NodeJS.Platform): void {
  Object.defineProperty(process, 'platform', { value: platform, configurable: true })
}

function restorePlatform(): void {
  if (originalPlatform) Object.defineProperty(process, 'platform', originalPlatform)
}

function registeredAccelerators(): string[] {
  return vi.mocked(globalShortcut.register).mock.calls.map((call) => String(call[0]))
}

function defaultReservable(): ReservableBinding[] {
  const map = createDefaultBindingMap()
  return (Object.keys(map) as (keyof KeyBindingMap)[]).flatMap((actionId) =>
    map[actionId].map((binding) => ({ actionId, binding }))
  )
}

// ============================================================
// 1) accelerator 예약 정책 (순수)
// ============================================================

describe('acceleratorsToReserve', () => {
  it('Windows 에서는 기본 바인딩을 하나도 예약하지 않는다', () => {
    expect(
      acceleratorsToReserve(defaultReservable(), { platform: 'win32', flags: { suggestionEnabled: true } })
    ).toEqual([])
    expect(
      acceleratorsToReserve(defaultReservable(), { platform: 'linux', flags: { suggestionEnabled: true } })
    ).toEqual([])
  })

  it('macOS 에서 제안 기능이 꺼져 있으면 suggestion-* 바인딩은 예약하지 않는다', () => {
    expect(
      acceleratorsToReserve(defaultReservable(), { platform: 'darwin', flags: { suggestionEnabled: false } })
    ).toEqual(['Control+Shift+V', 'Control+Shift+C'])
  })

  it('macOS 에서 제안 기능이 켜져 있으면 suggestion-* 바인딩도 예약한다', () => {
    expect(
      acceleratorsToReserve(defaultReservable(), { platform: 'darwin', flags: { suggestionEnabled: true } })
    ).toEqual([
      'Control+Shift+V',
      'Control+Shift+C',
      'Control+Alt+Return',
      'Control+Alt+Down',
      'Control+Alt+Up',
      'Control+Alt+Backspace'
    ])
  })

  it('한 바인딩을 공유하는 액션 중 하나라도 켜져 있으면 예약하고, 중복은 한 번만 낸다', () => {
    const shared: KeyBinding = { device: 'keyboard', code: 0x78, ctrl: true, alt: false, shift: true, meta: false }
    expect(
      acceleratorsToReserve(
        [
          { actionId: 'suggestion-next', binding: shared },
          { actionId: 'command-popup', binding: shared }
        ],
        { platform: 'darwin', flags: { suggestionEnabled: false } }
      )
    ).toEqual(['Control+Shift+F9'])
  })

  it('마우스 · 수정자 단독 바인딩은 accelerator 로 표현하지 않는다', () => {
    const x1: KeyBinding = { device: 'mouse', code: MouseButton.Back, ctrl: false, alt: false, shift: false, meta: false }
    expect(bindingToAccelerator(x1, 'darwin')).toBeNull()
    expect(bindingToAccelerator(createDefaultBindingMap().dictation[0]!, 'darwin')).toBeNull()
  })

  it('meta 는 macOS 에서 Cmd, 그 외에서는 Super 다', () => {
    const b: KeyBinding = { device: 'keyboard', code: 0x4b, ctrl: false, alt: false, shift: false, meta: true }
    expect(bindingToAccelerator(b, 'darwin')).toBe('Cmd+K')
    expect(bindingToAccelerator(b, 'win32')).toBe('Super+K')
  })

  it('기능 스위치가 없는 액션은 항상 켜져 있다', () => {
    expect(isKeyBindingActionFeatureEnabled('history-popup', { suggestionEnabled: false })).toBe(true)
    expect(isKeyBindingActionFeatureEnabled('suggestion-accept', { suggestionEnabled: false })).toBe(false)
  })
})

// ============================================================
// 1) + 2) KeyBindingService 어댑터
// ============================================================

describe('KeyBindingService — globalShortcut 예약 · 마우스 release', () => {
  beforeEach(() => {
    initInMemoryConfig()
    vi.mocked(globalShortcut.register).mockClear()
    vi.mocked(globalShortcut.unregister).mockClear()
    vi.mocked(uIOhook.on).mockClear()
  })

  afterEach(() => {
    getKeyBindingService().stop()
    restorePlatform()
    resetInMemoryConfig()
  })

  it('Windows 에서는 기본 설정으로 시작해도 globalShortcut 을 하나도 등록하지 않는다', () => {
    setPlatform('win32')
    const service = getKeyBindingService()
    service.loadFromConfig()
    service.start()
    expect(service.registeredBindingCount).toBeGreaterThan(0)
    expect(globalShortcut.register).not.toHaveBeenCalled()

    configSet('suggestionEnabled', true)
    expect(globalShortcut.register).not.toHaveBeenCalled()
  })

  it('macOS 에서는 켜진 기능만 예약하고, 제안 기능을 켜고 끄면 다시 맞춘다', () => {
    setPlatform('darwin')
    const service = getKeyBindingService()
    service.loadFromConfig()
    service.start()
    expect(registeredAccelerators()).toEqual(['Control+Shift+V', 'Control+Shift+C'])

    vi.mocked(globalShortcut.register).mockClear()
    configSet('suggestionEnabled', true)
    expect(registeredAccelerators()).toContain('Control+Alt+Down')

    vi.mocked(globalShortcut.register).mockClear()
    configSet('suggestionEnabled', false)
    expect(registeredAccelerators()).toEqual(['Control+Shift+V', 'Control+Shift+C'])
  })

  it('X1 hold 중 Alt 를 더 누른 채 버튼을 놓아도 dictation 이 released 된다', () => {
    setPlatform('win32')
    const map = createDefaultBindingMap()
    map.dictation = [{ device: 'mouse', code: MouseButton.Back, ctrl: false, alt: false, shift: false, meta: false }]
    configSet('keyBindings', map)

    const service = getKeyBindingService()
    service.loadFromConfig()
    service.start()

    const handlerOf = (event: string): ((e: UiohookMouseEvent) => void) => {
      const call = vi.mocked(uIOhook.on).mock.calls.find((c) => c[0] === event)
      if (!call) throw new Error(`no ${event} handler`)
      return call[1] as (e: UiohookMouseEvent) => void
    }
    const events: string[] = []
    const listener = (p: KeyBindingTriggerPayload): void => {
      events.push(`${p.actionId}:${p.type}`)
    }
    service.on('triggered', listener)

    const mouseEvent = (alt: boolean): UiohookMouseEvent =>
      ({ button: MouseButton.Back, altKey: alt, ctrlKey: false, shiftKey: false, metaKey: false }) as unknown as UiohookMouseEvent

    handlerOf('mousedown')(mouseEvent(false))
    handlerOf('mouseup')(mouseEvent(true))
    service.off('triggered', listener)

    expect(events).toEqual(['dictation:pressed', 'dictation:released'])
  })
})

// ============================================================
// 3) 비운 액션의 영속
// ============================================================

type Handler = (event: unknown, ...args: unknown[]) => Promise<IPCResult<unknown>>

function captureHandlers(): Map<string, Handler> {
  const handlers = new Map<string, Handler>()
  vi.mocked(ipcMain.handle).mockImplementation((channel: string, handler: Handler) => {
    handlers.set(channel, handler)
  })
  registerKeyBindingHandlers()
  return handlers
}

async function invoke(handlers: Map<string, Handler>, channel: string, params?: unknown): Promise<IPCResult<unknown>> {
  const handler = handlers.get(channel)
  if (!handler) throw new Error(`IPC handler not registered: ${channel}`)
  return handler({}, params)
}

const FREE_BINDING: KeyBinding = { device: 'keyboard', code: 0x78, ctrl: true, alt: false, shift: true, meta: false }

describe('keybinding IPC — 비운 액션 보존', () => {
  beforeEach(() => {
    initInMemoryConfig()
  })

  afterEach(() => {
    getKeyBindingService().stop()
    resetInMemoryConfig()
  })

  it('history-popup 을 비운 뒤 다른 액션을 저장해도 history-popup 은 비어 있다 (GET_MAP 포함)', async () => {
    const handlers = captureHandlers()
    const cleared = await invoke(handlers, IPC_CHANNELS.KEYBINDING.SET_BINDINGS, {
      actionId: 'history-popup',
      bindings: []
    })
    expect(cleared.success).toBe(true)

    const other = await invoke(handlers, IPC_CHANNELS.KEYBINDING.SET_BINDINGS, {
      actionId: 'dictation',
      bindings: [FREE_BINDING]
    })
    expect(other.success).toBe(true)

    expect(configGet('keyBindings')['history-popup']).toEqual([])
    const map = await invoke(handlers, IPC_CHANNELS.KEYBINDING.GET_MAP)
    expect(map.success && (map.data as KeyBindingMap)['history-popup']).toEqual([])
    expect(loadKeyBindings()['history-popup']).toEqual([])
  })

  it('비운 액션은 런타임에도 등록되지 않는다', async () => {
    const handlers = captureHandlers()
    const before = (() => {
      getKeyBindingService().loadFromConfig()
      return getKeyBindingService().registeredBindingCount
    })()
    await invoke(handlers, IPC_CHANNELS.KEYBINDING.SET_BINDINGS, { actionId: 'history-popup', bindings: [] })
    expect(getKeyBindingService().registeredBindingCount).toBe(before - 1)
  })
})

describe('ConfigService 재시작 — 비운 액션 보존', () => {
  afterEach(() => {
    vi.doUnmock('electron-store')
    vi.resetModules()
  })

  it('저장소에 []로 남은 액션은 initConfigService 마이그레이션 뒤에도 [] 다', async () => {
    const persisted: Record<string, unknown> = {
      suggestionTuningRevision: 6,
      keyBindings: { ...createDefaultBindingMap(), 'history-popup': [] }
    }
    const setCalls: string[] = []

    class TestStore<T extends Record<string, unknown>> {
      store: T

      constructor(options: { defaults: T }) {
        this.store = { ...options.defaults, ...persisted } as T
      }

      get<K extends keyof T>(key: K): T[K] {
        return this.store[key]
      }

      set<K extends keyof T>(key: K, value: T[K]): void {
        setCalls.push(String(key))
        this.store[key] = value
      }

      delete(key: string): void {
        delete this.store[key as keyof T]
      }
    }

    vi.doMock('electron-store', () => ({ default: TestStore }))
    const fresh = await import('../../../src/main/services/ConfigService')
    await fresh.initConfigService()

    expect(fresh.configGet('keyBindings')['history-popup']).toEqual([])
    expect(fresh.loadKeyBindings()['history-popup']).toEqual([])
    // 이미 정본 모양이면 다시 쓰지 않는다.
    expect(setCalls).not.toContain('keyBindings')
    fresh.resetInMemoryConfig()
  })

  it('새 액션이 빠진 저장값은 그 액션만 기본값으로 채워 다시 쓴다', async () => {
    const stored: Partial<KeyBindingMap> = { ...createDefaultBindingMap(), 'history-popup': [] }
    delete stored['suggestion-dismiss']
    const persisted: Record<string, unknown> = { suggestionTuningRevision: 6, keyBindings: stored }

    class TestStore<T extends Record<string, unknown>> {
      store: T

      constructor(options: { defaults: T }) {
        this.store = { ...options.defaults, ...persisted } as T
      }

      get<K extends keyof T>(key: K): T[K] {
        return this.store[key]
      }

      set<K extends keyof T>(key: K, value: T[K]): void {
        this.store[key] = value
      }

      delete(key: string): void {
        delete this.store[key as keyof T]
      }
    }

    vi.doMock('electron-store', () => ({ default: TestStore }))
    const fresh = await import('../../../src/main/services/ConfigService')
    await fresh.initConfigService()

    const bindings = fresh.configGet('keyBindings')
    expect(bindings['suggestion-dismiss']).toEqual(createDefaultBindingMap()['suggestion-dismiss'])
    expect(bindings['history-popup']).toEqual([])
    fresh.resetInMemoryConfig()
  })
})