import type { uniappRequestAdapter } from '@alova/adapter-uniapp'
import type { IResponse } from './types'
import AdapterUniapp from '@alova/adapter-uniapp'
import { createAlova } from 'alova'
import { createServerTokenAuthentication } from 'alova/client'
import VueHook from 'alova/vue'
import { toast } from '@/utils/toast'
import { ContentTypeEnum, ResultEnum, ShowMessage } from './tools/enum'
import { useUserStore } from '@/store'
import { router } from '@/utils/tools'

// 配置动态Tag
export const API_DOMAINS = {
	DEFAULT: import.meta.env.VITE_SERVER_BASEURL,
	SECONDARY: import.meta.env.VITE_API_SECONDARY_URL,
}

/**
 * 创建请求实例
 */
const { onAuthRequired, onResponseRefreshToken } = createServerTokenAuthentication<
	typeof VueHook,
	typeof uniappRequestAdapter
>({
	refreshTokenOnError: {
		isExpired: (error) => {
			return error.response?.status === ResultEnum.Unauthorized
		},
		handler: async () => {
			try {
				// await authLogin();
			}
			catch (error) {
				// 切换到登录页
				await uni.reLaunch({ url: '/pages/common/login/index' })
				throw error
			}
		},
	},
})

/**
 * alova 请求实例
 */
const alovaInstance = createAlova({
	baseURL: import.meta.env.VITE_SERVER_BASEURL,
	...AdapterUniapp(),
	timeout: 5000,
	statesHook: VueHook,

	beforeRequest: onAuthRequired((method) => {
		// 设置默认 Content-Type
		method.config.headers = {
			ContentType: ContentTypeEnum.JSON,
			Accept: 'application/json, text/plain, */*',
			...method.config.headers,
		}

		const { config } = method
		const ignoreAuth = !config.meta?.ignoreAuth
		console.log('ignoreAuth===>', ignoreAuth)
		// 处理认证信息   自行处理认证问题
		if (ignoreAuth) {
			// const token = 'getToken()'
			// if (!token) {
			// 	throw new Error('[请求错误]：未登录')
			// }
			// method.config.headers.token = token;

			const userStore = useUserStore()
			const { token, mobile } = userStore.userInfo as unknown as IUserInfo
		
			if (!token) {
				toast.info('请先登录')
				router.switchTab('/pages/my/my', 500)
				throw new Error('[请求错误]：未登录')
			}

			// if (!mobile) {
			// 	toast.info('请先绑定手机号')
			// 	router.navigateTo('/pages/login/mobile', 500)
			// 	throw new Error('[请求错误]：未绑定手机号')
			// }

			method.config.headers.token = token;
		}

		// 处理动态域名
		if (config.meta?.domain) {
			method.baseURL = config.meta.domain
			console.log('当前域名', method.baseURL)
		}
	}),

	responded: onResponseRefreshToken((response, method) => {
		const { config } = method
		const { requestType } = config
		const {
			statusCode,
			data: rawData,
			errMsg,
		} = response as UniNamespace.RequestSuccessCallbackResult

		// 处理特殊请求类型（上传/下载）
		if (requestType === 'upload' || requestType === 'download') {
			return response
		}

		// 处理 HTTP 状态码错误
		// if (statusCode !== 200) {
		// 	const errorMessage = ShowMessage(statusCode) || `HTTP请求错误[${statusCode}]`
		// 	console.error('errorMessage===>', errorMessage)
		// 	toast.error(errorMessage)
		// 	throw new Error(`${errorMessage}：${errMsg}`)
		// }

		// 处理业务逻辑错误
		const { code, msg, data } = rawData as IResponse
		if (code === ResultEnum.Unauthorized) {
			useUserStore().removeUserInfo()

			if (config.meta?.toast !== false) {
				toast.info(msg)
				router.switchTab('/pages/my/my', 1000)
			}
			throw new Error(`登录超时[${code}]：${msg}`)
		}

		if (code === ResultEnum.Success) {
			if (config.meta?.toast !== false && msg) {
				if (msg !== '查询成功') toast.info(msg)
			}
		}

		if (code !== ResultEnum.Success) {
			if (config.meta?.toast !== false) {
				toast.warning(msg)
			}
			throw new Error(`请求错误[${code}]：${msg}`)
		}
		// 处理成功响应，返回业务数据
		return data
	}),
})

export const http = alovaInstance