/**
 * 增强版生肖工具 - 接入天行数据API
 */

import TIANAPI_CONFIG, { validateConfig } from '@/config/api-config.js'
import zodiacUtil from './zodiac.js'

/**
 * 从天行数据API获取生肖运势
 * @param {String} zodiac - 生肖名称
 * @returns {Promise<Object>} 运势数据
 */
export async function getZodiacFortuneFromAPI(zodiac) {
	
	
	
	// 直接返回本地数据
	return {
		...zodiacUtil.getTodayFortune(zodiac),
		source: 'local_no_api',
		dataFrom: '本地数据（天行数据暂无运势接口）',
		updateTime: new Date().toLocaleString('zh-CN')
	}
	
	
}

/**
 * 🆕 生肖配对查询（使用天行数据API）
 * @param {String} myZodiac - 我的生肖
 * @param {String} targetZodiac - 对方生肖
 * @returns {Promise<Object>} 配对结果
 */
export async function getZodiacMatch(myZodiac, targetZodiac) {
	

	try {
		
		
		// 使用Promise包装uni.request以更好地处理错误
		const response = await new Promise((resolve, reject) => {
			uni.request({
				url: `${TIANAPI_CONFIG.BASE_URL}${TIANAPI_CONFIG.ENDPOINTS.zodiacMatch}`,
				method: 'GET',
				data: {
					key: TIANAPI_CONFIG.API_KEY,
					me: myZodiac,
					he: targetZodiac
				},
				timeout: 10000,
				success: (res) => {
					
					resolve(res)
				},
				fail: (err) => {
					console.error('🌐 网络请求失败，错误信息:', err)
					reject(new Error(`网络请求失败: ${err.errMsg || err.message || '未知网络错误'}`))
				}
			})
		})

		
		
		// 检查响应是否存在
		if (!response) {
			console.error('❌ 响应对象为空')
			throw new Error('网络响应为空，可能是域名配置或网络问题')
		}

		// 检查HTTP状态码
		if (response.statusCode !== 200) {
			console.error('❌ HTTP状态码错误:', response.statusCode)
			throw new Error(`HTTP错误: ${response.statusCode}`)
		}

		// 检查响应数据是否存在
		if (!response.data) {
			console.error('❌ API响应数据为空')
			throw new Error('API响应数据为空')
		}

		// 检查API业务状态码
		if (response.data.code !== 200) {
			console.error('❌ API业务错误:', {
				code: response.data.code,
				msg: response.data.msg || '未知错误'
			})
			throw new Error(response.data.msg || `API错误(code: ${response.data.code})`)
		}

		// 检查result数据
		const result = response.data.result
		if (!result) {
			console.error('❌ API返回结果为空')
			throw new Error('API返回结果为空')
		}

		
		return {
			title: result.title || '配对分析',
			malePerspective: result.mcontent || '',      // 男性视角
			femalePerspective: result.fcontent || '',    // 女性视角
			malePerspective2: result.mcontent1 || '',    // 男性视角2
			femalePerspective2: result.fcontent1 || '',  // 女性视角2
			source: 'tianapi',
			updateTime: new Date().toLocaleString('zh-CN')
		}

	} catch (error) {
		console.error('❌ 生肖配对查询失败')
		console.error('错误类型:', error.name || 'Unknown')
		console.error('错误信息:', error.message || error.errMsg || '未知错误')
		console.error('完整错误:', error)
		
		// 友好的用户提示
		uni.showToast({
			title: '配对查询失败，使用本地数据',
			icon: 'none',
			duration: 2000
		})
		
		return null
	}
}

/**
 * 解析运势文本为分数
 * 根据关键词判断分数
 */
function parseFortune(text) {
	if (!text) return 75

	// 正面关键词
	const positiveWords = ['佳', '好', '旺', '顺', '吉', '高', '升', '涨', '强']
	// 负面关键词
	const negativeWords = ['差', '弱', '低', '降', '凶', '衰', '险', '忌']

	let score = 75 // 基础分数

	// 检查正面词
	for (let word of positiveWords) {
		if (text.includes(word)) {
			score += 5
		}
	}

	// 检查负面词
	for (let word of negativeWords) {
		if (text.includes(word)) {
			score -= 5
		}
	}

	// 限制分数范围 60-95
	return Math.max(60, Math.min(95, score))
}

/**
 * 统一的获取运势接口
 * 优先使用API，失败则降级到本地
 */
export async function getTodayFortune(zodiac) {
	return await getZodiacFortuneFromAPI(zodiac)
}

/**
 * 获取星座运势（如果需要）
 */
export async function getConstellationFortune(constellation) {
	if (!validateConfig()) {
		return null
	}

	try {
		const response = await uni.request({
			url: `${TIANAPI_CONFIG.BASE_URL}${TIANAPI_CONFIG.ENDPOINTS.constellation}`,
			method: 'GET',
			data: {
				key: TIANAPI_CONFIG.API_KEY,
				astro: constellation
			},
			timeout: 5000
		})

		if (response.statusCode === 200 && response.data.code === 200) {
			return response.data.result
		}
	} catch (error) {
		console.error('获取星座运势失败:', error)
	}

	return null
}

