import request from '../utils/request';

/**
 * 打卡营相关 API 接口
 * 整合了打卡营、任务、订单、支付等所有相关接口
 */
export const campApi = {
	// ==================== 打卡营基础信息 ====================
	
	/**
	 * 获取打卡营分类列表
	 */
	getCampCategories: () => {
		const url = `/camp/categories?keyword=&page=1&page_size=10`;
		return request({
			url,
			method: 'GET'
		});
	},

	/**
	 * 获取打卡营列表
	 * @param {String} categoryId - 分类ID，如果为 undefined/null/-1 则返回推荐打卡营
	 * @param {String} userId - 用户ID（可选，如果不传则从本地存储获取）
	 */
	getCamps: (categoryId, userId) => {
		const user_id = String(userId || wx.getStorageSync('wxuserid') || '');
		// 已加入打卡营：只返回当前用户已加入的营
		if (categoryId === 'joined') {
			return request({
				url: `/camp/camps?joined_only=1&page=1&page_size=50&user_id=${encodeURIComponent(user_id)}`,
				method: 'GET'
			});
		}
		// 推荐打卡营（与后端 RecommendFilter 约定：only_true = 只返回推荐的）
		if (!categoryId || categoryId === 'undefined' || categoryId === '-1') {
			return request({
				url: `/camp/camps?recommend_filter=only_true&page=1&page_size=20&user_id=${encodeURIComponent(user_id)}`,
				method: 'GET'
			});
		}
		// 按分类筛选
		const url = `/camp/camps?category_id=${categoryId}&page=1&page_size=20&user_id=${encodeURIComponent(user_id)}`;
		return request({
			url,
			method: 'GET'
		});
	},

	/**
	 * 获取打卡营详情
	 * @param {String} campId - 打卡营ID
	 * @param {String} userId - 用户ID（可选，如果不传则从本地存储获取）
	 */
	getCampDetail: (campId, userId) => {
		const user_id = String(userId || wx.getStorageSync('wxuserid') || '');
		// 根据 proto 定义，使用查询参数 id
		return request({
			url: `/camp/camps/detail?id=${campId}&user_id=${encodeURIComponent(user_id)}`,
			method: 'GET'
		});
	},

	/**
	 * 获取打卡营详情及状态（聚合接口，包含用户状态、小节、任务等完整信息）
	 * @param {String} campId - 打卡营ID
	 * @param {String} userId - 用户ID
	 */
	getCampDetailWithUserStatus: (campId, userId) => {
		return request({
			url: `/camp/camp_detail_with_user_status`,
			method: 'POST',
			data: {
				camp_id: String(campId),
				user_id: String(userId || wx.getStorageSync('wxuserid') || '')
			}
		});
	},

	// ==================== 用户打卡营操作 ====================

	/**
	 * 加入打卡营
	 * @param {String} campId - 打卡营ID
	 */
	joinCamp: (campId) => {
		return request({
			url: `/camp/user_camp/join`,
			method: 'POST',
			data: {
				user_id: String(wx.getStorageSync('wxuserid') || ''), // 从本地存储获取用户ID
				camp_id: campId
			}
		});
	},

	/**
	 * 检查用户是否加入打卡营
	 * @param {String} campId - 打卡营ID
	 */
	checkUserCampStatus: (campId) => {
		return request({
			url: `/camp/check_user_camp_status`,
			method: 'POST',
			data: {
				user_id: String(wx.getStorageSync('wxuserid') || ''), // 从本地存储获取用户ID
				camp_id: campId
			}
		});
	},

	/**
	 * 重置打卡营进度（新接口）
	 * @param {String} campId - 打卡营ID
	 * @param {String} userId - 用户ID
	 * @param {Boolean} confirm - 是否确认
	 */
	resetCampProgress: (campId, userId, confirm = true) => {
		return request({
			url: `/camp/user_camp/reset_progress`,
			method: 'POST',
			data: {
				user_id: String(userId || wx.getStorageSync('wxuserid') || ''),
				camp_id: String(campId),
				confirm: confirm
			}
		});
	},

	/**
	 * 重启打卡营（旧接口，已废弃）
	 * @deprecated 请使用 resetCampProgress
	 */
	restartCamp: (campId) => {
		return request({
			url: `/camp/${campId}/restart`,
			method: 'POST'
		});
	},

	// ==================== 小节相关 ====================

	/**
	 * 获取打卡营的小节列表（课程列表）
	 * @param {String} campId - 打卡营ID
	 * @param {String} userId - 用户ID（可选，如果不传则从本地存储获取）
	 */
	getCampCourses: (campId, userId) => {
		const user_id = String(userId || wx.getStorageSync('wxuserid') || '');
		// 根据 proto 定义，使用 /camp/sections 接口，通过 camp_id 查询参数
		return request({
			url: `/camp/sections?camp_id=${campId}&page=1&page_size=10&user_id=${encodeURIComponent(user_id)}`,
			method: 'GET'
		});
	},

	/**
	 * 检查是否可开启小节（后端查库：上一小节是否完成等）
	 * @param {String} campId - 打卡营ID
	 * @param {String} sectionId - 小节ID
	 * @returns {Promise<{ success: boolean, can_unlock: boolean, message: string }>}
	 */
	canUnlockSection: (campId, sectionId) => {
		return request({
			url: `/camp/can_unlock_section`,
			method: 'POST',
			data: {
				user_id: String(wx.getStorageSync('wxuserid') || ''),
				camp_id: campId,
				section_id: sectionId
			}
		});
	},

	/**
	 * 检查任务是否可以开始（前置任务是否已完成）
	 * @param {String} taskId - 任务ID
	 * @returns {Promise<{ success: boolean, can_start: boolean, reason: string }>}
	 */
	canStartTask: (taskId) => {
		return request({
			url: `/camp/can_start_task`,
			method: 'POST',
			data: {
				user_id: String(wx.getStorageSync('wxuserid') || ''),
				task_id: taskId
			}
		});
	},

	/**
	 * 购买小节（开启第一小节）
	 * @param {String} campId - 打卡营ID
	 * @param {String} sectionId - 小节ID
	 */
	purchaseSection: (campId, sectionId) => {
		return request({
			url: `/camp/purchase_section`,
			method: 'POST',
			data: {
				user_id: String(wx.getStorageSync('wxuserid') || ''),
				camp_id: campId,
				section_id: sectionId
			}
		});
	},

	/**
	 * 获取用户在某营的小节可访问/已购列表
	 * @param {String} campId - 打卡营ID
	 * @param {Number} page - 页码
	 * @param {Number} page_size - 每页数量
	 */
	listUserSectionAccess: (campId, page = 1, page_size = 1000) => {
		return request({
			url: `/camp/list_user_section_access`,
			method: 'POST',
			data: {
				user_id: String(wx.getStorageSync('wxuserid') || ''),
				camp_id: campId,
				page,
				page_size
			}
		});
	},

	/**
	 * 获取每个小节的完成状态
	 * @param {String} campId - 打卡营ID
	 * @param {String} userId - 用户ID
	 */
	getSectionUserStatus: (campId, userId) => {
		return request({
			url: `/camp/section/user-status`,
			method: 'POST',
			data: {
				camp_id: String(campId),
				user_id: String(userId || wx.getStorageSync('wxuserid') || '')
			}
		});
	},

	/**
	 * 根据课程小节ID获取用户与课程小节的关联关系
	 * @param {String} courseIds - 课程ID列表（逗号分隔）
	 * @param {String} userId - 用户ID（可选，如果不传则从本地存储获取）
	 */
	getCourseUserRelations: (courseIds, userId) => {
		const user_id = String(userId || wx.getStorageSync('wxuserid') || '');
		return request({
			url: `/camp/course/user-course-relations?course_ids=${courseIds}&user_id=${encodeURIComponent(user_id)}`,
			method: 'GET',
		});
	},

	/**
	 * 获取课程完成状态
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 */
	getCourseCompleted: (campId, courseId) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/completed`,
			method: 'GET'
		});
	},

	// ==================== 任务相关 ====================

	/**
	 * 获取任务详情（需要 campId 和 courseId）
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 * @param {String} taskType - 任务类型
	 */
	getTaskDetail: (campId, courseId, taskId, taskType) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}?task_type=${taskType.toUpperCase()}`,
			method: 'GET',
		});
	},

	/**
	 * 按任务ID直接获取任务详情（无需 campId/courseId）
	 * @param {String} taskId - 任务ID
	 * @param {String} userId - 用户ID（可选，如果不传则从本地存储获取）
	 */
	getTaskDetailById: (taskId, userId) => {
		const user_id = String(userId || wx.getStorageSync('wxuserid') || '');
		return request({
			url: `/camp/tasks/detail?id=${taskId}&user_id=${encodeURIComponent(user_id)}`,
			method: 'GET',
		});
	},

	/**
	 * 根据任务ID获取任务与用户的关联关系
	 * @param {String} taskIds - 任务ID列表（逗号分隔）
	 * @param {String} userId - 用户ID（可选，如果不传则从本地存储获取）
	 */
	getCampTaskUserRelations: (taskIds, userId) => {
		const user_id = String(userId || wx.getStorageSync('wxuserid') || '');
		return request({
			url: `/camp/task/user_task?task_ids=${taskIds}&user_id=${encodeURIComponent(user_id)}`,
			method: 'GET',
		});
	},

	// ==================== 任务进度相关 ====================

	/**
	 * 获取用户任务进度详情
	 * @param {String} userId - 用户ID
	 * @param {String} taskId - 任务ID
	 */
	getProgressDetail: (userId, taskId) => {
		// GET 请求的参数作为 query 参数传递（兼容微信小程序，不使用 URLSearchParams）
		const user_id = encodeURIComponent(String(userId));
		const task_id = encodeURIComponent(String(taskId));
		return request({
			url: `/camp/progress/info?user_id=${user_id}&task_id=${task_id}`,
			method: 'GET'
		});
		// 注意：request.js 已处理，当 success=false 时不会显示错误提示（没有进度是正常情况）
	},

	/**
	 * 更新任务通用进度
	 * @param {Object} data - 进度数据
	 */
	updateCampProgress: (data) => {
		return request({
			url: `/camp/progress/update`,
			method: 'POST',
			data: data
		});
	},

	/**
	 * 重置任务进度（用户重新答题）
	 * @param {Object} data - 重置数据
	 */
	resetTaskProgress: (data) => {
		return request({
			url: `/camp/reset_task_progress`,
			method: 'POST',
			data: data
		});
	},

	// ==================== 任务类型特定接口 ====================

	/**
	 * 更新视频任务进度
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 * @param {Object} data - 进度数据
	 */
	updateVideoProgress: (campId, courseId, taskId, data) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/video`,
			method: 'POST',
			data: data
		});
	},

	/**
	 * 更新文本图片任务进度
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 * @param {Object} data - 进度数据
	 */
	updateTextImageProgress: (campId, courseId, taskId, data) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/text-image`,
			method: 'POST',
			data: data
		});
	},

	/**
	 * 更新主观题任务进度
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 * @param {Object} data - 进度数据
	 */
	updateSubjectiveQuestionProgress: (campId, courseId, taskId, data) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/subjective`,
			method: 'POST',
			data: data
		});
	},

	/**
	 * 更新申论任务进度
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 * @param {Object} data - 进度数据
	 */
	updateEssayProgress: (campId, courseId, taskId, data) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/essay-question/essay`,
			method: 'POST',
			data: data
		});
	},

	/**
	 * 更新客观题任务进度
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 * @param {Object} data - 进度数据
	 */
	updateObjectiveQuestionProgress: (campId, courseId, taskId, data) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/objective`,
			method: 'POST',
			data: data
		});
	},

	// ==================== 任务答案相关 ====================

	/**
	 * 获取主观题任务的用户答案
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 */
	getSubjectiveTaskUserAnswer: (campId, courseId, taskId) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/subjective/user-answer`,
			method: 'GET',
		});
	},

	/**
	 * 获取申论题任务所有问题的用户答案
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 */
	getEssayQuestionUserAnswer: (campId, courseId, taskId) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/essay-question/user-answer`,
			method: 'GET',
		});
	},

	/**
	 * 获取申论题任务是否需要审核
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 */
	getEssayTaskReviewStatus: (campId, courseId, taskId) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/essay-question/need-audit`,
			method: 'GET',
		});
	},

	/**
	 * 获取客观题答题结算结果
	 * @param {String} campId - 打卡营ID
	 * @param {String} courseId - 课程ID
	 * @param {String} taskId - 任务ID
	 */
	getObjectiveQuestionSettlementResult: (campId, courseId, taskId) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/tasks/${taskId}/objective/settlement-result`,
			method: 'GET',
		});
	},

	// ==================== 订单相关 ====================

	/**
	 * 创建订单（打卡营小节）
	 * @param {Object} orderData - 订单数据
	 */
	createOrder: (orderData) => {
		return request({
			url: `/order/create`,
			method: 'POST',
			data: orderData
		});
	},

	/**
	 * 取消订单
	 * @param {Object} orderData - 订单数据
	 */
	cancelOrder: (orderData) => {
		return request({
			url: `/order/cancel`,
			method: 'POST',
			data: orderData
		});
	},

	// ==================== 支付相关 ====================

	/**
	 * 创建支付（获取预支付ID）
	 * @param {Object} paymentData - 支付数据
	 */
	createPayment: (paymentData) => {
		return request({
			url: `/pay/create`,
			method: 'POST',
			data: paymentData
		});
	},

	/**
	 * 创建打卡营小节支付请求订单（已废弃，使用 createOrder + createPayment）
	 * @deprecated 请使用 createOrder + createPayment
	 */
	createCampPayment: (campId, courseId) => {
		return request({
			url: `/camp/${campId}/course/${courseId}/order`,
			method: 'POST',
		});
	},

	/**
	 * 取消支付
	 * @deprecated 请使用 cancelOrder
	 */
	cancelCampPayment: (campId, orderId) => {
		return request({
			url: `/camp/${campId}/order/${orderId}/cancel`,
			method: 'POST',
		});
	},
};