<template>
	<view class="clone-tool-container">
		<!-- 上方日志展示区域 -->
		<view class="log-section">
			<view class="log-header">
				<text class="log-title">日志输出</text>
				<view class="log-actions">
					<button class="btn-small" @click="clearLog">清空</button>
					<button class="btn-small" @click="exportLog">导出</button>
				</view>
			</view>
			<scroll-view class="log-content" scroll-y scroll-with-animation :scroll-top="scrollTop">
				<view v-for="(log, index) in logs" :key="index" class="log-item">
					<text>{{ log }}</text>
				</view>
				<view v-if="logs.length === 0" class="empty-log">
					<text>暂无日志信息</text>
				</view>
			</scroll-view>
		</view>

		<!-- 下方控制按钮区域 -->
		<view class="control-section">
			<!-- 状态显示 -->
			<view class="status-bar">
				<text class="status-text">{{ status }}</text>
			</view>

			<!-- 主要功能按钮 -->
			<view class="main-buttons">
				<button class="function-btn account-btn" @click="showAccountModal = true">
					<text class="btn-label">账号配置</text>
				</button>

				<button class="function-btn fetch-btn" @click="showFetchModal = true">
					<text class="btn-label">拉取商品</text>
				</button>

				<button class="function-btn price-btn" @click="showPriceModal = true">
					<text class="btn-label">价格配置</text>
				</button>



				<button class="function-btn process-btn" @click="showProcessModal = true">
					<text class="btn-label">处理控制</text>
				</button>
			</view>
		</view>

		<!-- 底部状态栏 -->
		<view class="status-bar">
			<text>{{ progressText }}</text>
			<text>{{ currentItemText }}</text>
		</view>

		<!-- 账号配置模态框 -->
		<view v-if="showAccountModal" class="modal-overlay" @click="showAccountModal = false">
			<view class="modal-content" @click.stop>
				<view class="modal-header">
					<text class="modal-title">账号配置</text>
					<text class="modal-close" @click="showAccountModal = false">×</text>
				</view>
				<view class="modal-body">
					<view class="form-item">
						<text class="label">用户名:</text>
						<input class="input" v-model="config.username" placeholder="请输入用户名" />
					</view>
					<view class="form-item">
						<text class="label">密码:</text>
						<input class="input" v-model="config.password" type="password" placeholder="请输入密码" />
					</view>
				</view>
				<view class="modal-footer">
					<button class="btn-secondary" @click="showAccountModal = false">取消</button>
					<!-- <button class="btn-primary" @click="saveConfig">保存配置</button> -->
					<button class="btn-primary" @click="login">登录</button>
				</view>
			</view>
		</view>

		<!-- 拉取商品模态框 -->
		<view v-if="showFetchModal" class="modal-overlay" @click="showFetchModal = false">
			<view class="modal-content" @click.stop>
				<view class="modal-header">
					<text class="modal-title">拉取商品设置</text>
					<text class="modal-close" @click="showFetchModal = false">×</text>
				</view>
				<view class="modal-body">
					<view class="form-item">
						<text class="label">货号:</text>
						<input class="input" v-model="fetchParams.itemSn" placeholder="请输入货号" />
					</view>
					<view class="form-item">
						<text class="label">价格范围:</text>
						<view class="price-range-container">
							<input class="input price-range-input" v-model="fetchParams.priceMin" placeholder="最低价格"
								type="digit" inputmode="decimal" />
							<text class="price-separator">-</text>
							<input class="input price-range-input" v-model="fetchParams.priceMax" placeholder="最高价格"
								type="digit" inputmode="decimal" />
						</view>
					</view>
					<view class="form-item">
						<text class="label">开始日期:</text>
						<view class="date-input-container">
							<picker mode="date" :value="startDateFormatted" @change="onStartDateChange"
								class="date-picker">
								<view class="picker-text">{{ fetchParams.startDate || '请选择开始日期' }}</view>
							</picker>
							<button v-if="fetchParams.startDate" class="clear-btn" @click="clearStartDate">×</button>
						</view>
					</view>
					<view class="form-item">
						<text class="label">结束日期:</text>
						<view class="date-input-container">
							<picker mode="date" :value="endDateFormatted" @change="onEndDateChange" class="date-picker">
								<view class="picker-text">{{ fetchParams.endDate || '请选择结束日期' }}</view>
							</picker>
							<button v-if="fetchParams.endDate" class="clear-btn" @click="clearEndDate">×</button>
						</view>
					</view>
				</view>
				<view class="modal-footer">
					<button class="btn-secondary" @click="showFetchModal = false">取消</button>
					<button class="btn-primary" @click="confirmFetchItems" :disabled="fetching">
						{{ fetching ? '拉取中...' : '开始拉取' }}
					</button>
				</view>
			</view>
		</view>

		<!-- 价格配置模态框 -->
		<view v-if="showPriceModal" class="modal-overlay" @click="showPriceModal = false">
			<view class="modal-content" @click.stop>
				<view class="modal-header">
					<text class="modal-title">价格配置设置</text>
					<text class="modal-close" @click="showPriceModal = false">×</text>
				</view>
				<view class="modal-body">
					<view class="form-item">
						<text class="label">调整类型:</text>
						<radio-group @change="onPriceTypeChange" class="radio-group">
							<label class="radio-item">
								<radio value="1" :checked="priceConfig.configType === 1" />折扣
							</label>
							<label class="radio-item">
								<radio value="2" :checked="priceConfig.configType === 2" />加减值
							</label>
							<label class="radio-item">
								<radio value="3" :checked="priceConfig.configType === 3" />指定金额
							</label>
						</radio-group>
					</view>
					<view class="form-item">
						<text class="label">调整值:</text>
						<view class="price-input-container">
							<!-- 加减值类型显示正负号选择 -->
							<picker v-if="priceConfig.configType === 2" mode="selector" :range="signOptions"
								:value="signIndex" @change="onSignChange" class="sign-picker">
								<view class="sign-text">{{ signOptions[signIndex] }}</view>
							</picker>
							<input class="input price-input" v-model="priceConfig.value"
								:placeholder="getPlaceholderText()" type="digit" @input="onPriceValueInput"
								@keypress="onKeyPress" inputmode="decimal" />
						</view>
						<!-- 根据配置类型显示不同的提示文字 -->
						<text class="price-hint-text">
							<text v-if="priceConfig.configType === 1">请输入0-100内的折扣数字</text>
							<text v-else-if="priceConfig.configType === 2">选择加减符号并输入相应的数字进行调整值</text>
							<text v-else-if="priceConfig.configType === 3">请输入纯数字</text>
						</text>
					</view>
				</view>
				<view class="modal-footer">
					<button class="btn-secondary" @click="showPriceModal = false">取消</button>
					<button class="btn-primary" @click="confirmSavePriceConfig">保存配置</button>
				</view>
			</view>
		</view>

		<!-- 处理控制模态框 -->
		<view v-if="showProcessModal" class="modal-overlay" @click="showProcessModal = false">
			<view class="modal-content" @click.stop>
				<view class="modal-header">
					<text class="modal-title">处理控制</text>
					<text class="modal-close" @click="showProcessModal = false">×</text>
				</view>
				<view class="modal-body">
					<view class="process-controls">
						<button class="control-btn start-btn" @click="startProcessing" :disabled="processing">
							<text class="btn-icon">▶️</text>
							<text class="btn-text">开始处理</text>
						</button>
						<button class="control-btn pause-btn" @click="togglePause" :disabled="!processing">
							<text class="btn-icon">{{ paused ? '▶️' : '⏸️' }}</text>
							<text class="btn-text">{{ paused ? '继续' : '暂停' }}</text>
						</button>
						<button class="control-btn stop-btn" @click="stopProcessing" :disabled="!processing">
							<text class="btn-icon">⏹️</text>
							<text class="btn-text">停止</text>
						</button>
					</view>
					<view class="process-info">
						<text class="info-text">当前状态: {{ status }}</text>
						<text class="info-text">处理进度: {{ progressText }}</text>
					</view>
				</view>
				<view class="modal-footer">
					<button class="btn-secondary" @click="showProcessModal = false">关闭</button>
				</view>
			</view>
		</view>


	</view>