/**
 * 测试API连接
 */
export async function testAPIConnection() {
	if (!validateConfig()) {
		return {
			success: false,
			message: '请先配置API Key'
		}
	}

	try {
		
		const result = await getZodiacFortuneFromAPI('鼠')
		
		// 检查是否真的是API数据
		if (result.source === 'tianapi') {
			return {
				success: true,
				message: 'API连接成功！',
				data: result
			}
		} else {
			return {
				success: false,
				message: 'API调用失败，已降级到本地数据',
				data: result
			}
		}
	} catch (error) {
		return {
			success: false,
			message: 'API连接失败：' + (error.message || error.errMsg || '未知错误'),
			error: error
		}
	}
}

/**
 * 🔧 网络连接诊断工具
 */
export async function diagnoseNetwork() {
	
	
	const diagnostics = {
		timestamp: new Date().toLocaleString('zh-CN'),
		environment: {
			platform: uni.getSystemInfoSync().platform,
			version: uni.getSystemInfoSync().version,
			SDKVersion: uni.getSystemInfoSync().SDKVersion
		},
		tests: {}
	}
	
	// 测试1: 基础网络连接
	try {
	
		const testResponse = await new Promise((resolve, reject) => {
			uni.request({
				url: 'https://www.baidu.com',
				method: 'GET',
				timeout: 5000,
				success: resolve,
				fail: reject
			})
		})
		
		diagnostics.tests.basicNetwork = {
			success: true,
			statusCode: testResponse.statusCode,
			message: '网络连接正常'
		}
		
	} catch (error) {
		diagnostics.tests.basicNetwork = {
			success: false,
			error: error.errMsg || error.message,
			message: '基础网络连接失败'
		}
		console.error('❌ 基础网络连接失败:', error)
	}
	
	// 测试2: HTTPS协议测试
	try {
		
		const httpsResponse = await new Promise((resolve, reject) => {
			uni.request({
				url: 'https://httpbin.org/get',
				method: 'GET',
				timeout: 8000,
				success: resolve,
				fail: reject
			})
		})
		
		diagnostics.tests.httpsSupport = {
			success: true,
			statusCode: httpsResponse.statusCode,
			message: 'HTTPS协议支持正常'
		}
	
	} catch (error) {
		diagnostics.tests.httpsSupport = {
			success: false,
			error: error.errMsg || error.message,
			message: 'HTTPS协议测试失败'
		}
		console.error('❌ HTTPS协议测试失败:', error)
	}
	
	// 测试3: 天行数据域名连通性
	try {
		
		const tianApiResponse = await new Promise((resolve, reject) => {
			uni.request({
				url: 'https://apis.tianapi.com',
				method: 'GET',
				timeout: 8000,
				success: resolve,
				fail: reject
			})
		})
		
		diagnostics.tests.tianApiDomain = {
			success: true,
			statusCode: tianApiResponse.statusCode,
			message: '天行数据域名可访问'
		}
	
	} catch (error) {
		diagnostics.tests.tianApiDomain = {
			success: false,
			error: error.errMsg || error.message,
			message: '天行数据域名无法访问'
		}
		console.error('❌ 天行数据域名无法访问:', error)
	}
	
	return diagnostics
}

/**
 * 详细的API诊断工具
 */
export async function diagnoseAPI() {
	
	
	const diagnostics = {
		config: {
			hasApiKey: !!TIANAPI_CONFIG.API_KEY,
			apiKey: TIANAPI_CONFIG.API_KEY ? TIANAPI_CONFIG.API_KEY.substring(0, 8) + '...' : '未配置',
			baseUrl: TIANAPI_CONFIG.BASE_URL,
			endpoint: TIANAPI_CONFIG.ENDPOINTS.zodiac
		},
		network: {},
		apiResponse: {}
	}
	
	// 测试基础网络连接
	try {
		
		const testUrl = `${TIANAPI_CONFIG.BASE_URL}${TIANAPI_CONFIG.ENDPOINTS.zodiac}`
		diagnostics.network.testUrl = testUrl
		
		const response = await uni.request({
			url: testUrl,
			method: 'GET',
			data: {
				key: TIANAPI_CONFIG.API_KEY,
				name: '鼠'
			},
			timeout: 10000
		})
		
		diagnostics.network.success = true
		diagnostics.network.statusCode = response.statusCode
		diagnostics.apiResponse = response.data
		
	
		
	} catch (error) {
		diagnostics.network.success = false
		diagnostics.network.error = error.errMsg || error.message
		console.error('❌ 网络连接失败:', error)
	}
	
	return diagnostics
}

export default {
	getTodayFortune,
	getZodiacFortuneFromAPI,
	getZodiacMatch,
	getConstellationFortune,
	testAPIConnection,
	diagnoseAPI,
	diagnoseNetwork
}