import { refresh } from './auth.js'
import { session, replaceTokens, signOut } from '../stores/session.js'

let refreshPromise = null

function errorFrom(response, fallback) {
	const body = response?.data || {}
	const error = new Error(body.message || fallback)
	error.code = body.code || response?.statusCode
	error.requestId = body.requestId || response?.header?.['x-request-id'] || response?.header?.['X-Request-Id']
	error.traceId = body.traceId || response?.header?.['x-trace-id'] || response?.header?.['X-Trace-Id']
	return error
}

function unauthorized(response) {
	const code = String(response?.data?.code || response?.statusCode || '')
	return response?.statusCode === 401 || code === 'A0401'
}

function successful(response, body) {
	return response?.statusCode === 200 && ['00000', '200'].includes(String(body?.code))
}

async function refreshOverseasToken() {
	if (!session.refreshToken) {
		signOut()
		throw new Error('登录状态已过期，请重新登录')
	}
	if (!refreshPromise) {
		refreshPromise = refresh(session.refreshToken)
			.then((tokens) => { replaceTokens(tokens); return session.token })
			.catch((error) => { signOut(); throw error })
			.finally(() => { refreshPromise = null })
	}
	return refreshPromise
}

async function tokenAfterUnauthorized(failedToken) {
	if (session.token && session.token !== failedToken) return session.token
	return refreshOverseasToken()
}

function overseasUrl(path) {
	const base = String(session.apiBase || '').replace(/\/$/, '')
	const value = `/${String(path || '').replace(/^\/+/, '')}`
	const normalized = /\/(?:api|overseas-api)$/.test(base)
		? value.replace(/^\/api(?=\/)/, '')
		: value
	return `${base}${normalized}`
}

function rawRequest(method, path, data, token) {
	return new Promise((resolve, reject) => {
		uni.request({
			url: overseasUrl(path),
			method,
			data,
			header: { Accept: 'application/json', Authorization: `Bearer ${token}` },
			success: resolve,
			fail: (cause) => reject(Object.assign(new Error(cause.errMsg || '海外服务网络连接失败'), { network: true }))
		})
	})
}

export async function overseasRequest(method, path, data, retry = true) {
	console.info('[Overseas PDA API] request', { method, path })
	const attemptedToken = session.token
	let response = await rawRequest(method, path, data, attemptedToken)
	if (retry && unauthorized(response)) {
		const replacementToken = await tokenAfterUnauthorized(attemptedToken)
		response = await rawRequest(method, path, data, replacementToken)
	}
	const body = response?.data || {}
	console.info('[Overseas PDA API] response', { method, path, statusCode: response?.statusCode, code: body?.code,
		message: body?.message, requestId: body?.requestId || response?.header?.['x-request-id'] || response?.header?.['X-Request-Id'],
		traceId: body?.traceId || response?.header?.['x-trace-id'] || response?.header?.['X-Trace-Id'] })
	if (!successful(response, body)) throw errorFrom(response, '海外作业请求失败')
	return body.data
}

function rawUpload(path, filePath, name, token) {
	return new Promise((resolve, reject) => {
		uni.uploadFile({
			url: overseasUrl(path),
			filePath,
			name,
			header: { Authorization: `Bearer ${token}` },
			success: resolve,
			fail: (cause) => reject(Object.assign(new Error(cause.errMsg || '海外作业文件上传失败'), { network: true }))
		})
	})
}

function rawDownload(path, token) {
	return new Promise((resolve, reject) => {
		uni.downloadFile({
			url: overseasUrl(path),
			header: { Authorization: `Bearer ${token}` },
			success: resolve,
			fail: (cause) => reject(Object.assign(new Error(cause.errMsg || '签收照片下载失败'), { network: true }))
		})
	})
}

export async function overseasUpload(path, filePath, name = 'file', retry = true) {
	const attemptedToken = session.token
	let response = await rawUpload(path, filePath, name, attemptedToken)
	let body = null
	try { body = JSON.parse(response.data || '{}') } catch (_) { /* handled below */ }
	if (retry && unauthorized({ ...response, data: body })) {
		const replacementToken = await tokenAfterUnauthorized(attemptedToken)
		response = await rawUpload(path, filePath, name, replacementToken)
		try { body = JSON.parse(response.data || '{}') } catch (_) { body = null }
	}
	if (!successful(response, body)) throw errorFrom({ ...response, data: body }, '海外作业文件上传失败')
	return body.data
}

export async function overseasDownload(path, options = {}) {
	const { retry = true, expectedContentTypePrefix = '' } = options
	const attemptedToken = session.token
	let response = await rawDownload(path, attemptedToken)
	if (retry && unauthorized(response)) {
		const replacementToken = await tokenAfterUnauthorized(attemptedToken)
		response = await rawDownload(path, replacementToken)
	}
	if (response?.statusCode !== 200 || !response?.tempFilePath) {
		throw errorFrom({ ...response, data: {} }, '签收照片下载失败')
	}
	const contentType = String(response?.header?.['content-type'] || response?.header?.['Content-Type'] || '').toLowerCase()
	if (expectedContentTypePrefix && !contentType.startsWith(expectedContentTypePrefix.toLowerCase())) {
		throw errorFrom({ ...response, data: {} }, '照片服务返回了无效内容，请稍后重试')
	}
	return response.tempFilePath
}

export function resetOverseasRequestStateForTest() { refreshPromise = null }