/**
 * 报名名单与基础数据包（单位 / 大项 / 小项 / 组别）的 xlsx 导入导出。
 *
 * 这两组接口没进 `shared/api.ts` 的 ApiClient（那是全站共用的客户端，本任务不改它），
 * 单独放一个模块，导出页与测试都从这里取。
 *
 * 错误处理与全站一致：只有连不上 / 超时才可能是「后端未就绪」，
 * 403 / 400 / 409 这些是服务端的真实回答，必须原样抛出，否则会把
 * 「没权限」「表头写错了」伪装成示例数据。
 */

import { ApiError } from './api'
import type { ApiErrorCode } from './types'

const BASE_URL = '/api'
/** 导出要等服务端现算 xlsx，比普通读接口慢。 */
const DOWNLOAD_TIMEOUT_MS = 60_000
/** 上传整包要读全部工作表再写库，弱网下更慢。 */
const UPLOAD_TIMEOUT_MS = 120_000

const API_ERROR_CODES: readonly string[] = [
  'AUTH_REQUIRED',
  'AUTH_FAILED',
  'FORBIDDEN',
  'VALIDATION_FAILED',
  'CONFLICT',
  'STATE_INVALID',
  'RATE_LIMITED',
  'INTERNAL',
  'NETWORK',
  'TIMEOUT',
  'PARSE_FAILED',
]

export const ENTRIES_XLSX_FILENAME = '报名名单.xlsx'
export const BASEDATA_XLSX_FILENAME = '基础数据包.xlsx'

export interface DownloadFile {
  blob: Blob
  filename: string
}

/** 报名名单的筛选条件；不传的字段 = 该维度不筛。 */
export interface EntryExportFilter {
  eventId?: number
  categoryId?: number
  teamId?: number
  heat?: number
}

export interface BaseDataFieldDiff {
  field: string
  from: string
  to: string
}

/** 一行差异：哪张表、第几行、新增还是更新、哪个字段从什么变成什么。 */
export interface BaseDataChange {
  sheet: string
  line: number
  action: string
  key: string
  fields: BaseDataFieldDiff[]
}

/**
 * 差异预览 / 导入结果。
 * `errors` 是行级中文错误（形如「单位 第 3 行：单位编码必填」），有错误就不会写库里那一行。
 */
export interface BaseDataImportResult {
  dryRun: boolean
  added: number
  updated: number
  unchanged: number
  errorCount: number
  errors: string[]
  changes: BaseDataChange[]
}

/** 报名名单导出的请求路径（筛选参数为空就不带 query）。 */
export function entriesExportPath(filter: EntryExportFilter = {}): string {
  const params = new URLSearchParams()
  for (const key of ['eventId', 'categoryId', 'teamId', 'heat'] as const) {
    const value = filter[key]
    if (value !== undefined) params.append(key, String(value))
  }
  const query = params.toString()
  return `/export/entries.xlsx${query === '' ? '' : `?${query}`}`
}

/** 下载报名名单（xlsx）。 */
export function downloadEntriesXLSX(filter: EntryExportFilter = {}): Promise<DownloadFile> {
  return download(entriesExportPath(filter), ENTRIES_XLSX_FILENAME)
}

/** 下载基础数据包（多 sheet 工作簿）。 */
export function downloadBaseDataXLSX(): Promise<DownloadFile> {
  return download('/export/basedata.xlsx', BASEDATA_XLSX_FILENAME)
}

/**
 * 上传基础数据包。
 * `dryRun=true` 只算差异不写库；用户确认后再用 `dryRun=false` 提交同一个文件。
 */
