import { test } from 'node:test'
import assert from 'node:assert/strict'
import { http } from '../src/shared/api/http.ts'
import {
  runDedupe,
  getDedupeRunProgress,
  getDedupeHistory,
  deleteDedupeHistory,
  getDedupeResultDownloadUrl,
  type DedupeRunRequest,
  type DedupeRunProgressVo,
} from '../src/shared/api/types/modules/dedupe.ts'

function setupWindow() {
  ;(globalThis as Record<string, unknown>).window = {
    localStorage: { getItem: () => '42' },
    location: { origin: 'http://localhost' },
  }
}

function mockRequest(
  t: Parameters<typeof test>[1] extends (t: infer T) => unknown ? T : never,
  impl: (config: { url?: string; method?: string; params?: Record<string, unknown>; data?: unknown }) => Promise<unknown>,
) {
  t.mock.method(http, 'request', impl as never)
}

const okResponse = (data: unknown) => Promise.resolve({ data: { success: true, message: 'ok', data } })

const runningProgress = (runId: string): DedupeRunProgressVo => ({
  runId,
  status: 'running',
  total: 2,
  processedCount: 1,
  successCount: 1,
  failedCount: 0,
  finished: false,
})

test('test_dedupe_run_url', async (t) => {
  setupWindow()
  let captured: { url?: string } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse(runningProgress('run-1'))
  })
  await runDedupe({ files: [{ fileKey: 'k1' }], selectedColumns: ['a'], keepIntegerIds: false, keepUnderscoreIds: false, keepIntegerMainIdsWhenNoSubIds: true })
  assert.equal(captured.url, '/newApi/api/dedupe/run')
})

test('test_dedupe_run_method_payload', async (t) => {
  setupWindow()
  let captured: { method?: string; data?: unknown } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse(runningProgress('run-1'))
  })
  await runDedupe({ files: [{ fileKey: 'k1' }], selectedColumns: ['a'], keepIntegerIds: true, keepUnderscoreIds: true, keepIntegerMainIdsWhenNoSubIds: false })
  assert.equal(captured.method, 'POST')
  assert.deepEqual(captured.data, {
    files: [{ fileKey: 'k1' }],
    selectedColumns: ['a'],
    keepIntegerIds: true,
    keepUnderscoreIds: true,
    keepIntegerMainIdsWhenNoSubIds: false,
    user_id: 42,
  })
})

test('test_dedupe_run_returns_progress', async (t) => {
  setupWindow()
  mockRequest(t, () => okResponse(runningProgress('run-1')))
  const progress = await runDedupe({ files: [{ fileKey: 'k1' }], selectedColumns: ['a'], keepIntegerIds: false, keepUnderscoreIds: false, keepIntegerMainIdsWhenNoSubIds: true })
  assert.equal(progress.runId, 'run-1', 'run 应立即返回 runId')
  assert.equal(progress.status, 'running')
  assert.equal(progress.finished, false)
  assert.equal(progress.result, undefined, '运行中不应携带最终结果')
})

test('test_dedupe_progress_url', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ runId: 'run-1', status: 'success', total: 2, processedCount: 2, successCount: 2, failedCount: 0, finished: true, result: { total: 2, successCount: 2, failedCount: 0, items: [] } })
  })
  const progress = await getDedupeRunProgress('run-1')
  assert.equal(captured.url, '/newApi/api/dedupe/run/run-1/progress')
  assert.equal(captured.method, 'GET')
  assert.equal(progress.status, 'success')
  assert.ok(progress.result, '完成后应返回结果')
})

test('test_dedupe_history_url', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string; params?: Record<string, unknown> } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ items: [] })
  })
  await getDedupeHistory()
  assert.equal(captured.url, '/newApi/api/dedupe/history')
  assert.equal(captured.method, 'GET')
  assert.deepEqual(captured.params, { user_id: 42 })
})

test('test_dedupe_delete_history', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse(null)
  })
  await deleteDedupeHistory(5)
  assert.equal(captured.url, '/newApi/api/dedupe/history/5')
  assert.equal(captured.method, 'DELETE')
})

test('test_dedupe_download_url', async (t) => {
  setupWindow()
  const url = getDedupeResultDownloadUrl(5)
  assert.equal(url, 'http://localhost/newApi/api/dedupe/results/5/download?user_id=42')
})

test('test_dedupe_signature_unchanged', async (t) => {
  setupWindow()
  assert.equal(runDedupe.length, 1, 'runDedupe 应保持单参数')
  assert.equal(getDedupeRunProgress.length, 1, 'getDedupeRunProgress 应保持单参数')
  assert.equal(getDedupeHistory.length, 0, 'getDedupeHistory 应保持无参')
  assert.equal(deleteDedupeHistory.length, 1, 'deleteDedupeHistory 应保持单参数')
  assert.equal(getDedupeResultDownloadUrl.length, 1, 'getDedupeResultDownloadUrl 应保持单参数')
  const request: DedupeRunRequest = {
    files: [{ fileKey: 'k' }],
    selectedColumns: [],
    keepIntegerIds: false,
    keepUnderscoreIds: false,
    keepIntegerMainIdsWhenNoSubIds: false,
    user_id: 1,
  }
  assert.ok(request.user_id === 1)
})

test('test_dedupe_export_compat', async (t) => {
  setupWindow()
  const fromJavaModules = await import('../src/shared/api/java-modules.ts')
  const fromDedupe = await import('../src/shared/api/types/modules/dedupe.ts')
  assert.equal(fromJavaModules.runDedupe, fromDedupe.runDedupe, '旧路径 import 应与新路径同引用')
  assert.equal(fromJavaModules.getDedupeHistory, fromDedupe.getDedupeHistory)
  assert.equal(fromJavaModules.deleteDedupeHistory, fromDedupe.deleteDedupeHistory)
  assert.equal(fromJavaModules.getDedupeResultDownloadUrl, fromDedupe.getDedupeResultDownloadUrl)
})

test('test_dedupe_unwrap_progress', async (t) => {
  setupWindow()
  mockRequest(t, () => okResponse(runningProgress('run-1')))
  const progress = await runDedupe<DedupeRunProgressVo>({ files: [{ fileKey: 'k' }], selectedColumns: [], keepIntegerIds: false, keepUnderscoreIds: false, keepIntegerMainIdsWhenNoSubIds: false })
  assert.deepEqual(progress, runningProgress('run-1'), '应返回解包后的 data')
})