import { test } from 'node:test'
import assert from 'node:assert/strict'
import { http } from '../src/shared/api/http.ts'
import {
  getExcelInfo,
  getConvertTemplates,
  importConvertTemplate,
  setDefaultConvertTemplate,
  deleteConvertTemplate,
  runConvert,
  getConvertHistory,
  deleteConvertHistory,
  getConvertResultDownloadUrl,
  type ConvertRunRequest,
  type ConvertTemplateVo,
  type ConvertRunVo,
} from '../src/shared/api/types/modules/convert.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 convertRequest: Omit<ConvertRunRequest, 'user_id'> = {
  files: [{ fileKey: 'k1' }],
  templateId: 'TPL001',
  archiveName: '转换结果',
}

test('test_convert_excel_info_url', async (t) => {
  setupWindow()
  let captured: { url?: string; params?: Record<string, unknown> } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ headers: ['a', 'b'], totalRows: 10 })
  })
  await getExcelInfo('key-123')
  assert.equal(captured.url, '/newApi/api/files/excel-info')
  assert.deepEqual(captured.params, { fileKey: 'key-123' })
})

test('test_convert_run_url_payload', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string; data?: unknown } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse({ total: 1, successCount: 1, failedCount: 0, items: [] })
  })
  await runConvert(convertRequest)
  assert.equal(captured.url, '/newApi/api/convert/run')
  assert.equal(captured.method, 'POST')
  assert.deepEqual(captured.data, { ...convertRequest, user_id: 42 })
})

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

test('test_convert_delete_history', async (t) => {
  setupWindow()
  let captured: { url?: string; method?: string; params?: Record<string, unknown> } = {}
  mockRequest(t, (config) => {
    captured = config
    return okResponse(null)
  })
  await deleteConvertHistory(7)
  assert.equal(captured.url, '/newApi/api/convert/history/7')
  assert.equal(captured.method, 'DELETE')
  assert.deepEqual(captured.params, { user_id: 42 })
})

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

test('test_convert_template_apis', async (t) => {
  setupWindow()
  const calls: { url?: string; method?: string; data?: unknown }[] = []
  mockRequest(t, (config) => {
    calls.push(config)
    return okResponse(null)
  })
  await getConvertTemplates()
  await importConvertTemplate({ templateName: '模板A', templateContent: 'x' })
  await setDefaultConvertTemplate('TPL001')
  await deleteConvertTemplate('TPL001')
  assert.equal(calls.length, 4)
  assert.equal(calls[0].url, '/newApi/api/convert/templates')
  assert.equal(calls[0].method, 'GET')
  assert.equal(calls[1].url, '/newApi/api/convert/templates/import')
  assert.equal(calls[1].method, 'POST')
  assert.deepEqual(calls[1].data, { templateName: '模板A', templateContent: 'x' })
  assert.equal(calls[2].url, '/newApi/api/convert/templates/TPL001/default')
  assert.equal(calls[2].method, 'POST')
  assert.equal(calls[3].url, '/newApi/api/convert/templates/TPL001')
  assert.equal(calls[3].method, 'DELETE')
})

test('test_convert_signature_unchanged', async (t) => {
  setupWindow()
  assert.equal(getExcelInfo.length, 1)
  assert.equal(getConvertTemplates.length, 0)
  assert.equal(importConvertTemplate.length, 1)
  assert.equal(setDefaultConvertTemplate.length, 1)
  assert.equal(deleteConvertTemplate.length, 1)
  assert.equal(runConvert.length, 1)
  assert.equal(getConvertHistory.length, 0)
  assert.equal(deleteConvertHistory.length, 1)
  assert.equal(getConvertResultDownloadUrl.length, 1)
  const template: ConvertTemplateVo = { id: '1', templateCode: 'TPL001', templateName: '模板A', outputFilename: 'out.xlsx' }
  assert.equal(template.builtIn, undefined)
})

test('test_convert_export_compat', async (t) => {
  setupWindow()
  const fromJavaModules = await import('../src/shared/api/java-modules.ts')
  const fromConvert = await import('../src/shared/api/types/modules/convert.ts')
  assert.equal(fromJavaModules.getExcelInfo, fromConvert.getExcelInfo)
  assert.equal(fromJavaModules.runConvert, fromConvert.runConvert)
  assert.equal(fromJavaModules.getConvertHistory, fromConvert.getConvertHistory)
  assert.equal(fromJavaModules.deleteConvertHistory, fromConvert.deleteConvertHistory)
  assert.equal(fromJavaModules.getConvertResultDownloadUrl, fromConvert.getConvertResultDownloadUrl)
  assert.equal(fromJavaModules.getConvertTemplates, fromConvert.getConvertTemplates)
  assert.equal(fromJavaModules.importConvertTemplate, fromConvert.importConvertTemplate)
  assert.equal(fromJavaModules.setDefaultConvertTemplate, fromConvert.setDefaultConvertTemplate)
  assert.equal(fromJavaModules.deleteConvertTemplate, fromConvert.deleteConvertTemplate)
})

test('test_convert_unwrap_and_error', async (t) => {
  setupWindow()
  mockRequest(t, () => okResponse({ total: 1, successCount: 0, failedCount: 1, items: [{ sourceFilename: 'a', success: false, error: '转换失败' }] }))
  const result = await runConvert<ConvertRunVo>(convertRequest)
  assert.equal(result.failedCount, 1)
  assert.equal(result.items[0].error, '转换失败')

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