</template>

<script>
	import request from '@/utils/request.js';
	import {
		generateDeviceId,
		validateDate,
		dateToTimestamp,
		adjustPrice,
		formatLogMessage,
		saveToStorage,
		loadFromStorage,
		getNewItemIds,
		clearNewItemIds
	} from '@/utils/clone-tool.js';
	import {
		login as kongfzLogin,
		fetchItems as kongfzFetchItems,
		getItemTplFields as kongfzGetItemTplFields,
		submitItemForm as kongfzSubmitItemForm,
		deleteItem as kongfzDeleteItem,
		batchUpdatePddPlatformId
	} from '@/api/kongfz.js';

	export default {
		data() {
			return {
				// 配置信息
				config: {
					username: '',
					password: '',
					token: ''
				},
				// 价格配置
				priceConfig: {
					configType: 1, // 1: 折扣, 2: 加减值, 3: 指定金额
					value: 1.0
				},
				// 正负号选择
				signOptions: ['+', '-'],
				signIndex: 0,
				// 拉取参数
				fetchParams: {
					itemSn: '',
					priceMin: '',
					priceMax: '',
					startDate: '',
					endDate: ''
				},
				// 处理状态
				processing: false,
				paused: false,
				fetching: false,
				status: '就绪',
				// 日志
				logs: [],
				scrollTop: 0,
				// 进度
				progressText: '0/0',
				currentItemText: '当前商品: 无',
				// 商品列表
				itemList: [],
				currentItemIndex: -1,
				// 设备ID
				deviceId: '',
				// 模态框控制
				showAccountModal: false,
				showFetchModal: false,
				showPriceModal: false,
				showProcessModal: false
			};
		},
		onLoad() {
			// 生成设备ID
			this.deviceId = generateDeviceId();
			this.log(`设备ID: ${this.deviceId}`);

			// 加载配置
			this.config = loadFromStorage('kongfz_config', this.config);
			const savedPriceConfig = loadFromStorage('kongfz_price_config', this.priceConfig);
			this.priceConfig = savedPriceConfig;
			// 加载正负号信息
			if (savedPriceConfig && savedPriceConfig.signIndex !== undefined) {
				this.signIndex = savedPriceConfig.signIndex;
			}

			// 加载商品列表
			const itemList = loadFromStorage('kongfz_item_list');
			if (itemList) {
				this.itemList = itemList;
			}

			// 加载新商品ID列表
			this.newItemIds = getNewItemIds();

			this.log('配置已加载');
			if (this.newItemIds.length > 0) {
				this.log(`已加载 ${this.newItemIds.length} 个新商品ID`);
			}
		},
		computed: {
			// 开始日期格式化为YYYY-MM-DD格式供picker使用
			startDateFormatted() {
				if (!this.fetchParams.startDate) return '';
				const date = this.fetchParams.startDate;
				if (date.length === 8) {
					return `${date.substring(0, 4)}-${date.substring(4, 6)}-${date.substring(6, 8)}`;
				}
				return date;
			},
			// 结束日期格式化为YYYY-MM-DD格式供picker使用
			endDateFormatted() {
				if (!this.fetchParams.endDate) return '';
				const date = this.fetchParams.endDate;
				if (date.length === 8) {
					return `${date.substring(0, 4)}-${date.substring(4, 6)}-${date.substring(6, 8)}`;
				}
				return date;
			}
		},
		methods: {
			// 开始日期选择处理
			onStartDateChange(e) {
				const selectedDate = e.detail.value;
				this.fetchParams.startDate = selectedDate.replace(/-/g, '');
			},
			// 结束日期选择处理
			onEndDateChange(e) {
				const selectedDate = e.detail.value;
				this.fetchParams.endDate = selectedDate.replace(/-/g, '');
			},
			// 清空开始日期
			clearStartDate() {
				this.fetchParams.startDate = '';
			},
			// 清空结束日期
			clearEndDate() {
				this.fetchParams.endDate = '';
			},
			// 价格类型选择处理
			onPriceTypeChange(e) {
				this.priceConfig.configType = parseInt(e.detail.value);
				// 重置调整值
				this.priceConfig.value = this.priceConfig.configType === 1 ? 1.0 : 0;
				// 重置正负号为正号
				this.signIndex = 0;
			},
			// 正负号选择处理
			onSignChange(e) {
				this.signIndex = e.detail.value;
			},
			// 获取输入框提示文本
			getPlaceholderText() {
				switch (this.priceConfig.configType) {
					case 1:
						return '请输入0-100的折扣值';
					case 2:
						return '请输入数字';
					case 3:
						return '请输入指定金额';
					default:
						return '请输入调整值';
				}
			},
			// 键盘按键事件处理（阻止非数字字符输入）
			onKeyPress(e) {
				const char = String.fromCharCode(e.which || e.keyCode);
				const currentValue = this.priceConfig.value || '';

				// 只允许数字和小数点
				if (!/[\d.]/.test(char)) {
					e.preventDefault();
					return false;
				}

				// 如果是小数点，检查是否已经有小数点
				if (char === '.' && currentValue.includes('.')) {
					e.preventDefault();
					return false;
				}

				return true;
			},

			// 价格值输入处理
			onPriceValueInput(e) {
				let value = e.detail.value;

				// 严格过滤：只允许数字和小数点，移除所有非数字字符（包括汉字）
				value = value.replace(/[^\d.]/g, '');

				// 防止多个小数点
				const dotCount = (value.match(/\./g) || []).length;
				if (dotCount > 1) {
					const firstDotIndex = value.indexOf('.');
					value = value.substring(0, firstDotIndex + 1) + value.substring(firstDotIndex + 1).replace(/\./g, '');
				}

				// 防止以小数点开头
				if (value.startsWith('.')) {
					value = '0' + value;
				}

				// 折扣类型限制0-100
				if (this.priceConfig.configType === 1) {
					const numValue = parseFloat(value);
					if (numValue > 100) {
						value = '100';
						uni.showToast({
							title: '折扣值不能超过100',
							icon: 'none'
						});
					}
				}

				// 更新值
				this.priceConfig.value = value;

				// 强制更新输入框显示（防止输入汉字后显示异常）
				this.$nextTick(() => {
					this.priceConfig.value = value;
				});
			},

			// 保存配置
			saveConfig() {
				if (saveToStorage('kongfz_config', this.config)) {
					this.log('配置已保存');
					this.showAccountModal = false; // 关闭弹框
				} else {
					this.log('保存配置失败');
				}
			},

			// 加载价格配置
			loadPriceConfig() {
				const savedPriceConfig = loadFromStorage('kongfz_price_config', this.priceConfig);
				this.priceConfig = savedPriceConfig;
				// 加载正负号信息
				if (savedPriceConfig && savedPriceConfig.signIndex !== undefined) {
					this.signIndex = savedPriceConfig.signIndex;
				}
				console.log('已加载价格配置:', this.priceConfig);
			},

			// 保存价格配置
			savePriceConfig() {
				// 验证价格值是否为数字
				let value = parseFloat(this.priceConfig.value);
				if (isNaN(value)) {
					uni.showToast({
						title: '请输入有效的数值',
						icon: 'none'
					});
					return;
				}

				// 折扣类型验证范围
				if (this.priceConfig.configType === 1 && (value < 0 || value > 100)) {
					uni.showToast({
						title: '折扣值必须在0-100之间',
						icon: 'none'
					});
					return;
				}

				// 加减值类型处理正负号
				if (this.priceConfig.configType === 2 && parseInt(this.signIndex) === 1) {
					value = -Math.abs(value); // 确保是负数
				}

				// 保存配置时包含正负号信息
				const configToSave = {
					...this.priceConfig,
					value: value,
					signIndex: this.signIndex
				};
				console.log("价格配置", configToSave)

				if (saveToStorage('kongfz_price_config', configToSave)) {
					this.log('价格配置已保存');
				} else {
					this.log('保存价格配置失败');
				}
			},

			// 登录
			async login() {
				const {
					username,
					password
				} = this.config;

				if (!username || !password) {
					uni.showToast({
						title: '请输入用户名和密码',
						icon: 'none'
					});
					return;
				}

				this.log('正在登录...');
				this.status = '登录中...';

				try {
					// 调用登录API
					const result = await kongfzLogin(username, password);

					if (result.success) {
						console.log("token", result);
						this.config.token = result.token;
						this.saveConfig();
						this.log(`登录成功! Token: ${result.token}`);
						this.status = '登录成功';

						// 关闭账号配置模态框
						this.showAccountModal = false;

						// 显示成功提示
						uni.showToast({
							title: '登录成功',
							icon: 'success',
							duration: 2000
						});
					} else {
						// 处理登录失败情况
						this.handleLoginError(result);
					}
				} catch (err) {
					console.error('登录出错:', err);
					this.log(`登录失败: ${err.message}`);
					this.status = '登录失败';

					// 显示网络错误提示
					uni.showModal({
						title: '登录失败',
						content: '网络异常或服务器错误，请检查网络连接后重试',
						showCancel: false
					});
				}
			},

			// 处理登录错误
			handleLoginError(result) {
				this.log(result.message || '登录失败');
				this.status = '登录失败';

				// 根据错误码显示不同的错误信息
				let errorTitle = '登录失败';
				let errorContent = result.message || '未知错误';

				// 检查是否有具体的错误码
				if (result.responseData) {
					const errCode = result.responseData.errCode;
					const errInfo = result.responseData.errInfo;

					switch (errCode) {
						case 102:
							errorContent = '用户名不能为空';
							break;
						case 1000:
							errorContent = '授权码错误或已过期';
							break;
						case 1001:
							errorContent = '用户不存在，请检查用户名是否正确';
							break;
						case 1005:
							errorContent = '密码错误，请检查密码是否正确';
							break;
						case 1009:
							errorContent = '调用次数已达上限，请稍后再试';
							break;
						default:
							if (errInfo) {
								errorContent = errInfo;
							}
							break;
					}

					// 检查是否需要手机验证
					if (result.responseData.extInfo &&
						result.responseData.extInfo.action === "redirect" &&
						result.responseData.extInfo.uri &&
						result.responseData.extInfo.uri.includes("请使用手机号验证登录")) {
						errorTitle = '需要手机验证';
						errorContent = '该账号需要手机验证登录，请使用其他账号或到网页端完成验证';
					}
				}

				// 显示错误弹框
				uni.showModal({
					title: errorTitle,
					content: errorContent,
					showCancel: false,
					confirmText: '确定'
				});
			},

			// 确认拉取商品
			confirmFetchItems() {
				this.showFetchModal = false;
				this.startFetchItems();
			},

			// 确认保存价格配置
			confirmSavePriceConfig() {
				this.showPriceModal = false;
				this.savePriceConfig();
				// 更新当前的价格配置
				this.loadPriceConfig();
			},

			// 开始拉取商品
			startFetchItems() {
				if (this.fetching) {
					return;
				}

				// 获取输入参数
				const {
					itemSn,
					priceMin,
					priceMax,
					startDate,
					endDate
				} = this.fetchParams;

				// 验证日期格式
				if (startDate && !validateDate(startDate)) {
					uni.showToast({
						title: '开始日期格式错误，请输入YYYYMMDD格式的日期',
						icon: 'none'
					});
					return;
				}

				if (endDate && !validateDate(endDate)) {
					uni.showToast({
						title: '结束日期格式错误，请输入YYYYMMDD格式的日期',
						icon: 'none'
					});
					return;
				}

				// 验证时间范围
				if (startDate && endDate) {
					try {
						const startTs = dateToTimestamp(startDate, false);
						const endTs = dateToTimestamp(endDate, true);
						if (endTs <= startTs) {
							uni.showToast({
								title: '结束日期必须大于开始日期',
								icon: 'none'
							});
							return;
						}
					} catch (e) {
						this.log(`日期转换错误: ${e.message}`);
						return;
					}
				}

				// 准备参数
				const params = {};
				if (itemSn) {
					params.itemSn = itemSn;
				}

				if (priceMin) {
					try {
						parseFloat(priceMin); // 验证是否为数字
						params.priceMin = priceMin;
					} catch (e) {
						uni.showToast({
							title: '最低价格格式错误，请输入有效数字',
							icon: 'none'
						});
						return;
					}
				}

				if (priceMax) {
					try {
						parseFloat(priceMax); // 验证是否为数字
						params.priceMax = priceMax;
					} catch (e) {
						uni.showToast({
							title: '最高价格格式错误，请输入有效数字',
							icon: 'none'
						});
						return;
					}
				}

				if (startDate) {
					try {
						const startTs = dateToTimestamp(startDate, false);
						params.startCreateTime = startTs.toString();
					} catch (e) {
						this.log(`开始日期转换错误: ${e.message}`);
						return;
					}
				}

				if (endDate) {
					try {
						const endTs = dateToTimestamp(endDate, true);
						params.endCreateTime = endTs.toString();
					} catch (e) {
						this.log(`结束日期转换错误: ${e.message}`);
						return;
					}
				}

				this.log('开始拉取商品...');
				this.status = '拉取商品中...';
				this.fetching = true;

				// 执行拉取
				this.fetchItems(params);
			},

			// 拉取商品
			fetchItems(params) {
				const token = this.config.token;
				if (!token) {
					this.log('请先登录获取Token');
					this.fetching = false;
					this.status = '就绪';
					return;
				}

				// 调用API获取商品列表
				console.log(`开始拉取商品...`);
				this.log(`请求参数：${JSON.stringify(params)}`);
				this.log(`使用Token：${token.substring(0, 4)}...${token.substring(token.length - 4)}`);

				kongfzFetchItems(token, params, (progressMessage) => {
						// 进度回调
						this.log(progressMessage);
					})
					.then(allItemIds => {
						if (allItemIds.length > 0) {
							this.itemList = allItemIds;
							this.log(`✅ 成功拉取 ${allItemIds.length} 个商品`);
							this.log(
								`📋 商品ID列表: ${allItemIds.slice(0, 5).map(item => item.id).join(', ')}${allItemIds.length > 5 ? '...' : ''}`
								);

							// 统计商品状态
							const statusCounts = allItemIds.reduce((acc, item) => {
								acc[item.status] = (acc[item.status] || 0) + 1;
								return acc;
							}, {});
							this.log(
								`📊 商品状态统计: ${Object.entries(statusCounts).map(([status, count]) => `${status}=${count}`).join(', ')}`
								);
							console.log("保存数据", allItemIds)
							// 保存到本地存储
							saveToStorage('kongfz_item_list', allItemIds);
							this.log('💾 商品列表已保存到本地存储');
						} else {
							this.log('⚠️ 没有找到符合条件的商品');
							this.log('请检查以下可能的原因:');
							this.log('1. 筛选条件是否过于严格');
							this.log('2. 账号中是否有在售商品');
							this.log('3. 日期范围是否正确');
						}

						this.fetching = false;
						this.status = '就绪';
						this.log('拉取商品完成');
					})
					.catch(err => {
						this.log(`❌ 拉取商品失败: ${err.message}`);
						this.log('🔍 请检查以下可能的问题:');
						this.log('1. 网络连接是否正常');
						this.log('2. 登录状态是否有效 (Token可能已过期)');
						this.log('3. 孔夫子网站是否可访问');
						this.log('4. 请求参数是否正确');

						// 建议用户重新登录
						this.log('建议尝试重新登录后再次拉取');

						this.fetching = false;
						this.status = '拉取失败';

						// 3秒后恢复状态
						setTimeout(() => {
							if (this.status === '拉取失败') {
								this.status = '就绪';
							}
						}, 3000);
					});
			},

			// 开始处理商品
			startProcessing() {
				if (this.processing) {
					return;
				}

				// 检查是否有商品列表
				if (!this.itemList || this.itemList.length === 0) {
					try {
						const itemListStr = uni.getStorageSync('kongfz_item_list');
						if (itemListStr) {
							this.itemList = JSON.parse(itemListStr);
						}
					} catch (e) {
						this.log('读取商品列表失败: ' + e.message);
					}

					if (!this.itemList || this.itemList.length === 0) {
						uni.showToast({
							title: '没有可处理的商品，请先拉取商品',
							icon: 'none'
						});
						return;
					}
				}

				// 检查是否已登录
				if (!this.config.token) {
					this.log('请先登录获取Token');
					uni.showToast({
						title: '请先登录',
						icon: 'none'
					});
					return;
				}

				this.processing = true;
				this.paused = false;
				this.status = '处理中...';
				this.log('开始处理商品...');

				// 清除之前的新商品ID存储数据
				try {
					uni.removeStorageSync('kongfz_new_ids');
					this.log('已清除之前的新商品ID记录');
				} catch (e) {
					this.log('清除新商品ID记录失败: ' + e.message);
				}

				// 重置进度
				this.currentItemIndex = -1;
				const waitingItems = this.itemList.filter(item => item.status === 'wait');
				this.progressText = `0/${waitingItems.length}`;

				// 保存当前商品列表到本地存储
				saveToStorage('kongfz_item_list', this.itemList);

				// 开始处理
				this.processNextItem();
			},

			// 处理下一个商品
			processNextItem() {
				if (!this.processing || this.paused) {
					return;
				}

				// 查找下一个待处理的商品
				let nextItemIndex = -1;
				for (let i = 0; i < this.itemList.length; i++) {
					if (this.itemList[i].status === 'wait') {
						nextItemIndex = i;
						break;
					}
				}

				if (nextItemIndex === -1) {
					// 所有商品已处理完成
					this.log('所有商品处理完成!');
					this.stopProcessing();
					return;
				}

				this.currentItemIndex = nextItemIndex;
				const currentItem = this.itemList[nextItemIndex];
				const itemId = currentItem.id;

				this.currentItemText = `当前商品: ${itemId}`;
				this.log(`处理商品: ${itemId}`);

				// 获取商品模板字段
				this.log(`获取商品 ${itemId} 的模板字段...`);
				console.log("通过itemId获取模板", itemId)
				this.getItemTplFields(itemId).then(itemData => {
					console.log("itemData", itemData)
					if (itemData) {
						// 保存商品数据
						this.log(`保存商品 ${itemId} 数据...`);
						this.saveItemData(itemId, itemData);

						// 更新状态为geted
						this.updateItemStatus(nextItemIndex, 'geted');

						// 更新进度
						const waitingItems = this.itemList.filter(item => item.status === 'wait');
						const processedItems = this.itemList.filter(item => item.status !== 'wait').length;
						this.progressText = `${processedItems}/${processedItems + waitingItems.length}`;

						// 保存当前状态到本地存储
						saveToStorage('kongfz_item_list', this.itemList);

						// 提交商品表单
						this.log(`提交商品 ${itemId}...`);
						console.log("itemData", itemData)
						this.submitItemForm(itemData).then(success => {
							if (success) {
								this.log(`商品 ${itemId} 提交成功`);

								// 刷新新商品ID列表
								// this.refreshNewItemIds();

								// 删除原商品
								this.deleteItem(itemId).then(deleteSuccess => {
									if (deleteSuccess) {
										this.updateItemStatus(nextItemIndex, 'delete');
										this.log(`原商品 ${itemId} 已删除`);
									} else {
										this.updateItemStatus(nextItemIndex, 'delete_error');
										this.log(`警告: 原商品 ${itemId} 删除失败`);
									}
									console.log("保存数据1", this.itemList)
									// 保存当前状态到本地存储
									saveToStorage('kongfz_item_list', this.itemList);

									// 立即处理当前商品的孔更新
									this.log(`开始处理商品 ${itemId} 的平台ID更新...`);
									this.processSinglePddItem(itemId).then(() => {
										this.log(`孔商品 ${itemId} 处理完成`);
										// 延迟5秒后处理下一个
										this.log('等待5秒...');
										setTimeout(() => this.processNextItem(), 5000);
									}).catch(err => {
										this.log(`商品 ${itemId} 孔处理失败: ${err.message}`);
										// 延迟5秒后处理下一个
										this.log('等待5秒...');
										setTimeout(() => this.processNextItem(), 5000);
									});
								});
							} else {
								this.log(`商品 ${itemId} 提交失败`);
								this.updateItemStatus(nextItemIndex, 'clone_error');

								// 保存当前状态到本地存储
								saveToStorage('kongfz_item_list', this.itemList);

								// 延迟5秒后处理下一个
								this.log('等待5秒...');
								setTimeout(() => this.processNextItem(), 5000);
							}
						});
					} else {
						// 更新状态为error
						this.updateItemStatus(nextItemIndex, 'error');
						this.log(`商品 ${itemId} 处理失败`);

						// 保存当前状态到本地存储
						saveToStorage('kongfz_item_list', this.itemList);

						// 延迟5秒后处理下一个
						this.log('等待5秒...');
						setTimeout(() => this.processNextItem(), 5000);
					}
				}).catch(err => {
					this.log(`处理商品 ${itemId} 时出错: ${err.message}`);
					this.updateItemStatus(nextItemIndex, 'error');

					// 保存当前状态到本地存储
					saveToStorage('kongfz_item_list', this.itemList);

					// 延迟5秒后处理下一个
					this.log('等待5秒...');
					setTimeout(() => this.processNextItem(), 5000);
				});
			},

			// 暂停/继续处理
			togglePause() {
				this.paused = !this.paused;

				if (this.paused) {
					this.log('处理已暂停...');
					this.status = '已暂停';
				} else {
					this.log('继续处理...');
					this.status = '处理中...';
					this.processNextItem();
				}
			},

			// 停止处理
			stopProcessing() {
				this.processing = false;
				this.paused = false;
				this.log('处理已停止');
				this.status = '已停止';
				this.currentItemText = '当前商品: 无';
			},

			// 获取商品模板字段
			getItemTplFields(itemId) {
				return kongfzGetItemTplFields(this.config.token, itemId);
			},

			// 保存商品数据
			saveItemData(itemId, data) {
				try {
					// 保存到本地存储
					const key = `kongfz_item_${itemId}`;
					saveToStorage(key, data);
					return true;
				} catch (e) {
					this.log(`保存商品数据失败: ${e.message}`);
					return false;
				}
			},

			// 更新商品状态
			updateItemStatus(index, newStatus) {
				if (index >= 0 && index < this.itemList.length) {
					this.itemList[index].status = newStatus;
					// 不在每次状态更新时都保存，而是在processNextItem方法的关键点保存
				}
			},

			// 提交商品表单
			submitItemForm(itemData) {
				return kongfzSubmitItemForm(this.config.token, itemData, this.priceConfig);
			},

			// 删除原商品
			deleteItem(itemId) {
				return kongfzDeleteItem(this.config.token, itemId);
			},

			// 添加日志
			log(message) {
				const logMessage = formatLogMessage(message);
				this.logs.push(logMessage);

				// 同时输出到控制台
				console.log(logMessage);

				// 保持日志不超过1000条
				if (this.logs.length > 1000) {
					this.logs.shift();
				}

				// 自动滚动到底部
				this.$nextTick(() => {
					const query = uni.createSelectorQuery().in(this);
					query.select('.log-content').fields({
						scrollOffset: true,
						size: true
					}, (data) => {
						if (data && data.scrollHeight > data.height) {
							// 计算需要滚动的距离
							const maxScrollTop = data.scrollHeight - data.height;
							this.scrollTop = maxScrollTop;
						}
					}).exec();
				});
			},

			// 清空日志
			clearLog() {
				this.logs = [];
				this.log('日志已清空');
			},

			// 导出日志
			exportLog() {
				if (this.logs.length === 0) {
					uni.showToast({
						title: '暂无日志可导出',
						icon: 'none'
					});
					return;
				}

				const logContent = this.logs.join('\n');
				const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
				const filename = `clone-tool-log-${timestamp}.txt`;

				// 在小程序环境中，可以使用分享功能
				uni.showActionSheet({
					itemList: ['复制到剪贴板', '分享日志'],
					success: (res) => {
						if (res.tapIndex === 0) {
							uni.setClipboardData({
								data: logContent,
								success: () => {
									uni.showToast({
										title: '日志已复制到剪贴板',
										icon: 'success'
									});
								}
							});
						} else if (res.tapIndex === 1) {
							// 分享功能
							uni.share({
								provider: 'weixin',
								type: 0,
								title: '克隆工具日志',
								summary: `日志内容，共${this.logs.length}条记录`,
								success: () => {
									this.log('日志分享成功');
								},
								fail: (err) => {
									this.log(`日志分享失败: ${err.errMsg}`);
								}
							});
						}
					}
				});
			},

			// 开始孔商品处理
			startPddProcessing() {
				if (this.pddProcessing) {
					return;
				}

				// 获取新商品ID列表
				const newItemIds = getNewItemIds();
				if (!newItemIds || newItemIds.length === 0) {
					uni.showToast({
						title: '没有找到新商品ID，请先完成商品处理',
						icon: 'none'
					});
					this.log('孔处理失败: 没有找到新商品ID');
					return;
				}

				// 检查是否有对应的旧商品ID
				if (!this.itemList || this.itemList.length === 0) {
					uni.showToast({
						title: '没有找到原始商品列表，请先拉取商品',
						icon: 'none'
					});
					this.log('孔处理失败: 没有找到原始商品列表');
					return;
				}

				this.pddProcessing = true;
				this.pddStatus = '处理中...';
				this.pddProcessedItems = [];

				this.log('开始孔商品处理...');
				this.log(`找到 ${newItemIds.length} 个新商品ID`);
				this.log(`原始商品列表包含 ${this.itemList.length} 个商品`);

				// 构建ID对应关系 - 使用存储的映射关系而不是索引匹配
				const idMappings = [];

				// 遍历新商品ID列表，每个项目现在包含oldId和newId的映射
				for (const item of newItemIds) {
					// 严格校验oldId和newId都不为空
					if (item.oldId && item.newId &&
						String(item.oldId).trim() !== '' &&
						String(item.newId).trim() !== '') {
						idMappings.push({
							oldPlatformId: String(item.oldId),
							newPlatformId: String(item.newId)
						});
					} else {
						// 记录跳过的无效数据
						this.log(`跳过无效数据: oldId=${item.oldId || '空'}, newId=${item.newId || '空'}`);
					}
				}

				if (idMappings.length === 0) {
					this.pddProcessing = false;
					this.pddStatus = '处理失败';
					uni.showToast({
						title: '没有找到有效的ID对应关系',
						icon: 'none'
					});
					this.log('孔处理失败: 没有找到有效的ID对应关系');
					return;
				}

				this.pddProgressText = `0/${idMappings.length}`;
				this.log(`准备处理 ${idMappings.length} 个商品ID对应关系`);

				// 调用批量更新接口
				this.processPddBatch(idMappings);
			},

			// 处理单个商品的孔平台ID更新
			processSinglePddItem(oldItemId) {
				return new Promise((resolve, reject) => {
					// 获取新商品ID列表
					const newItemIds = getNewItemIds();

					if (!newItemIds || newItemIds.length === 0) {
						reject(new Error('没有找到新商品ID记录'));
						return;
					}

					// 查找对应的新商品ID
					const matchedItem = newItemIds.find(item =>
						item.oldId && String(item.oldId).trim() === String(oldItemId).trim()
					);

					if (!matchedItem || !matchedItem.newId || String(matchedItem.newId).trim() === '') {
						reject(new Error(`未找到商品 ${oldItemId} 对应的新商品ID`));
						return;
					}

					// 构建单个商品的ID映射
					const idMapping = [{
						oldPlatformId: String(matchedItem.oldId),
						newPlatformId: String(matchedItem.newId)
					}];

					this.log(`找到商品 ${oldItemId} 对应的新ID: ${matchedItem.newId}`);

					// 调用批量更新接口（虽然只有一个商品）
					batchUpdatePddPlatformId(idMapping)
						.then(result => {
							if (result.success) {
								this.log(`商品 ${oldItemId} 孔平台ID更新成功`);
								resolve(result);
							} else {
								reject(new Error(result.message || '更新失败'));
							}
						})
						.catch(err => {
							reject(err);
						});
				});
			},

			// 处理孔批量更新
			processPddBatch(idMappings) {
				this.pddCurrentItemText = `正在批量更新 ${idMappings.length} 个商品...`;

				batchUpdatePddPlatformId(idMappings)
					.then(result => {
						if (result.success) {
							this.pddStatus = '处理完成';
							this.pddProgressText = `${idMappings.length}/${idMappings.length}`;
							this.pddCurrentItemText = '批量更新完成';
							this.log(`孔商品处理成功: ${result.message}`);
							this.log(`成功更新 ${idMappings.length} 个商品的平台ID`);

							// 显示处理结果
							uni.showToast({
								title: '孔商品处理完成',
								icon: 'success'
							});

							// 保存处理记录
							this.pddProcessedItems = idMappings;

						} else {
							this.pddStatus = '处理失败';
							this.pddCurrentItemText = '批量更新失败';
							this.log(`孔商品处理失败: ${result.message}`);

							uni.showToast({
								title: `处理失败: ${result.message}`,
								icon: 'none'
							});
						}
					})
					.catch(err => {
						this.pddStatus = '处理失败';
						this.pddCurrentItemText = '批量更新出错';
						this.log(`孔商品处理出错: ${err.message}`);

						uni.showToast({
							title: `处理出错: ${err.message}`,
							icon: 'none'
						});
					})
					.finally(() => {
						this.pddProcessing = false;
					});
			},



			// 格式化时间
			formatTime(timeStr) {
				try {
					const date = new Date(timeStr);
					return date.toLocaleString('zh-CN', {
						year: 'numeric',
						month: '2-digit',
						day: '2-digit',
						hour: '2-digit',
						minute: '2-digit',
						second: '2-digit'
					});
				} catch (e) {
					return timeStr;
				}
			}
		}
	};
</script>

<style lang="scss">
	@import "./index.scss";
</style>