/**
 * 增强版生肖工具 - 接入天行数据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) {
	// ⚠️ 注意：天行数据的 /zodiac/index 是生肖配对接口，不是运势接口
	// 该接口需要 me 和 he 两个参数，用于查询生肖配对关系
	// 目前天行数据可能没有单独的生肖运势接口，因此直接使用本地数据
	
	console.log('ℹ️ 天行数据暂无生肖运势接口，使用本地数据')
	console.log('📝 说明: /zodiac/index 是生肖配对接口，不是运势接口')
	
	// 直接返回本地数据
	return {
		...zodiacUtil.getTodayFortune(zodiac),
		source: 'local_no_api',
		dataFrom: '本地数据（天行数据暂无运势接口）',
		updateTime: new Date().toLocaleString('zh-CN')
	}
	
	/* 
	// 保留代码供参考：如果找到正确的运势API，可以恢复使用
	
	// 验证配置
	if (!validateConfig()) {
		console.log('API Key未配置，使用本地数据')
		return {
			...zodiacUtil.getTodayFortune(zodiac),
			source: 'local_no_config',
			dataFrom: '本地数据（未配置API）'
		}
	}

	try {
		console.log('🔍 开始调用天行数据API...')
		console.log('请求生肖:', zodiac)
		
		// 调用天行数据API（使用Promise包装以捕获所有错误）
		const [error, response] = await uni.request({
			url: `${TIANAPI_CONFIG.BASE_URL}${TIANAPI_CONFIG.ENDPOINTS.zodiacFortune}`,
			method: 'GET',
			data: {
				key: TIANAPI_CONFIG.API_KEY,
				name: zodiac
			},
			timeout: 8000 // 8秒超时，给网络更多时间
		}).then(res => [null, res]).catch(err => [err, null])

		// 如果请求本身失败（网络错误等）
		if (error) {
			console.error('❌ 网络请求失败:', error)
			throw new Error(`网络错误: ${error.errMsg || error.message || '未知错误'}`)
		}

		console.log('📡 API响应状态码:', response.statusCode)
		console.log('📡 API响应数据:', response.data)

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

		const data = response.data

		// 检查数据格式
		if (!data || typeof data !== 'object') {
			console.error('❌ 响应数据格式错误:', data)
			throw new Error('响应数据格式不正确')
		}

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

		// 检查result字段
		const result = data.result
		if (!result) {
			console.error('❌ 缺少result数据')
			throw new Error('API返回数据不完整')
		}

		console.log('✅ API调用成功，数据:', result)

		// 天行数据返回格式转换为我们的格式
		return {
			overall: result.summary || '平稳',
			love: parseFortune(result.love_txt),
			career: parseFortune(result.work_txt),
			wealth: parseFortune(result.money_txt),
			health: parseFortune(result.health_txt),
			tips: `幸运颜色：${result.color || '未知'}，幸运数字：${result.number || '未知'}。${result.general_txt || ''}`,
			luckyColor: result.color || zodiacUtil.getZodiacInfo(zodiac).luckyColor,
			luckyNumber: result.number || zodiacUtil.getZodiacInfo(zodiac).luckyNumber,
			source: 'tianapi',
			dataFrom: '天行数据专业API',
			updateTime: new Date().toLocaleString('zh-CN')
		}

	} catch (error) {
		console.error('❌ 获取API数据失败，降级到本地数据')
		console.error('错误详情:', error)
		console.error('错误消息:', error.message || error.errMsg || '未知错误')
		
		// 显示友好提示（不打断用户）
		uni.showToast({
			title: '使用本地数据',
			icon: 'none',
			duration: 1500
		})

		// 降级到本地数据
		return {
			...zodiacUtil.getTodayFortune(zodiac),
			source: 'local_fallback',
			dataFrom: '本地数据（API暂不可用）',
			updateTime: new Date().toLocaleString('zh-CN')
		}
	}
	*/
}

/**
 * 🆕 生肖配对查询（使用天行数据API）
 * @param {String} myZodiac - 我的生肖
 * @param {String} targetZodiac - 对方生肖
 * @returns {Promise<Object>} 配对结果
 */
export async function getZodiacMatch(myZodiac, targetZodiac) {
	// 验证配置
	if (!validateConfig()) {
		console.log('API Key未配置，无法使用配对功能')
		return null
	}

	try {
		console.log('🔍 开始调用生肖配对API...')
		console.log('我的生肖:', myZodiac, '对方生肖:', targetZodiac)
		console.log('请求URL:', `${TIANAPI_CONFIG.BASE_URL}${TIANAPI_CONFIG.ENDPOINTS.zodiacMatch}`)
		console.log('请求参数:', {
			key: TIANAPI_CONFIG.API_KEY ? TIANAPI_CONFIG.API_KEY.substring(0, 8) + '...' : '未配置',
			me: myZodiac,
			he: targetZodiac
		})
		
		// 使用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) => {
					console.log('🌐 网络请求成功，原始响应:', res)
					resolve(res)
				},
				fail: (err) => {
					console.error('🌐 网络请求失败，错误信息:', err)
					reject(new Error(`网络请求失败: ${err.errMsg || err.message || '未知网络错误'}`))
				}
			})
		})

		console.log('📡 配对API完整响应:', {
			statusCode: response.statusCode,
			data: response.data,
			header: response.header,
			cookies: response.cookies
		})
		
		// 检查响应是否存在
		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返回结果为空')
		}

		console.log('✅ 配对查询成功，数据:', result)
		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 {
		console.log('🧪 开始测试API连接...')
		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() {
	console.log('🔧 开始网络诊断...')
	
	const diagnostics = {
		timestamp: new Date().toLocaleString('zh-CN'),
		environment: {
			platform: uni.getSystemInfoSync().platform,
			version: uni.getSystemInfoSync().version,
			SDKVersion: uni.getSystemInfoSync().SDKVersion
		},
		tests: {}
	}
	
	// 测试1: 基础网络连接
	try {
		console.log('📡 测试基础网络连接...')
		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: '网络连接正常'
		}
		console.log('✅ 基础网络连接正常')
	} catch (error) {
		diagnostics.tests.basicNetwork = {
			success: false,
			error: error.errMsg || error.message,
			message: '基础网络连接失败'
		}
		console.error('❌ 基础网络连接失败:', error)
	}
	
	// 测试2: HTTPS协议测试
	try {
		console.log('🔒 测试HTTPS协议支持...')
		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协议支持正常'
		}
		console.log('✅ HTTPS协议支持正常')
	} catch (error) {
		diagnostics.tests.httpsSupport = {
			success: false,
			error: error.errMsg || error.message,
			message: 'HTTPS协议测试失败'
		}
		console.error('❌ HTTPS协议测试失败:', error)
	}
	
	// 测试3: 天行数据域名连通性
	try {
		console.log('🌐 测试天行数据域名连通性...')
		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: '天行数据域名可访问'
		}
		console.log('✅ 天行数据域名可访问')
	} catch (error) {
		diagnostics.tests.tianApiDomain = {
			success: false,
			error: error.errMsg || error.message,
			message: '天行数据域名无法访问'
		}
		console.error('❌ 天行数据域名无法访问:', error)
	}
	
	return diagnostics
}

/**
 * 详细的API诊断工具
 */
export async function diagnoseAPI() {
	console.log('🔧 开始API诊断...')
	
	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 {
		console.log('📡 测试网络连接...')
		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
		
		console.log('✅ 网络连接成功')
		console.log('响应:', 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
}