import db, {
	query,
	executeSql,
	update
} from '@/common/sqlite' // 导入已配置的数据库连接
import {
	formatDate
} from '@/common/utils' // 导入工具函数

import {
	config
} from '@/config/config'

import orderMatService from './orderMatService'

export default {
	/**
	 * 获取模拟订单数据
	 * @param {number} count 生成的数量
	 * @returns {Array} 模拟订单列表
	 */
	getMockOrders(count = 10) {
		const statuses = ['pending', 'processing', 'completed', 'cancelled']
		const statusTexts = {
			pending: '待处理',
			processing: '处理中',
			completed: '已完成',
			cancelled: '已取消'
		}
		const materials = ['钢材', '铝材', '铜材', '塑料', '木材']

		return Array.from({
			length: count
		}, (_, i) => {
			const status = statuses[i % statuses.length]
			return {
				id: i + 1,
				orderNo: `ORD${10000 + i}`,
				status,
				statusText: statusTexts[status],
				createTime: new Date(Date.now() - i * 3600000).toISOString(),
				materials: Array.from({
					length: Math.ceil(Math.random() * 3)
				}, (_, j) => ({
					id: j + 1,
					name: materials[j % materials.length],
					quantity: Math.ceil(Math.random() * 10)
				}))
			}
		})
	},


	/**
	 * 获取订单列表
	 * @param {Object} params 查询参数
	 * @param {string} params.status 订单状态
	 * @param {string} params.orderNo 订单号
	 * @param {Array} params.createTime 创建时间范围
	 * @param {number} params.page 页码
	 * @param {number} params.pageSize 每页条数
	 * @returns {Promise<Array>} 订单列表
	 */
	async getOrderList(
		status,
		orderNo,
		createTime,
		page = 1,
		pageSize = 10
	) {
		try {
			// 构建查询条件和参数
			let whereClause = ''
			let whereArgs = []
			// 状态筛选
			if (status && status != 'all') {
				whereClause += 'status = ?'
				whereArgs.push(status)
			}

			// 订单号搜索
			if (orderNo) {
				if (whereClause) whereClause += ' AND '
				whereClause += 'orderNo LIKE ?'
				whereArgs.push(`%${orderNo}%`)
			}

			// 时间范围筛选
			if (createTime && createTime.length === 2) {
				if (whereClause) whereClause += ' AND '
				whereClause += 'createTime BETWEEN ? AND ?'
				whereArgs.push(createTime[0], createTime[1])
			}

			// 执行查询
			const sql =
				`SELECT * FROM orders ${whereClause ? 'WHERE ' + whereClause : ''} ORDER BY createTime DESC LIMIT ? OFFSET ? `
			const queryArgs = [...whereArgs, pageSize, (page - 1) * pageSize]

			const res = await query(
				sql, queryArgs
			)

			let orders = [];

			for (var index = 0; index < res.length; index++) {
				var element = res[index];
				const materials = await orderMatService.getMaterials(element.orderNo);
				orders.push({
					orderNo: element.orderNo,
					materials
				})
			}

			// 格式化返回数据
			return res.map(order => ({
				...order,
				materials: orders.find(x => x.orderNo == order.orderNo).materials,
				createTime: formatDate(order.createTime) // 格式化日期
			}))

			// return res;
		} catch (error) {
			console.error('获取订单列表失败:', error)
			throw error
		}
	},

	/**
	 * 创建新订单
	 * @param {Object} orderData 订单数据
	 * @param {string} orderData.remark 备注
	 * @param {string} orderData.originalDoc 原始单据
	 * @param {Array} orderData.images 其他图片
	 * @returns {Promise<Object>} 创建的订单
	 */
	async createOrder(orderData) {
		try {

			let userInfo = uni.getStorageSync(config.storageKeys.userInfo);
			if (!userInfo) {
				throw new Error('用户未登录')
			}

			// 生成订单基本信息
			const orderNo = orderData.orderNo
			const createTime = new Date().toISOString()
			const status = 'pending'

			// 执行插入
			const sql = `
				INSERT INTO orders (orderNo, remark, originalDoc, createTime, status, createUserId, customer)
				VALUES (?, ?, ?, ?, ?, ?, ?)
			  `
			const args = [
				orderData.orderNo,
				orderData.remark,
				orderData.originalDoc,
				createTime,
				status,
				userInfo.id,
				orderData.customer
			]

			const res = await executeSql(
				sql,
				args
			)

			// 返回创建的订单
			return {
				id: res.insertId,
				orderNo,
				...orderData,
				createTime: formatDate(createTime),
				status,
				statusText: '待处理'
			}
		} catch (error) {
			console.error('创建订单失败:', error)
			throw error
		}
	},

	async updateOrderStatus(orderNo, status) {
		try {
			update('orders', {
				status: status
			}, ' orderNo = ?', [orderNo]);
		} catch (e) {
			console.error('updateOrderStatus', e)
		}

	},

	async getOrderByOrderNo(orderNo) {
		try {
			// 执行查询
			const sql =
				`SELECT * FROM orders WHERE orderNo = ?`
			const result = await query(sql, [orderNo]);
			return result[0];
		} catch (e) {
			console.log(e)
		}
	},

	async updateOrderCustomer(orderNo, name) {
		update('orders', {
			customer: name
		}, ' orderNo = ?', [orderNo]);
	}
}