export async function importBaseDataXLSX(
  file: File,
  options: { dryRun?: boolean } = {},
): Promise<BaseDataImportResult> {
  const form = new FormData()
  form.append('file', file)
  if (options.dryRun === true) form.append('dryRun', '1')

  const response = await request('/export/basedata/import', {
    method: 'POST',
    body: form,
    // 浏览器自己带 multipart 边界，显式设 Content-Type 反而会漏掉 boundary。
    headers: csrfHeader(),
  }, UPLOAD_TIMEOUT_MS)

  const body = await readBody(response)
  const record = isRecord(body) ? body : {}
  if (record.ok !== true) {
    throw toApiError(body, response.status)
  }
  const data = isRecord(record.data) ? record.data : {}
  return {
    dryRun: data.dryRun === true,
    added: readNumber(data, 'added') ?? 0,
    updated: readNumber(data, 'updated') ?? 0,
    unchanged: readNumber(data, 'unchanged') ?? 0,
    errorCount: readNumber(data, 'errorCount') ?? 0,
    errors: readStrings(data.errors),
    changes: readChanges(data.changes),
  }
}

// ---------------------------------------------------------------------------
// 底层
// ---------------------------------------------------------------------------

async function download(path: string, filename: string): Promise<DownloadFile> {
  const response = await request(path, { method: 'GET' })
  return { blob: await response.blob(), filename }
}

async function request(path: string, init: RequestInit, timeoutMs = DOWNLOAD_TIMEOUT_MS): Promise<Response> {
  const controller = new AbortController()
  const timer = setTimeout(() => controller.abort(), timeoutMs)
  try {
    const response = await fetch(`${BASE_URL}${path}`, {
      credentials: 'include',
      ...init,
      signal: controller.signal,
    })
    if (!response.ok) {
      throw toApiError(await readBody(response), response.status)
    }
    return response
  } catch (error) {
    if (error instanceof ApiError) throw error
    if (controller.signal.aborted) {
      throw new ApiError('TIMEOUT', `请求超时（${timeoutMs}ms）`, 0, error)
    }
    throw new ApiError('NETWORK', '无法连接服务端', 0, error)
  } finally {
    clearTimeout(timer)
  }
}

async function readBody(response: Response): Promise<unknown> {
  if (response.status === 204) return null
  const text = await response.text()
  if (text.trim() === '') return null
  try {
    return JSON.parse(text)
  } catch {
    return text
  }
}

function csrfHeader(): Record<string, string> {
  if (typeof document === 'undefined') return {}
  const match = /(?:^|;\s*)csrf_token=([^;]+)/.exec(document.cookie)
  const raw = match?.[1]
  if (raw === undefined) return {}
  return { 'X-CSRF-Token': decodeURIComponent(raw) }
}

function toApiError(body: unknown, status: number): ApiError {
  const record = isRecord(body) ? body : {}
  const error = isRecord(record.error) ? record.error : {}
  const code = typeof error.code === 'string' && API_ERROR_CODES.includes(error.code)
    ? (error.code as ApiErrorCode)
    : 'INTERNAL'
  const message = typeof error.message === 'string' && error.message !== ''
    ? error.message
    : `请求失败（HTTP ${status}）`
  return new ApiError(code, message, status, error.detail)
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value)
}

function readNumber(source: Record<string, unknown>, key: string): number | null {
  const value = source[key]
  return typeof value === 'number' && Number.isFinite(value) ? value : null
}

function readStrings(value: unknown): string[] {
  if (!Array.isArray(value)) return []
  return value.filter((item): item is string => typeof item === 'string')
}

function readChanges(value: unknown): BaseDataChange[] {
  if (!Array.isArray(value)) return []
  const out: BaseDataChange[] = []
  for (const item of value) {
    if (!isRecord(item)) continue
    const fields: BaseDataFieldDiff[] = []
    if (Array.isArray(item.fields)) {
      for (const field of item.fields) {
        if (!isRecord(field)) continue
        fields.push({
          field: typeof field.field === 'string' ? field.field : '',
          from: typeof field.from === 'string' ? field.from : '',
          to: typeof field.to === 'string' ? field.to : '',
        })
      }
    }
    out.push({
      sheet: typeof item.sheet === 'string' ? item.sheet : '',
      line: readNumber(item, 'line') ?? 0,
      action: typeof item.action === 'string' ? item.action : '',
      key: typeof item.key === 'string' ? item.key : '',
      fields,
    })
  }
  return out
}