import { test } from 'node:test'
import assert from 'node:assert/strict'
import { http } from '../src/shared/api/http.ts'
import {
  runSplit,
  getSplitHistory,
  deleteSplitHistory,
  getSplitResultDownloadUrl,
  type SplitRunRequest,
  type SplitRunVo,
} from '../src/shared/api/types/modules/split.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 splitRequest: Omit<SplitRunRequest, 'user_id'> = {
  files: [{ fileKey: 'k1' }],
  selectedColumns: ['a'],
  splitMode: 'rows_per_file',
  rowsPerFile: 500,
  archiveName: '拆分结果',
}

test('test_split_run_url', async (t) => {
  setupWindow()
  let captured: { url?: string } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ total: 1, successCount: 1, failedCount: 0, items: [] })
  })
  await runSplit(splitRequest)
  assert.equal(captured.url, '/newApi/api/split/run')
})

test('test_split_run_method_payload', async (t) => {
  setupWindow()
  let captured: { method?: string; data?: unknown } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ total: 0, successCount: 0, failedCount: 0, items: [] })
  })
  await runSplit(splitRequest)
  assert.equal(captured.method, 'POST')
  assert.deepEqual(captured.data, { ...splitRequest, user_id: 42 })
})

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

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

test('test_split_download_url', async (t) => {
  setupWindow()
  const url = getSplitResultDownloadUrl(7)
  assert.equal(url, 'http://localhost/newApi/api/split/results/7/download?user_id=42')
})

test('test_split_signature_unchanged', async (t) => {
  setupWindow()
  assert.equal(runSplit.length, 1)
  assert.equal(getSplitHistory.length, 0)
  assert.equal(deleteSplitHistory.length, 1)
  assert.equal(getSplitResultDownloadUrl.length, 1)
  const request: SplitRunRequest = { ...splitRequest, user_id: 1 }
  assert.equal(request.splitMode, 'rows_per_file')
  const entry = { filename: 'a.xlsx', rowCount: 10 }
  assert.equal(entry.rowCount, 10)
})

test('test_split_export_compat', async (t) => {
  setupWindow()
  const fromJavaModules = await import('../src/shared/api/java-modules.ts')
  const fromSplit = await import('../src/shared/api/types/modules/split.ts')
  assert.equal(fromJavaModules.runSplit, fromSplit.runSplit)
  assert.equal(fromJavaModules.getSplitHistory, fromSplit.getSplitHistory)
  assert.equal(fromJavaModules.deleteSplitHistory, fromSplit.deleteSplitHistory)
  assert.equal(fromJavaModules.getSplitResultDownloadUrl, fromSplit.getSplitResultDownloadUrl)
})

test('test_split_unwrap_and_error', async (t) => {
  setupWindow()
  mockRequest(t, () => okResponse({ total: 1, successCount: 0, failedCount: 1, items: [{ sourceFilename: 'a', success: false, error: '解析失败' }] }))
  const result = await runSplit<SplitRunVo>(splitRequest)
  assert.equal(result.failedCount, 1)
  assert.equal(result.items[0].error, '解析失败')

  mockRequest(t, () => Promise.resolve({ data: { success: false, message: '服务不可用' } }))
  await assert.rejects(runSplit(splitRequest), /服务不可用/, 'success=false 应回传异常')
})