<template>
	<view class="feeding-record-add-page">
		<!-- 可滚动内容区域 -->
		<!-- 广告横幅 -->
		<swiper class="banner-swiper" v-if="swiperData.length > 0" :indicator-dots="swiperData.length > 1"
			:autoplay="swiperData.length > 1" :circular="swiperData.length > 1" indicator-color="#dfddd9"
			indicator-active-color="#b27c1e" :indicator-top="596">
			<swiper-item v-for="(item, index) in swiperData" :key="index">
				<image class="banner-img" :src="`${item?.bannerImg}`" mode="aspectFill" @click="bannerHandler(item)" />
			</swiper-item>
		</swiper>

		<!-- 喂养时间 -->
		<view class="feeding-time">
			<view class="baby-info" @click="showBabySwitch" v-if="babyList.length > 1">
				<image class="avatar-img" :src="currentBaby?.babyAvatar || feedingIndexRes.avatar">
				</image>
				<view class="baby-name-section">
					<text class="baby-name">{{ currentBaby?.babyName || '加载中...' }}</text>
					<image class="dropdown-icon" :src="feedingIndexRes.icon_arrow_yellow_drop" />
				</view>
			</view>
			<view class="baby-info" v-else-if="babyList.length === 1">
				<image class="avatar-img" :src="currentBaby?.babyAvatar || feedingIndexRes.avatar">
				</image>
				<view class="baby-name-section">
					<text class="baby-name">{{ currentBaby?.babyName || '加载中...' }}</text>
				</view>
			</view>
			<view class="baby-info" v-else>
				<image class="avatar-img" :src="feedingIndexRes.avatar"></image>
				<view class="baby-name-section">
					<text class="baby-name">加载中...</text>
					<image class="dropdown-icon" :src="feedingIndexRes.icon_arrow_yellow_drop" />
				</view>
			</view>
			<view class="time-section" @click="showTimePicker">
				<text class="time-label">喂养时间</text>
				<uni-datetime-picker ref="timePickerRef" v-model="currentTime" type="datetime" :clear-icon="false"
					:border="false" @change="onTimeChange" :start="earliestDateString" :end="latestDateString"
					style="z-index: 999999;">
					<view class="time-display">
						<text class="time-value">{{ formatCurrentTime() }}</text>
						<image class="edit-icon" :src="feedingIndexRes.icon_modify" />
					</view>
				</uni-datetime-picker>
			</view>


		</view>

		<!-- 喂养记录 -->
		<view class="feeding-records" @click="goToFeedingRecord">
			<text class="records-link">喂养记录</text>
			<image class="arrow-right" :src="feedingIndexRes.icon_arrow_yellow"></image>
		</view>

		<!-- 喂养类型选择 -->
		<view class="feeding-types">
			<view class="type-item" v-for="(type, index) in feedingTypes" :key="index"
				:class="{ active: selectedType === type.value }" @click="selectType(type.value)">
				<image class="icon-bg" :src="feedingIndexRes.icon_bg" mode="aspectFit"
					v-if="selectedType === type.value" />
				<view class="type-icon-wrapper">

					<image class="type-icon" :src="type.icon" mode="aspectFit" />
				</view>
				<text class="type-label">{{ type.label }}</text>
			</view>
		</view>

		<!-- 下半部分背景 -->
		<view class="bottom-section">
			<image class="bottom-bg" :src="feedingIndexRes.bottom_bg" mode="aspectFill" />

			<view class="bottom-bg-content"></view>

			<!-- 温馨提示 -->
			<view class="warm-tip" v-if="selectedType === 'breastfeeding' && recordMethods[selectedType] === 'manual'">
				<text>温馨提示:每十分钟建议更换一侧,更推荐瓶装方式喂养~</text>
			</view>

			<!-- 动态表单区域 -->
			<view v-if="shouldShowForm" class="form-section">
				<!-- 母乳亲喂表单 -->
				<view v-if="selectedType === 'breastfeeding'" class="breastfeeding-form">
					<view class="duration-controls">
						<view class="duration-item">
							<view class="duration-circle">
								<image class="circle-bg" :src="feedingIndexRes.iconBg" mode="aspectFit" />
								<view class="circle-content">
									<text class="duration-number">{{ feedingData.breastfeeding.leftDuration
									}}</text>
									<text class="duration-unit">分钟</text>
								</view>
							</view>
							<view class="duration-buttons">
								<image class="btn-minus"
									:src="feedingData.breastfeeding.leftDuration <= 0 ? feedingIndexRes.icon_G : feedingIndexRes.icon_L"
									mode="aspectFit" @click="adjustDuration('left', -1)"
									:class="{ disabled: feedingData.breastfeeding.leftDuration <= 0 }" />
								<image class="btn-plus"
									:src="feedingData.breastfeeding.leftDuration >= 60 ? feedingIndexRes.icon_G_plus : feedingIndexRes.icon_L_plus"
									mode="aspectFit" @click="adjustDuration('left', 1)"
									:class="{ disabled: feedingData.breastfeeding.leftDuration >= 60 }" />
							</view>
							<text class="duration-label">左侧哺乳时长</text>
						</view>
						<view class="duration-item">
							<view class="duration-circle">
								<image class="circle-bg" :src="feedingIndexRes.iconBg" mode="aspectFit" />
								<view class="circle-content">
									<text class="duration-number">{{ feedingData.breastfeeding.rightDuration
									}}</text>
									<text class="duration-unit">分钟</text>
								</view>
							</view>
							<view class="duration-buttons">
								<image class="btn-minus"
									:src="feedingData.breastfeeding.rightDuration <= 0 ? feedingIndexRes.icon_G : feedingIndexRes.icon_L"
									mode="aspectFit" @click="adjustDuration('right', -1)"
									:class="{ disabled: feedingData.breastfeeding.rightDuration <= 0 }" />
								<image class="btn-plus"
									:src="feedingData.breastfeeding.rightDuration >= 60 ? feedingIndexRes.icon_G_plus : feedingIndexRes.icon_L_plus"
									mode="aspectFit" @click="adjustDuration('right', 1)"
									:class="{ disabled: feedingData.breastfeeding.rightDuration >= 60 }" />
							</view>
							<text class="duration-label">右侧哺乳时长</text>
						</view>
					</view>
				</view>

				<!-- 母乳瓶喂/奶粉喂养表单 -->
				<view v-if="(selectedType === 'bottle' || selectedType === 'formula')" class="bottle-form">
					<view class="bottle-graphic">
						<!-- 左侧喂奶量显示 -->
						<view class="amount-bubble">
							<image class="bubble-bg" :src="feedingIndexRes.icon_left_arrow_tip" mode="aspectFit" />
							<text class="bubble-label">喂奶量</text>
							<text class="bubble-value">{{ feedingData[selectedType].amount }}ml</text>
						</view>

						<!-- 中间瓶子图形 -->
						<view class="bottle-container">
							<image class="bottle-image" :src="feedingIndexRes.icon_milk_bottle" mode="aspectFit" />

							<!-- 奶量选择器 -->
							<picker-view class="amount-picker" :value="pickerValue" @change="onPickerChange"
								:mask-style="{ opacity: 0 }" :indicator-style="indicatorStyle"
								indicator-class="amount-picker" mask-style="opacity:0; border: none;">
								<picker-view-column>
									<view class="picker-item" v-for="(amount, index) in pickerAmounts" :key="amount"
										:class="{ active: pickerValue[0] === index }">
										{{ amount }}ml
									</view>
								</picker-view-column>
							</picker-view>
						</view>
					</view>
				</view>

				<!-- 辅食表单 -->
				<view v-if="selectedType === 'food'" class="food-form">
					<!-- 已选择的辅食展示区域 -->
					<view class="selected-items">
						<text>{{ feedingData.food.selectedItems.join(',') || '请选择辅食' }}</text>
					</view>

					<!-- 分隔线 -->
					<view class="divider"></view>

					<!-- 辅食分类标题和操作按钮 -->
					<view class="food-categories">
						<text class="category-title">辅食分类</text>
						<view class="category-actions">
							<text v-if="foodSelectionState.isEditMode" class="complete-btn"
								:class="{ disabled: foodSelectionState.isDeletingFood }"
								@click="foodSelectionState.isDeletingFood ? null : exitEditMode()">
								完成
							</text>
							<view v-else class="delete-btn" @click="enterEditMode">
								<image class="delete-icon" :src="feedingIndexRes.icon_shanchu" mode="aspectFit" />
								<text>删除</text>
							</view>
						</view>
					</view>

					<!-- 辅食分类列表 -->
					<view class="category-list">
						<view v-for="(category, categoryName) in foodCategories" :key="categoryName"
							class="category-item">
							<text class="category-name">{{ categoryName }}</text>
							<view class="add-section">
								<image class="add-btn"
									:class="{ disabled: foodSelectionState.isEditMode || foodSelectionState.isAddingFood }"
									:src="feedingIndexRes.icon_fushi_add" mode="aspectFit"
									@click="foodSelectionState.isAddingFood ? null : showAddFoodPopup(categoryName)" />
							</view>
							<view class="selected-tags">
								<!-- 默认辅食项 -->
								<view v-for="(item, index) in category.items" :key="item" class="tag-item" :class="{
									active: feedingData.food.selectedItems.includes(item),
									editing: foodSelectionState.isEditMode,
									hidden: !category.expanded && index >= 3
								}" @click="toggleFoodSelection(item)">
									<text class="tag">{{ item }}</text>
									<image v-if="foodSelectionState.isEditMode" class="delete-x"
										:src="feedingIndexRes.icon_shanchu_x" mode="aspectFit"
										@click.stop="removeFoodItem(categoryName, item)" />
								</view>
								<!-- 自定义辅食项 -->
								<view v-for="(item, index) in category.customItems" :key="`custom-${item}`"
									class="tag-item" :class="{
										active: feedingData.food.selectedItems.includes(item),
										editing: foodSelectionState.isEditMode,
										hidden: !category.expanded && index >= 3
									}" @click="toggleFoodSelection(item)">
									<text class="tag">{{ item }}</text>
									<image v-if="foodSelectionState.isEditMode" class="delete-x"
										:src="feedingIndexRes.icon_shanchu_x" mode="aspectFit"
										@click.stop="removeFoodItem(categoryName, item)" />
								</view>
							</view>
							<!-- 展开/缩起按钮 -->
							<view v-if="(category.items.length + category.customItems.length) > 3" class="expand-btn"
								@click="toggleCategoryExpansion(categoryName)">
								<image class="expand-icon"
									:src="category.expanded ? feedingIndexRes.icon_fushi_up : feedingIndexRes.icon_fushi_drop"
									mode="aspectFit" />
							</view>
						</view>
					</view>
				</view>
			</view>
			<!-- 录音控制区域 -->
			<view v-if="recordMethods[selectedType] === 'voice'" class="voice-controls">
				<!-- 提示文字 -->
				<view class="voice-tip">
					<text class="tip-text">你可以尝试这样说:</text>
				</view>

				<!-- 示例语音 -->
				<view class="voice-example">
					<text class="example-text" v-if="selectedType === 'breastfeeding'">"左边5分钟,右边6分钟"</text>
					<text class="example-text" v-else>"喂奶量90毫升"</text>
				</view>

				<!-- 麦克风图标 -->
				<view class="voice-microphone" @touchstart="startRecording" @touchend="stopRecording"
					@touchcancel="stopRecording">
					<image class="microphone-icon"
						:src="voiceRecognitionState.isRecording ? feedingIndexRes.icon_luyining_gif : feedingIndexRes.icon_luyin"
						mode="aspectFit" />
				</view>

				<!-- 录音提示 -->
				<view class="voice-click-tip">
					<text class="click-text" v-if="voiceRecognitionState.isRecording">
						正在录音... {{ formatRecordingDuration(voiceRecognitionState.recordingDuration) }}
					</text>
					<text class="click-text" v-else-if="voiceRecognitionState.isPolling">正在识别...</text>
					<text class="click-text" v-else>长按录音</text>
				</view>
			</view>

			<!-- 计时器控制区域 -->
			<view v-if="recordMethods[selectedType] === 'timer'" class="timer-controls">
				<!-- 总时长显示 -->
				<view class="total-duration">
					<text class="total-duration-label">总时长</text>
					<text class="total-duration-value">{{ formatTotalDuration() }}</text>
				</view>

				<!-- 圆形计时器 -->
				<view class="circular-timers">
					<!-- 左侧计时器 -->
					<view class="timer-circle left-timer">
						<image class="timer-icon"
							:src="isLeftTimerRunning ? feedingIndexRes.icon_stop : feedingIndexRes.icon_start"
							mode="aspectFit" @click="toggleTimer('left')" />
						<text class="timer-time">{{ formatTime(timerData.leftDuration) }}</text>
						<text class="timer-label">左侧</text>
					</view>

					<!-- 右侧计时器 -->
					<view class="timer-circle right-timer">
						<image class="timer-icon"
							:src="isRightTimerRunning ? feedingIndexRes.icon_stop : feedingIndexRes.icon_start"
							mode="aspectFit" @click="toggleTimer('right')" />
						<text class="timer-time">{{ formatTime(timerData.rightDuration) }}</text>
						<text class="timer-label">右侧</text>
					</view>
				</view>
			</view>

			<!-- 记录方式选择 - 母乳亲喂 -->
			<view class="record-methods1" v-if="selectedType === 'breastfeeding'">
				<image class="tab-image" :src="getTabImage()" mode="aspectFill" />
				<view class="click-area left" @click="setRecordMethod('manual')"></view>
				<view class="click-area center" @click="setRecordMethod('timer')"></view>
				<view class="click-area right" @click="setRecordMethod('voice')"></view>
			</view>

			<!-- 记录方式选择 - 母乳瓶喂/奶粉喂养 -->
			<view class="record-methods2" v-if="selectedType === 'bottle' || selectedType === 'formula'">
				<image class="tab-image" :src="getTabImage2()" mode="aspectFill" />
				<view class="click-area left" @click="setRecordMethod('manual')">
				</view>
				<view class="click-area right" @click="setRecordMethod('voice')">
				</view>
			</view>


		</view>
		<!-- 底部完成按钮 -->
		<view class="bottom_complete-btn" @click="completeRecord">
			<image class="complete-btn-bg" :src="feedingIndexRes.complete_btn" />
			<!-- <text class="complete-btn-text">{{ isSubmitting ? '保存中...' : '完成记录' }}</text> -->
		</view>
	</view>

	<!-- 添加辅食弹窗 -->
	<uni-popup ref="addFoodPopup" type="center" :mask-click="false" class="add-food-popup-container">
		<view class="add-food-popup">
			<view class="popup-header">
				<text class="popup-title">新增辅食名称</text>
			</view>
			<view class="popup-content2">
				<view class="input-container">
					<input class="food-input" v-model="foodSelectionState.newFoodItem" placeholder="请输入辅食名称"
						maxlength="10" />
					<text class="char-count">{{ foodSelectionState.newFoodItem.length }}/10</text>
				</view>
			</view>
			<view class="popup-buttons">
				<image class="cancel-btn" :src="feedingIndexRes.icon_fushi_btn_cancel" mode="aspectFit"
					@click="cancelAddFood"></image>
				<image class="confirm-btn"
					:class="{ disabled: foodSelectionState.isAddingFood || !foodSelectionState.newFoodItem.trim() }"
					:src="feedingIndexRes.icon_fushi_btn_add" mode="aspectFit"
					@click="(foodSelectionState.isAddingFood || !foodSelectionState.newFoodItem.trim()) ? null : confirmAddFood()">
				</image>
			</view>
		</view>
	</uni-popup>

	<!-- 语音识别结果弹窗 -->
	<view v-if="voiceRecognitionState.showResultPage" class="popup-mask" @touchmove.prevent>
		<view class="popup-content" @click.stop @touchmove.stop>
			<view class="popup-header">
				<view class="popup-title">确认识别结果</view>
				<view class="popup-close" @click="closeVoiceResult">
					<text class="close-text">×</text>
				</view>
			</view>

			<!-- 识别状态显示 -->
			<view v-if="voiceRecognitionState.recognitionStatus === 'processing'" class="recognition-status">
				<text class="status-text">识别处理中...</text>
			</view>

			<view class="form-container">
				<!-- 语音识别时间选择器，层级最高，未拉起不显示 -->
				<view class="form-item" style="z-index: 10003; position: relative;">
					<uni-datetime-picker class="voice-time-picker" ref="voiceTimePickerRef"
						v-model="voiceRecognitionState.voiceDateTime" type="datetime" :clear-icon="false"
						:border="false" :start="earliestDateString" :end="latestDateString" @change="onVoiceTimeChange"
						style="z-index: 999999;">
						<text class="label">喂养时间</text>
						<view class="input-container">
							<input class="input" :value="formatVoiceDateTime()" placeholder="请选择时间" readonly
								@click="showVoiceTimePicker" />
						</view>
					</uni-datetime-picker>
				</view>
				<view class="form-item">
					<text class="label">喂养方式</text>
					<view class="picker disabled">{{ getFeedingTypeLabel() }}</view>
				</view>
				<view class="form-item">
					<text class="label">喂养详情</text>
					<view class="input-container">
						<input class="input" v-model="voiceRecognitionState.recognizedText" placeholder="请输入喂养详情"
							maxlength="20" />
					</view>
				</view>
			</view>

			<view class="popup-buttons">
				<image :src="feedingIndexRes.icon_btn_cancel" class="cancel-btn" @click="reRecognize" />
				<image :src="feedingIndexRes.icon_btn_confirm" class="confirm-btn" @click="completeVoiceRecord" />
			</view>
		</view>
	</view>





	<!-- 切换宝宝弹窗 -->
	<BabySwitchPopup v-model:visible="showBabySwitchPopup" :selected-index="currentBabyIndex" @change="onBabyChange"
		v-if="babyList.length > 1" />

	<!-- 记录成功弹窗 -->
	<uni-popup ref="successPopup" type="center" :mask-click="false">
		<view class="success-popup">
			<image class="success-bg" :src="feedingIndexRes.add_suc_bg" mode="aspectFit" />
			<view class="success-content">
				<view class="success-buttons">

					<image class="success-btn success-btn-close" :src="feedingIndexRes.add_suc_btn_close"
						mode="aspectFit" @click="onSuccessClose" />
					<image class="success-btn success-btn-jump" :src="feedingIndexRes.add_suc_btn_jump" mode="aspectFit"
						@click="onSuccessJump" />
				</view>
			</view>
		</view>
	</uni-popup>

	<popupTip v-if="isTip" type="1" @statusChange="onPopupTipBabyChange" @close="isTip = false"></popupTip>
</template>

<script setup>
import { ref, computed, onMounted, onUnmounted, getCurrentInstance } from 'vue'
import { onShow, onLoad, onHide } from '@dcloudio/uni-app'
import BabySwitchPopup from '@/components/BabySwitchPopup.vue'
import popupTip from '../../components/popup-tip/popup-tip.vue'
import { fetchFeedingJSON, feedingHome, feedingRecords, feedingFoodsCustom, feedingFoodsCustomAdd, feedingFoodsCustomDelete, feedingTimerStart, feedingTimerStop, feedingVoiceUpload, feedingVoiceResult } from '@/api/feeding.js'
import { useUserStore } from '@/stores/user.js'
import { jump, JumpType, showLoading } from '../../utils'
import { getHealthField } from "@/api/common";
import md from '../../md'

// 弹窗引用
const addFoodPopup = ref(null)
const successPopup = ref(null)

const { proxy } = getCurrentInstance();
const $baseUrl = proxy.$baseUrl;

const version = 'v1'

// 计时器上限时间（秒）
const TIMER_MAX_DURATION = 3600

const feedingIndexRes = {
	// 轮播图
	banner: $baseUrl + `feedingIndex/${version}/banner.png`,

	// 头像和宝宝相关
	avatar: $baseUrl + `feedingIndex/${version}/avatar.png`,
	icon_arrow_yellow_drop: $baseUrl + `feedingIndex/${version}/icon_arrow_yellow_drop.png`,
	icon_arrow_yellow: $baseUrl + `feedingIndex/${version}/icon_arrow_yellow.png`,
	icon_modify: $baseUrl + `feedingIndex/${version}/icon_modify.png`,

	// 背景图片
	icon_bg: $baseUrl + `feedingIndex/${version}/icon_bg.png`,
	bottom_bg: $baseUrl + `feedingIndex/${version}/bottom_bg.png`,
	iconBg: $baseUrl + `feedingIndex/${version}/iconBg.png`,

	// 母乳亲喂相关
	icon_L: $baseUrl + `feedingIndex/${version}/icon-L.png`,
	icon_G: $baseUrl + `feedingIndex/${version}/icon-G.png`,
	icon_L_plus: $baseUrl + `feedingIndex/${version}/icon%2BL.png`,
	icon_G_plus: $baseUrl + `feedingIndex/${version}/icon%2BG.png`,

	// 喂养类型图标
	icon_muruqinwei: $baseUrl + `feedingIndex/${version}/icon_muruqinwei.png`,
	icon_murupinwei: $baseUrl + `feedingIndex/${version}/icon_murupinwei.png`,
	icon_naifen: $baseUrl + `feedingIndex/${version}/icon_naifen.png`,
	icon_fushi: $baseUrl + `feedingIndex/${version}/icon_fushi.png`,

	// 奶瓶和喂奶量相关
	icon_milk_bottle: $baseUrl + `feedingIndex/${version}/icon_milk_bottle.png`,
	icon_left_arrow_tip: $baseUrl + `feedingIndex/${version}/icon_left_arrow_tip.png`,

	// 语音相关
	icon_luyin: $baseUrl + `feedingIndex/${version}/icon_luyin.png`,
	icon_luyining: $baseUrl + `feedingIndex/${version}/icon_luyining.png`,
	icon_luyining_gif: $baseUrl + `feedingIndex/${version}/icon_luyining.gif`,

	// 计时器相关
	icon_start: $baseUrl + `feedingIndex/${version}/icon_start.png`,
	icon_stop: $baseUrl + `feedingIndex/${version}/icon_stop.png`,

	// 完成按钮
	complete_btn: $baseUrl + `feedingIndex/${version}/complete_btn.png`,

	// 记录方式选择
	Tab_bottom_write: $baseUrl + `feedingIndex/${version}/Tab_bottom_write.png`,
	Tab_bottom_timer: $baseUrl + `feedingIndex/${version}/Tab_bottom_timer.png`,
	Tab_bottom_voice: $baseUrl + `feedingIndex/${version}/Tab_bottom_voice.png`,
	Tab_bottom_muruandnaifen_write: $baseUrl + `feedingIndex/${version}/Tab_bottom_muruandnaifen_write.png`,
	Tab_bottom_muruandnaifen_voice: $baseUrl + `feedingIndex/${version}/Tab_bottom_muruandnaifen_voice.png`,

	// 辅食相关
	icon_fushi_add: $baseUrl + `feedingIndex/${version}/icon_fushi_add.png`,
	icon_fushi_up: $baseUrl + `feedingIndex/${version}/icon_fushi_up.png`,
	icon_fushi_drop: $baseUrl + `feedingIndex/${version}/icon_fushi_drop.png`,
	icon_shanchu_x: $baseUrl + `feedingIndex/${version}/icon_shanchu_x.png`,
	icon_shanchu: $baseUrl + `feedingIndex/${version}/icon_shanchu.png`,
	icon_fushi_btn_cancel: $baseUrl + `feedingIndex/${version}/icon_fushi_btn_cancel.png`,
	icon_fushi_btn_add: $baseUrl + `feedingIndex/${version}/icon_fushi_btn_add.png`,


	//添加记录成功弹窗
	add_suc_bg: $baseUrl + `feedingIndex/${version}/add_suc_bg.png`,
	add_suc_btn_jump: $baseUrl + `feedingIndex/${version}/add_suc_btn_jump.png`,
	add_suc_btn_close: $baseUrl + `feedingIndex/${version}/add_suc_btn_close.png`,


	// 识别成功弹窗
	icon_btn_confirm: $baseUrl + `feedingIndex/${version}/icon_btn_confirm.png`,
	icon_btn_cancel: $baseUrl + `feedingIndex/${version}/icon_btn_cancel.png`,
}

const swiperData = ref([

]);
const indicatorStyle = `height: 40px; border: none;`

// 当前时间，使用 home 接口的 timestamp
const currentTime = ref(null)

// 日期范围限制
const earliestDateString = ref('2020-01-01')
const latestDateString = ref('2030-12-31')

// 时间选择器引用
const timePickerRef = ref(null)
const voiceTimePickerRef = ref(null)

// 接口返回的数据
const homeData = ref({
	timestamp: null,
	lastRecordType: 0,
	lastBreastMilkVolume: 0,
	lastFormulaVolume: 0,
	leftTimerRunning: false,
	leftTimerDuration: 0,
	rightTimerRunning: false,
	rightTimerDuration: 0
})

// 记录相关数据
const currentRecordId = ref(null) // 当前记录ID，用于区分新增和修改
const isSubmitting = ref(false) // 提交状态
const bannerHandler = (item) => {
	// 检查是否正在录音
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		uni.showToast({
			title: '录音进行中，不可切换页面',
			icon: 'none'
		})
		return
	}

	md.sensorLogTake({
		xcxClick: "小程序页面点击事件",
		pageName: "喂养工具首页",
		buttonName: "banner资源位",
	});

	console.log(item);
	jump({ type: item.jumpType, url: item.url, extra: item.extra })
}

const showTimePicker = () => {
	md.sensorLogTake({
		xcxClick: "小程序页面点击事件",
		pageName: "喂养工具首页",
		buttonName: "选择喂养时间",
	});
}


const feedingTypes = ref([
	{ value: 'breastfeeding', label: '母乳亲喂', icon: feedingIndexRes.icon_muruqinwei },
	{ value: 'bottle', label: '母乳瓶喂', icon: feedingIndexRes.icon_murupinwei },
	{ value: 'formula', label: '奶粉喂养', icon: feedingIndexRes.icon_naifen },
	{ value: 'food', label: '辅食', icon: feedingIndexRes.icon_fushi }
])

// 根据接口数据初始化选中的喂养类型
const selectedType = ref('breastfeeding')

// 为每种喂养方式设置独立的记录方法
const recordMethods = ref({
	breastfeeding: 'manual',
	bottle: 'manual',
	formula: 'manual',
	food: 'manual'
})
const isRecording = ref(false)
const isLeftTimerRunning = ref(false)
const isRightTimerRunning = ref(false)

// 辅食数据结构 - 使用接口数据
const foodCategories = ref({
	主食: {
		items: [],
		customItems: [],
		expanded: false
	},
	蔬菜: {
		items: [],
		customItems: [],
		expanded: false
	},
	水果: {
		items: [],
		customItems: [],
		expanded: false
	},
	其他: {
		items: [],
		customItems: [],
		expanded: false
	}
})

// 辅食ID映射，用于删除操作
const foodIdMap = ref(new Map())

// 辅食类型映射
const foodTypeMap = {
	1: '主食',
	2: '蔬菜',
	3: '水果',
	4: '其他'
}

// 辅食选择状态
const foodSelectionState = ref({
	isEditMode: false, // 是否处于编辑模式
	showAddPopup: false, // 是否显示添加弹窗
	currentCategory: '', // 当前添加的分类
	newFoodItem: '', // 新添加的辅食项
	pendingDeletes: [], // 待删除的辅食列表
	originalFoodData: null, // 保存原始辅食数据，用于恢复
	isAddingFood: false, // 添加辅食防连点状态
	isDeletingFood: false // 删除辅食防连点状态
})

// 记录成功弹窗状态 - 已移除，改用 .open() 和 .close() 方法

// 语音识别状态
const voiceRecognitionState = ref({
	isRecording: false, // 是否正在录音
	showResultPage: false, // 是否显示识别结果页面
	recognizedText: '', // 识别结果文本
	recordingDuration: 0, // 录音时长
	recordingStartTime: null, // 录音开始时间
	recordingTimer: null, // 录音时长定时器
	taskId: '', // 语音识别任务ID
	isPolling: false, // 是否正在轮询识别结果
	pollingInterval: null, // 轮询定时器
	pollingErrorCount: 0, // 轮询错误计数
	recognitionStatus: 'idle', // 识别状态：idle-空闲, processing-处理中, success-成功, failed-失败
	recordDate: '', // 记录日期
	recordTime: '', // 记录时间
	voiceDateTime: '' // 完整的日期时间字符串
})

// 录音管理器
const recorderManager = uni.getRecorderManager()

// 全局状态管理
const userStore = useUserStore()
const babyId = computed(() => userStore.babyInfo?.content?.id)

// 宝宝切换相关状态
const showBabySwitchPopup = ref(false)

const isTip = ref(true)

// 为每种喂养方式设置独立的数据 - 根据接口数据初始化
const feedingData = ref({
	breastfeeding: {
		leftDuration: 5,
		rightDuration: 5
	},
	bottle: {
		amount: 0 // 首次默认定位到0ml
	},
	formula: {
		amount: 0 // 首次默认定位到0ml
	},
	food: {
		selectedItems: []
	}
})

// 刻度标记数组 (0-500ml，每5ml一个刻度)
const scaleMarks = ref([0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500])

// picker-view相关数据
const pickerAmounts = ref([0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230, 235, 240, 245, 250, 255, 260, 265, 270, 275, 280, 285, 290, 295, 300, 305, 310, 315, 320, 325, 330, 335, 340, 345, 350, 355, 360, 365, 370, 375, 380, 385, 390, 395, 400, 405, 410, 415, 420, 425, 430, 435, 440, 445, 450, 455, 460, 465, 470, 475, 480, 485, 490, 495, 500])

// 滑动相关状态
const isDragging = ref(false)
const startY = ref(0)
const startAmount = ref(0)

// 计时器数据 - 根据接口数据初始化
const timerData = ref({
	leftDuration: 0,
	rightDuration: 0
})

// 计时器间隔ID
let leftTimerInterval = null
let rightTimerInterval = null

// 计算属性 - 判断是否显示表单
const shouldShowForm = computed(() => {
	const currentMethod = recordMethods.value[selectedType.value]
	return currentMethod === 'manual' // 只有手动模式显示表单
})

// 计算属性 - 同步picker-view的值
const pickerValue = computed({
	get() {
		const currentAmount = feedingData.value[selectedType.value].amount
		const index = pickerAmounts.value.indexOf(currentAmount)
		return [index >= 0 ? index : 0]
	},
	set(value) {
		// 这个setter不会被直接调用，但需要保持响应式
	}
})

// 计算属性 - 判断是否为语音模式（辅食除外）
const isVoiceMode = computed(() => {
	return recordMethods.value[selectedType.value] === 'voice' && selectedType.value !== 'food'
})

// 计算属性 - 获取宝宝信息（只显示已出生的宝宝）
const babyList = computed(() => {
	const allBabies = userStore.babyInfo?.allBabyBaseInfo || []
	// 只返回已出生的宝宝（babyStage === 2）
	return allBabies.filter(baby => baby.babyStage === 2)
})
const currentBabyIndex = computed(() => {
	if (!babyList.value || !currentBaby.value) return 0
	return babyList.value.findIndex(baby => baby.id === currentBaby.value.id)
})
const currentBaby = computed(() => userStore.babyInfo?.content)
const currentBabyId = computed(() => userStore.babyInfo?.content?.id)

// 页面加载时获取数据
onMounted(async () => {
	md.sensorLogTake({
		xcxPage: "小程序页面浏览事件",
		pageName: "喂养工具首页",
	});
	console.warn('页面加载，开始初始化数据...')
	await loadBabyInfo()
	loadFoodsData()

	// 初始化录音管理器
	initializeRecorderManager()
})

const onPopupTipBabyChange = async () => {
	isTip.value = false
	console.log('onPopupTipBabyChange', isTip.value)
	// showBabySwitchPopup.value = true
	await loadBabyInfo()
	loadHomeData()
}

// 页面显示时刷新数据
onShow(async () => {
	console.log('页面显示，刷新数据...')

	if (!babyId.value) {
		isTip.value = true
		await loadBabyInfo()
	} else {
		isTip.value = false
	}

	// 刷新宝宝信息和首页数据
	loadHomeData()

	// 重置计时器状态，确保状态正确
	resetTimerStatus()

	// 检查录音状态，如果录音管理器正在录音但状态不一致，强制重置
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		console.log('检测到录音状态不一致，强制重置录音状态')
		forceResetRecorderManager()
	} else {
		// 重置录音状态，确保状态正确
		resetRecordingState()
	}

	// 检查录音状态
	checkRecorderStatus()

	// 如果处于编辑模式且有待删除的辅食，恢复编辑状态
	if (hasUnfinishedEdit()) {
		console.log('检测到未完成的辅食删除操作，恢复编辑状态')
		// 延迟执行，确保页面完全加载后再显示弹窗
		setTimeout(() => {
			restoreUnfinishedEdit()
		}, 500)
	}
})

// 页面隐藏时同步计时器状态
onHide(() => {
	console.log('页面隐藏，处理录音状态...')

	// 如果正在录音，停止录音并重置状态
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		console.log('页面隐藏时检测到正在录音，停止录音')
		forceResetRecorderManager()
	}

	// 如果页面隐藏时有计时器在运行，需要同步到后端
	if (isLeftTimerRunning.value && leftTimerInterval) {
		console.log('页面隐藏时同步左侧计时器状态')
		// 这里可以选择是否调用后端接口同步状态
		// 由于页面隐藏时通常不需要立即同步，可以等到页面显示时再同步
	}
	if (isRightTimerRunning.value && rightTimerInterval) {
		console.log('页面隐藏时同步右侧计时器状态')
		// 这里可以选择是否调用后端接口同步状态
	}
})

// 页面卸载时清理计时器
onUnmounted(() => {
	console.log('页面卸载，清理资源...')

	// 清理左侧计时器
	if (leftTimerInterval) {
		clearInterval(leftTimerInterval)
		leftTimerInterval = null
	}
	// 清理右侧计时器
	if (rightTimerInterval) {
		clearInterval(rightTimerInterval)
		rightTimerInterval = null
	}
	// 清理语音识别轮询
	clearPollingInterval()
	// 清理录音定时器
	if (recordingState.value.recordingTimer) {
		clearInterval(recordingState.value.recordingTimer)
		recordingState.value.recordingTimer = null
	}
	// 清理录音管理器事件监听器（兼容性处理）
	try {
		if (recorderManager && typeof recorderManager.offStart === 'function') {
			recorderManager.offStart()
		}
		if (recorderManager && typeof recorderManager.offStop === 'function') {
			recorderManager.offStop()
		}
		if (recorderManager && typeof recorderManager.offError === 'function') {
			recorderManager.offError()
		}
	} catch (error) {
		console.warn('页面卸载时清理录音管理器回调出错:', error)
	}
})

// 页面参数接收
onLoad(async (options) => {
	console.log('页面参数:', options)

	// 如果是修改记录，接收记录ID
	if (options.recordId) {
		currentRecordId.value = options.recordId
		console.log('修改记录ID:', currentRecordId.value)
	}

	// 如果有其他参数，可以在这里处理
	if (options.babyId) {
		// 设置选中的宝宝
		await userStore.changeBabySelected(options.babyId)
	}

	if (options.feedingType) {
		// 设置喂养类型
		const typeMap = {
			'1': 'breastfeeding',
			'2': 'bottle',
			'3': 'formula',
			'4': 'food'
		}
		selectedType.value = typeMap[options.feedingType] || 'breastfeeding'
	}
})

function getCurrentTime() {
	const now = new Date()
	const hours = String(now.getHours()).padStart(2, '0')
	const minutes = String(now.getMinutes()).padStart(2, '0')
	return `${hours}:${minutes}`
}


// 根据记录数据设置表单
function setFormDataFromRecord(recordData) {
	// 设置喂养类型
	const typeMap = {
		1: 'breastfeeding',
		2: 'bottle',
		3: 'formula',
		4: 'food'
	}
	selectedType.value = typeMap[recordData.feedingType] || 'breastfeeding'

	// 设置喂养数据
	if (recordData.feedingType === 1) {
		// 母乳亲喂
		feedingData.value.breastfeeding.leftDuration = Math.floor(recordData.durationLeftSeconds / 60)
		feedingData.value.breastfeeding.rightDuration = Math.floor(recordData.durationRightSeconds / 60)
	} else if (recordData.feedingType === 2 || recordData.feedingType === 3) {
		// 母乳瓶喂或奶粉喂养
		const type = recordData.feedingType === 2 ? 'bottle' : 'formula'
		feedingData.value[type].amount = recordData.volume
	} else if (recordData.feedingType === 4) {
		// 辅食
		if (recordData.foodDetails) {
			feedingData.value.food.selectedItems = recordData.foodDetails.split(',').filter(item => item.trim())
		}
	}

	// 设置喂养详情
	if (recordData.foodDetails) {
		voiceRecognitionState.value.recognizedText = recordData.foodDetails
	}

	// 不清除记录方法，保持用户的选择
}

// 获取宝宝信息
async function loadBabyInfo() {
	try {
		console.log('开始加载宝宝信息...')
		if (userStore.babyInfo?.babyStage != 2) {
			isTip.value = true
			console.log('isTip', isTip.value)
		} else {
			isTip.value = false
			console.log('宝宝信息加载完成')
		}
		// 使用全局状态管理加载宝宝信息
		// 加载宝宝信息 - 由 userStore 管理
		await userStore.loadBabyInfo()
		console.log('宝宝信息加载完成:', userStore.babyInfo, userStore.babyInfo?.babyStage)

		if (userStore.babyInfo?.babyStage != 2) {
			isTip.value = true
			console.log('isTip', isTip.value)
		} else {
			isTip.value = false
			console.log('宝宝信息加载完成')

			// 加载宝宝信息后，加载首页数据
			await loadHomeData()
		}

	} catch (error) {
		console.error('获取宝宝信息失败:', error)

		// 即使宝宝信息加载失败，也要加载首页数据
		await loadHomeData()

		uni.showToast({
			title: '获取宝宝信息失败，使用默认数据',
			icon: 'none'
		})
	}
}

// 获取首页数据
async function loadHomeData() {
	if (!babyId.value) {
		isTip.value = true
		return
	} else {
		isTip.value = false
	}
	try {
		const response = await feedingHome(babyId.value)
		console.log('首页数据:', response)

		if (response && response.data) {
			const data = response.data
			homeData.value = {
				timestamp: data.timestamp,
				lastRecordType: data.lastRecordType,
				lastBreastMilkVolume: data.lastBreastMilkVolume,
				lastFormulaVolume: data.lastFormulaVolume,
				leftTimerRunning: data.leftTimerRunning,
				leftTimerDuration: data.leftTimerDuration,
				rightTimerRunning: data.rightTimerRunning,
				rightTimerDuration: data.rightTimerDuration
			}
		}

		// 根据接口数据初始化页面状态
		initializePageData()
	} catch (error) {
		console.error('获取首页数据失败:', error)

		// 使用模拟数据作为fallback
		homeData.value = {
			timestamp: Date.now(),
			lastRecordType: 2,
			lastBreastMilkVolume: 120,
			lastFormulaVolume: 0,
			leftTimerRunning: false,
			leftTimerDuration: 0,
			rightTimerRunning: false,
			rightTimerDuration: 0
		}
		initializePageData()

		uni.showToast({
			title: '获取数据失败，使用默认数据',
			icon: 'none'
		})
	}


	// 获取轮播图数据
	try {
		const feedingResponse = await fetchFeedingJSON()
		console.log('轮播图数据:', feedingResponse)

		if (feedingResponse && feedingResponse.data && feedingResponse.data.swiperData && feedingResponse.data.swiperData.length > 0) {
			swiperData.value = feedingResponse.data.swiperData
		}
	} catch (error) {
		console.error('获取轮播图数据失败:', error)
		// 使用默认的轮播图数据作为fallback
		swiperData.value = []
	}
}

// 根据接口数据初始化页面状态
function initializePageData() {
	const data = homeData.value

	// 设置当前时间，优先使用 home 接口的 timestamp
	if (data.timestamp) {
		currentTime.value = data.timestamp
	} else {
		// 如果没有 timestamp，使用当前时间作为 fallback
		currentTime.value = getCurrentTime()
	}

	// 根据上次记录类型设置默认选中的喂养类型
	if (data.lastRecordType > 0) {
		const typeMap = {
			1: 'breastfeeding',
			2: 'bottle',
			3: 'formula',
			4: 'food'
		}
		selectedType.value = typeMap[data.lastRecordType] || 'breastfeeding'
	}

	// 设置上次的喂养量
	if (data.lastRecordType === 2 && data.lastBreastMilkVolume > 0) {
		feedingData.value.bottle.amount = data.lastBreastMilkVolume
	}
	if (data.lastRecordType === 3 && data.lastFormulaVolume > 0) {
		feedingData.value.formula.amount = data.lastFormulaVolume
	}

	// 设置计时器状态
	if (data.leftTimerRunning) {
		isLeftTimerRunning.value = true
		timerData.value.leftDuration = Math.floor(data.leftTimerDuration / 1000) // 转换为秒
		startLeftTimer()
	} else {
		// 如果接口显示没有左侧计时器在运行，但当前有计时器数据，则清空并停止定时器
		if (timerData.value.leftDuration > 0 || isLeftTimerRunning.value) {
			console.log('接口显示左侧计时器未运行，清空左侧计时器数据并停止定时器')
			timerData.value.leftDuration = 0
			isLeftTimerRunning.value = false
			stopLeftTimer()
		}
	}

	if (data.rightTimerRunning) {
		isRightTimerRunning.value = true
		timerData.value.rightDuration = Math.floor(data.rightTimerDuration / 1000) // 转换为秒
		startRightTimer()
	} else {
		// 如果接口显示没有右侧计时器在运行，但当前有计时器数据，则清空并停止定时器
		if (timerData.value.rightDuration > 0 || isRightTimerRunning.value) {
			console.log('接口显示右侧计时器未运行，清空右侧计时器数据并停止定时器')
			timerData.value.rightDuration = 0
			isRightTimerRunning.value = false
			stopRightTimer()
		}
	}

	// 如果有计时器在运行，切换到计时器模式
	if (data.leftTimerRunning || data.rightTimerRunning) {
		recordMethods.value.breastfeeding = 'timer'
	}

	// 重置计时器状态，确保状态和实际运行状态保持一致
	resetTimerStatus()
}

// 重置计时器状态
function resetTimerStatus() {
	// 如果状态显示计时器在运行，但实际没有定时器在运行，则重置状态
	if (isLeftTimerRunning.value && !leftTimerInterval) {
		console.log('重置左侧计时器状态：状态为运行但实际已停止')
		isLeftTimerRunning.value = false
	}
	if (isRightTimerRunning.value && !rightTimerInterval) {
		console.log('重置右侧计时器状态：状态为运行但实际已停止')
		isRightTimerRunning.value = false
	}
}

// 方法
function selectType(type) {
	// 检查是否正在录音
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		uni.showToast({
			title: '录音进行中，不可切换类型',
			icon: 'none'
		})
		return
	}

	// 检查是否有正在进行的计时器（只有在真正有计时器在运行时才阻止）
	if ((isLeftTimerRunning.value && leftTimerInterval) || (isRightTimerRunning.value && rightTimerInterval)) {
		uni.showToast({
			title: '记录进行中，不可切换',
			icon: 'none'
		})
		return
	}

	// 检查是否有计时器结束但未提交的记录
	if (selectedType.value === 'breastfeeding' && recordMethods.value.breastfeeding === 'timer' &&
		(timerData.value.leftDuration > 0 || timerData.value.rightDuration > 0)) {
		uni.showToast({
			title: '记录进行中，不可切换',
			icon: 'none'
		})
		return
	}

	// 检查是否有未保存的辅食删除操作，直接恢复数据
	if (foodSelectionState.value.isEditMode && foodSelectionState.value.pendingDeletes.length > 0) {
		// 取消编辑模式，恢复数据
		cancelEditMode()
	}

	// 如果切换的是不同的类型，清空之前的状态
	if (selectedType.value !== type) {
		clearPreviousState()
	}


	if (type === 'breastfeeding') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "母乳亲喂",
		});
	}
	if (type === 'bottle') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "母乳瓶喂",
		});
	}
	if (type === 'formula') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "奶粉喂养",
		});
	}
	if (type === 'food') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "辅食",
		});
	}
	selectedType.value = type
}



// 清空之前的状态
function clearPreviousState() {
	// 清理轮询定时器
	clearPollingInterval()

	// 清理录音定时器
	if (voiceRecognitionState.value.recordingTimer) {
		clearInterval(voiceRecognitionState.value.recordingTimer)
		voiceRecognitionState.value.recordingTimer = null
	}

	// 清空语音识别状态
	voiceRecognitionState.value = {
		isRecording: false,
		showResultPage: false,
		recognizedText: '',
		recordingDuration: 0,
		recordingStartTime: null,
		recordingTimer: null,
		taskId: '',
		isPolling: false,
		pollingInterval: null
	}

	// 清空辅食选择状态
	foodSelectionState.value = {
		isEditMode: false,
		showAddPopup: false,
		currentCategory: '',
		newFoodItem: '',
		pendingDeletes: [],
		originalFoodData: null
	}

	// 清空录音状态
	isRecording.value = false

	// 不清除记录方法，保持用户的选择
	// 不清除喂养数据，保持用户输入

	// 清空滑动状态
	isDragging.value = false
	startY.value = 0
	startAmount.value = 0
}

// 清空喂养数据（保存成功后调用）
function clearFeedingData() {
	// 清空所有喂养方式的数据
	feedingData.value.breastfeeding.leftDuration = 5
	feedingData.value.breastfeeding.rightDuration = 5
	feedingData.value.bottle.amount = 0
	feedingData.value.formula.amount = 0
	feedingData.value.food.selectedItems = []

	// 清空计时器数据
	timerData.value.leftDuration = 0
	timerData.value.rightDuration = 0

	// 停止所有计时器
	if (leftTimerInterval) {
		clearInterval(leftTimerInterval)
		leftTimerInterval = null
	}
	if (rightTimerInterval) {
		clearInterval(rightTimerInterval)
		rightTimerInterval = null
	}

	// 重置计时器状态
	isLeftTimerRunning.value = false
	isRightTimerRunning.value = false

	// 清空语音识别状态
	voiceRecognitionState.value = {
		isRecording: false,
		showResultPage: false,
		recognizedText: '',
		recordingDuration: 0,
		recordingStartTime: null,
		recordingTimer: null,
		taskId: '',
		isPolling: false,
		pollingInterval: null
	}

	// 清空辅食选择状态
	foodSelectionState.value = {
		isEditMode: false,
		showAddPopup: false,
		currentCategory: '',
		newFoodItem: '',
		pendingDeletes: [],
		originalFoodData: null
	}

	// 清空录音状态
	isRecording.value = false

	// 清空滑动状态
	isDragging.value = false
	startY.value = 0
	startAmount.value = 0

	// 不清除记录方法，保持用户的选择

	// 重置当前时间，使用 home 接口的最新 timestamp
	if (homeData.value.timestamp) {
		currentTime.value = homeData.value.timestamp
	} else {
		currentTime.value = getCurrentTime()
	}

	console.log('喂养数据已清空')
}

function adjustDuration(side, value) {
	const currentData = feedingData.value.breastfeeding
	if (side === 'left') {

		if (value > 0) {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "左侧哺乳时长+",
			});
		}
		if (value < 0) {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "左侧哺乳时长-",
			});
		}

		// 限制在0-60分钟范围内
		const newValue = currentData.leftDuration + value
		if (newValue >= 0 && newValue <= 60) {
			currentData.leftDuration = newValue
		}
	} else {

		if (value > 0) {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "右侧哺乳时长+",
			});
		}
		if (value < 0) {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "右侧哺乳时长-",
			});
		}

		// 限制在0-60分钟范围内
		const newValue = currentData.rightDuration + value
		if (newValue >= 0 && newValue <= 60) {
			currentData.rightDuration = newValue
		}
	}
}



function adjustAmount(value) {
	const currentType = selectedType.value
	if (currentType === 'bottle' || currentType === 'formula') {
		const currentData = feedingData.value[currentType]
		currentData.amount = Math.max(0, Math.min(500, currentData.amount + value))
	}
}

// 滑动选择相关方法
function onTouchStart(e) {
	isDragging.value = true
	startY.value = e.touches[0].clientY
	startAmount.value = feedingData.value[selectedType.value].amount
}

function onTouchMove(e) {
	if (!isDragging.value) return

	const currentY = e.touches[0].clientY
	const deltaY = startY.value - currentY // 向上滑动为增加

	// 计算滑动距离对应的数值变化 (每10px对应5ml)
	const deltaAmount = Math.round(deltaY / 10) * 5
	const newAmount = Math.max(0, Math.min(500, startAmount.value + deltaAmount))

	// 确保是5的倍数
	const adjustedAmount = Math.round(newAmount / 5) * 5

	feedingData.value[selectedType.value].amount = adjustedAmount
}

function onTouchEnd() {
	isDragging.value = false
}

function getSliderPosition() {
	const currentAmount = feedingData.value[selectedType.value].amount
	// 将0-500ml映射到0-100%的位置
	return 100 - (currentAmount / 500) * 100
}

// picker-view选择事件
function onPickerChange(e) {
	const index = e.detail.value[0]
	const selectedAmount = pickerAmounts.value[index]
	feedingData.value[selectedType.value].amount = selectedAmount
}

function setRecordMethod(method) {

	// 手动记录、计时器记录、语音记录

	if (method === 'manual') {
		if (selectedType.value === 'breastfeeding') {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "母乳亲喂手动记录",
			});
		}
		if (selectedType.value === 'bottle') {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "母乳瓶喂手动记录",
			});
		}
		if (selectedType.value === 'formula') {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "奶粉喂养手动记录",
			});
		}
	}

	if (method === 'voice') {

		if (selectedType.value === 'breastfeeding') {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "母乳亲喂语音记录",
			});
		}
		if (selectedType.value === 'bottle') {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "母乳瓶喂语音记录",
			});
		}
		if (selectedType.value === 'formula') {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "奶粉喂养语音记录",
			});
		}

	}

	if (method === 'timer') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "母乳亲喂计时器记录",
		});
	}

	// 辅食不支持语音模式
	if (selectedType.value === 'food' && method === 'voice') {
		uni.showToast({
			title: '辅食只支持手动选择模式',
			icon: 'none'
		})
		return
	}

	// 母乳亲喂计时器运行时阻止切换记录方式
	if (selectedType.value === 'breastfeeding' && ((isLeftTimerRunning.value && leftTimerInterval) || (isRightTimerRunning.value && rightTimerInterval))) {
		uni.showToast({
			title: '计时器正在运行，请先停止计时',
			icon: 'none'
		})
		return
	}

	// 检查是否有计时器结束但未提交的记录
	if (selectedType.value === 'breastfeeding' && recordMethods.value.breastfeeding === 'timer' &&
		(timerData.value.leftDuration > 0 || timerData.value.rightDuration > 0)) {
		uni.showToast({
			title: '记录进行中，不可切换',
			icon: 'none'
		})
		return
	}

	// 语音识别运行时阻止切换记录方式
	if (voiceRecognitionState.value.isRecording) {
		uni.showToast({
			title: '语音识别正在进行，请先停止录音',
			icon: 'none'
		})
		return
	}

	recordMethods.value[selectedType.value] = method

	// 如果切换到语音模式，检查录音权限
	if (method === 'voice') {
		checkVoicePermission()
	}
}



function toggleRecording() {
	isRecording.value = !isRecording.value
}

async function toggleTimer(side) {
	const currentBabyId = babyId.value

	if (side === 'left') {
		// 检查是否已达到上限
		if (timerData.value.leftDuration >= TIMER_MAX_DURATION) {
			uni.showToast({
				title: '计时已达上限',
				icon: 'none'
			})
			return
		}

		// 左侧计时逻辑
		if (!isLeftTimerRunning.value) {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "左侧计时器开始",
			});
			// 开始左侧计时
			try {
				const response = await feedingTimerStart({
					babyId: currentBabyId,
					side: 'left'
				})
				console.log('开始左侧计时成功:', response)
				isLeftTimerRunning.value = true
				startLeftTimer()
			} catch (error) {
				console.error('开始左侧计时失败:', error)
				uni.showToast({
					title: '开始计时失败',
					icon: 'none'
				})
			}
		} else {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "左侧计时器暂停",
			});
			// 停止左侧计时
			try {
				const response = await feedingTimerStop({
					babyId: currentBabyId,
					side: 'left'
				})
				console.log('停止左侧计时成功:', response)
				isLeftTimerRunning.value = false
				stopLeftTimer()
			} catch (error) {
				console.error('停止左侧计时失败:', error)
				uni.showToast({
					title: '停止计时失败',
					icon: 'none'
				})
			}
		}
	} else if (side === 'right') {
		// 检查是否已达到上限
		if (timerData.value.rightDuration >= TIMER_MAX_DURATION) {
			uni.showToast({
				title: '计时已达上限',
				icon: 'none'
			})
			return
		}

		// 右侧计时逻辑
		if (!isRightTimerRunning.value) {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "右侧计时器开始",
			});
			// 开始右侧计时
			try {
				const response = await feedingTimerStart({
					babyId: currentBabyId,
					side: 'right'
				})
				console.log('开始右侧计时成功:', response)
				isRightTimerRunning.value = true
				startRightTimer()
			} catch (error) {
				console.error('开始右侧计时失败:', error)
				uni.showToast({
					title: '开始计时失败',
					icon: 'none'
				})
			}
		} else {
			md.sensorLogTake({
				xcxClick: "小程序页面点击事件",
				pageName: "喂养工具首页",
				buttonName: "右侧计时器暂停",
			});
			// 停止右侧计时
			try {
				const response = await feedingTimerStop({
					babyId: currentBabyId,
					side: 'right'
				})
				console.log('停止右侧计时成功:', response)
				isRightTimerRunning.value = false
				stopRightTimer()
			} catch (error) {
				console.error('停止右侧计时失败:', error)
				uni.showToast({
					title: '停止计时失败',
					icon: 'none'
				})
			}
		}
	}
}

function startLeftTimer() {
	// 开始左侧计时
	console.log('开始左侧计时')
	// 如果已经有计时器在运行，先停止
	if (leftTimerInterval) {
		clearInterval(leftTimerInterval)
	}
	leftTimerInterval = setInterval(() => {
		timerData.value.leftDuration++

		// 检查是否达到上限，达到时自动暂停
		if (timerData.value.leftDuration >= TIMER_MAX_DURATION) {
			console.log('左侧计时器达到上限，自动暂停')
			stopLeftTimer()
			isLeftTimerRunning.value = false
			// 自动停止时也要调用后端接口
			autoStopLeftTimer()
		}
	}, 1000) // 每秒增加1秒
}

function stopLeftTimer() {
	// 停止左侧计时
	console.log('停止左侧计时')
	if (leftTimerInterval) {
		clearInterval(leftTimerInterval)
		leftTimerInterval = null
	}
}

function startRightTimer() {
	// 开始右侧计时
	console.log('开始右侧计时')
	// 如果已经有计时器在运行，先停止
	if (rightTimerInterval) {
		clearInterval(rightTimerInterval)
	}
	rightTimerInterval = setInterval(() => {
		timerData.value.rightDuration++

		// 检查是否达到上限，达到时自动暂停
		if (timerData.value.rightDuration >= TIMER_MAX_DURATION) {
			console.log('右侧计时器达到上限，自动暂停')
			stopRightTimer()
			isRightTimerRunning.value = false
			// 自动停止时也要调用后端接口
			autoStopRightTimer()
		}
	}, 1000) // 每秒增加1秒
}

function stopRightTimer() {
	// 停止右侧计时
	console.log('停止右侧计时')
	if (rightTimerInterval) {
		clearInterval(rightTimerInterval)
		rightTimerInterval = null
	}
}

// 自动停止左侧计时器（调用后端接口）
async function autoStopLeftTimer() {
	const currentBabyId = babyId.value
	if (!currentBabyId) {
		console.warn('没有选择宝宝，无法停止计时器')
		return
	}

	try {
		console.log('自动停止左侧计时器')
		const response = await feedingTimerStop({
			babyId: currentBabyId,
			side: 'left'
		})
		console.log('自动停止左侧计时器成功:', response)
	} catch (error) {
		console.error('自动停止左侧计时器失败:', error)
		// 不显示错误提示，因为这是自动停止
	}
}

// 自动停止右侧计时器（调用后端接口）
async function autoStopRightTimer() {
	const currentBabyId = babyId.value
	if (!currentBabyId) {
		console.warn('没有选择宝宝，无法停止计时器')
		return
	}

	try {
		console.log('自动停止右侧计时器')
		const response = await feedingTimerStop({
			babyId: currentBabyId,
			side: 'right'
		})
		console.log('自动停止右侧计时器成功:', response)
	} catch (error) {
		console.error('自动停止右侧计时器失败:', error)
		// 不显示错误提示，因为这是自动停止
	}
}

// 停止所有计时器
async function stopAllTimers() {
	const currentBabyId = babyId.value
	if (!currentBabyId) {
		console.warn('没有选择宝宝，无法停止计时器')
		return
	}

	try {
		// 停止左侧计时器
		if (isLeftTimerRunning.value) {
			console.log('保存记录前停止左侧计时器')
			const leftResponse = await feedingTimerStop({
				babyId: currentBabyId,
				side: 'left'
			})
			console.log('停止左侧计时器成功:', leftResponse)
			isLeftTimerRunning.value = false
			stopLeftTimer()
		}

		// 停止右侧计时器
		if (isRightTimerRunning.value) {
			console.log('保存记录前停止右侧计时器')
			const rightResponse = await feedingTimerStop({
				babyId: currentBabyId,
				side: 'right'
			})
			console.log('停止右侧计时器成功:', rightResponse)
			isRightTimerRunning.value = false
			stopRightTimer()
		}
	} catch (error) {
		console.error('停止计时器失败:', error)
		// 不显示错误提示，因为这是正常的保存流程
		// 即使计时器停止失败，也要继续保存记录
	}
}

// 完成记录
async function completeRecord() {


	// 防止重复提交
	if (isSubmitting.value) {
		return
	}

	// 检查当前是否为语音模式（辅食除外）
	const currentMethod = recordMethods.value[selectedType.value]
	if (currentMethod === 'voice' && selectedType.value !== 'food') {
		// 语音模式应该在语音识别结果中确认提交，这里不处理
		uni.showToast({
			title: '请在语音识别结果中确认提交',
			icon: 'none'
		})
		return
	}


	if (selectedType.value === 'breastfeeding') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "母乳亲喂完成记录",
		});
	}
	if (selectedType.value === 'bottle') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "母乳瓶喂完成记录",
		});
	}
	if (selectedType.value === 'formula') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "奶粉喂养完成记录",
		});
	}
	if (selectedType.value === 'food') {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "辅食完成记录",
		});
	}


	try {
		isSubmitting.value = true

		// 验证数据
		const validationResult = validateRecordData()
		if (!validationResult.valid) {
			uni.showToast({
				title: validationResult.message,
				icon: 'none'
			})
			return
		}

		// 显示加载提示
		// uni.showLoading({
		// 	title: '保存中...'
		// })

		// 构建记录数据
		const recordData = buildRecordData()
		console.log('提交记录数据:', recordData)

		// 如果是计时器模式，先停止计时器
		if (selectedType.value === 'breastfeeding' && recordMethods.value.breastfeeding === 'timer') {
			console.log('保存记录前先停止计时器')
			await stopAllTimers()
		}

		// 调用接口保存记录
		const response = await feedingRecords(recordData)
		console.log('保存记录成功:', response)

		// // 隐藏加载提示
		// uni.hideLoading()

		// 刷新 home 数据
		await loadHomeData()

		// 清空计时器数据
		timerData.value.leftDuration = 0
		timerData.value.rightDuration = 0

		// 显示成功弹窗
		successPopup.value.open()




	} catch (error) {
		console.error('保存记录失败:', error)
		// uni.hideLoading()
		uni.showToast({
			title: '保存失败',
			icon: 'none'
		})
	} finally {
		// 添加2秒防连点
		setTimeout(() => {
			isSubmitting.value = false
		}, 2000)
	}
}

// 验证记录数据
function validateRecordData() {
	const currentBaby = userStore.babyInfo?.content

	// 验证宝宝信息
	if (!currentBaby || !currentBaby.id) {
		return { valid: false, message: '请选择宝宝' }
	}

	// 验证喂养时间
	if (!currentTime.value) {
		return { valid: false, message: '请选择喂养时间' }
	}

	// 根据喂养类型和记录方式验证具体数据
	switch (selectedType.value) {
		case 'breastfeeding':
			const currentMethod = recordMethods.value.breastfeeding

			if (currentMethod === 'manual') {
				// 手动模式：验证左右侧时长
				const leftDuration = feedingData.value.breastfeeding.leftDuration
				const rightDuration = feedingData.value.breastfeeding.rightDuration
				if (leftDuration === 0 && rightDuration === 0) {
					return { valid: false, message: '还没有输入喂养信息哦～' }
				}
			} else if (currentMethod === 'timer') {
				// 计时器模式：验证计时器状态
				const leftDuration = timerData.value.leftDuration
				const rightDuration = timerData.value.rightDuration
				if (leftDuration === 0 && rightDuration === 0) {
					return { valid: false, message: '还没有输入喂养信息哦～' }
				}
			} else if (currentMethod === 'voice') {
				// 语音模式：验证语音识别结果
				if (!voiceRecognitionState.value.recognizedText.trim()) {
					return { valid: false, message: '还没有输入喂养信息哦～' }
				}
			}
			break

		case 'bottle':
		case 'formula':
			const currentMethod2 = recordMethods.value[selectedType.value]

			if (currentMethod2 === 'manual') {
				// 手动模式：验证喂养量
				const amount = feedingData.value[selectedType.value].amount
				if (amount === 0) {
					return { valid: false, message: '还没有输入喂养信息哦～' }
				}
			} else if (currentMethod2 === 'voice') {
				// 语音模式：验证语音识别结果
				if (!voiceRecognitionState.value.recognizedText.trim()) {
					return { valid: false, message: '还没有输入喂养信息哦～' }
				}
			}
			break

		case 'food':
			// 辅食只有手动选择模式
			const selectedItems = feedingData.value.food.selectedItems
			if (selectedItems.length === 0) {
				return { valid: false, message: '还没有输入喂养信息哦～' }
			}
			break
	}

	return { valid: true }
}

// 构建记录数据
function buildRecordData() {
	const currentBaby = userStore.babyInfo?.content

	// 判断是否为语音模式，如果是则使用弹窗中的日期和时间
	let recordTime
	if (voiceRecognitionState.value.showResultPage && voiceRecognitionState.value.voiceDateTime) {
		// 语音模式：使用弹窗中的日期和时间，转换为ISO格式
		const dateTimeStr = voiceRecognitionState.value.voiceDateTime
		const date = new Date(dateTimeStr)
		const year = date.getFullYear()
		const month = String(date.getMonth() + 1).padStart(2, '0')
		const day = String(date.getDate()).padStart(2, '0')
		const hours = String(date.getHours()).padStart(2, '0')
		const minutes = String(date.getMinutes()).padStart(2, '0')
		recordTime = `${year}-${month}-${day} ${hours}:${minutes}`
	} else {
		// 其他模式：使用当前时间
		recordTime = formatCurrentTime()
	}

	// 基础数据
	const baseData = {
		recordId: currentRecordId.value, // 修改时传入记录ID，新增时为null
		babyId: currentBaby.id,
		recordTime: recordTime
	}

	// 根据喂养类型和记录方式构建具体数据
	switch (selectedType.value) {
		case 'breastfeeding':
			const currentMethod = recordMethods.value.breastfeeding

			if (currentMethod === 'manual') {
				// 手动模式：使用手动设置的时长
				return {
					...baseData,
					feedingType: 1, // 母乳亲喂
					durationLeftSeconds: feedingData.value.breastfeeding.leftDuration * 60, // 转换为秒
					durationRightSeconds: feedingData.value.breastfeeding.rightDuration * 60,
					totalDurationSeconds: (feedingData.value.breastfeeding.leftDuration + feedingData.value.breastfeeding.rightDuration) * 60
				}
			} else if (currentMethod === 'timer') {
				// 计时器模式：使用计时器的实际时长
				return {
					...baseData,
					feedingType: 1, // 母乳亲喂
					durationLeftSeconds: timerData.value.leftDuration,
					durationRightSeconds: timerData.value.rightDuration,
					totalDurationSeconds: timerData.value.leftDuration + timerData.value.rightDuration
				}
			} else if (currentMethod === 'voice') {
				// 语音模式：使用语音识别的结果
				return {
					...baseData,
					feedingType: 1, // 母乳亲喂
					foodDetails: voiceRecognitionState.value.recognizedText.trim() // 语音识别的详情作为备注
				}
			}
			break

		case 'bottle':
			const currentMethod2 = recordMethods.value.bottle

			if (currentMethod2 === 'manual') {
				// 手动模式：使用手动设置的喂养量
				return {
					...baseData,
					feedingType: 2, // 母乳瓶喂
					volume: feedingData.value.bottle.amount
				}
			} else if (currentMethod2 === 'voice') {
				// 语音模式：使用语音识别的结果
				return {
					...baseData,
					feedingType: 2, // 母乳瓶喂
					foodDetails: voiceRecognitionState.value.recognizedText.trim()
				}
			}
			break

		case 'formula':
			const currentMethod3 = recordMethods.value.formula

			if (currentMethod3 === 'manual') {
				// 手动模式：使用手动设置的喂养量
				return {
					...baseData,
					feedingType: 3, // 奶粉喂养
					volume: feedingData.value.formula.amount
				}
			} else if (currentMethod3 === 'voice') {
				// 语音模式：使用语音识别的结果
				return {
					...baseData,
					feedingType: 3, // 奶粉喂养
					foodDetails: voiceRecognitionState.value.recognizedText.trim()
				}
			}
			break

		case 'food':
			// 辅食只有手动选择模式
			return {
				...baseData,
				feedingType: 4, // 辅食
				foodDetails: feedingData.value.food.selectedItems.join(',')
			}
	}

	return baseData
}

function goBack() {
	uni.navigateBack()
}

function goToFeedingRecord() {
	// 检查是否正在录音
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		uni.showToast({
			title: '录音进行中，不可切换页面',
			icon: 'none'
		})
		return
	}

	md.sensorLogTake({
		xcxClick: "小程序页面点击事件",
		pageName: "喂养工具首页",
		buttonName: "喂养记录",
	});

	uni.navigateTo({
		url: '/pages/feedingRecord/feedingRecord'
	})
}

// 时间选择器相关方法
function onTimeChange(value) {
	currentTime.value = value
}

// 语音识别时间选择器显示
function showVoiceTimePicker() {
	// 使用与 formatCurrentTime() 一致的默认时间
	if (!voiceRecognitionState.value.voiceDateTime) {
		const defaultTimeString = formatCurrentTime()
		if (defaultTimeString) {
			voiceRecognitionState.value.voiceDateTime = `${defaultTimeString}:00`
		} else {
			const now = new Date()
			voiceRecognitionState.value.voiceDateTime = now.toISOString().slice(0, 19).replace('T', ' ')
		}
	}
	voiceTimePickerRef.value.show()
}

// 语音识别时间选择
function onVoiceTimeChange(value) {
	// 设置完整的日期时间字符串
	voiceRecognitionState.value.voiceDateTime = value

	// 解析日期和时间
	const date = new Date(value)
	const year = date.getFullYear()
	const month = String(date.getMonth() + 1).padStart(2, '0')
	const day = String(date.getDate()).padStart(2, '0')
	const hours = String(date.getHours()).padStart(2, '0')
	const minutes = String(date.getMinutes()).padStart(2, '0')

	// 设置分离的日期和时间
	voiceRecognitionState.value.recordDate = `${year}-${month}-${day}`
	voiceRecognitionState.value.recordTime = `${hours}:${minutes}`
}

// 格式化语音识别时间显示
function formatVoiceDateTime() {
	if (voiceRecognitionState.value.voiceDateTime) {
		const date = new Date(voiceRecognitionState.value.voiceDateTime)
		const year = date.getFullYear()
		const month = String(date.getMonth() + 1).padStart(2, '0')
		const day = String(date.getDate()).padStart(2, '0')
		const hours = String(date.getHours()).padStart(2, '0')
		const minutes = String(date.getMinutes()).padStart(2, '0')
		console.warn('formatVoiceDateTime', year, month, day, hours, minutes)
		return `${year}-${month}-${day} ${hours}:${minutes}`
	}
	return ''
}

// 关闭语音识别结果弹窗
function closeVoiceResult() {
	voiceRecognitionState.value.showResultPage = false
	voiceRecognitionState.value.recognizedText = ''
	voiceRecognitionState.value.recordDate = ''
	voiceRecognitionState.value.recordTime = ''
	voiceRecognitionState.value.voiceDateTime = ''

	// 重置防连点状态，确保用户可以重新录音
	resetRecordingCooldown()
}

function formatCurrentTime() {
	if (!currentTime.value) {
		// 如果当前时间未设置，返回当前时间
		const now = new Date()
		const year = now.getFullYear()
		const month = String(now.getMonth() + 1).padStart(2, '0')
		const day = String(now.getDate()).padStart(2, '0')
		const hours = String(now.getHours()).padStart(2, '0')
		const minutes = String(now.getMinutes()).padStart(2, '0')
		return `${year}-${month}-${day} ${hours}:${minutes}`
	}

	const date = new Date(currentTime.value)
	const year = date.getFullYear()
	const month = String(date.getMonth() + 1).padStart(2, '0')
	const day = String(date.getDate()).padStart(2, '0')
	const hours = String(date.getHours()).padStart(2, '0')
	const minutes = String(date.getMinutes()).padStart(2, '0')
	return `${year}-${month}-${day} ${hours}:${minutes}`
}

function getTabImage() {
	const currentMethod = recordMethods.value[selectedType.value]
	if (currentMethod === 'manual') {
		return feedingIndexRes.Tab_bottom_write
	} else if (currentMethod === 'timer') {
		return feedingIndexRes.Tab_bottom_timer
	} else {
		return feedingIndexRes.Tab_bottom_voice
	}
}

function getTabImage2() {
	const currentMethod = recordMethods.value[selectedType.value]
	if (currentMethod === 'manual') {
		return feedingIndexRes.Tab_bottom_muruandnaifen_write
	} else {
		return feedingIndexRes.Tab_bottom_muruandnaifen_voice
	}
}

// 格式化时间显示 (MM:SS)
function formatTime(seconds) {
	const minutes = Math.floor(seconds / 60)
	const remainingSeconds = seconds % 60
	return `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`
}

// 格式化总时长显示 (HH:MM:SS)
function formatTotalDuration() {
	const totalSeconds = timerData.value.leftDuration + timerData.value.rightDuration
	const hours = Math.floor(totalSeconds / 3600)
	const minutes = Math.floor((totalSeconds % 3600) / 60)
	const seconds = totalSeconds % 60
	return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`
}

// 辅食选择相关方法
function toggleFoodSelection(item) {
	// 在编辑模式时不允许选择
	if (foodSelectionState.value.isEditMode) {
		return
	}

	const selectedItems = feedingData.value.food.selectedItems
	const index = selectedItems.indexOf(item)

	if (index > -1) {
		// 如果已选中，则取消选中
		selectedItems.splice(index, 1)
	} else {
		// 如果未选中，则添加选中
		selectedItems.push(item)
	}
}

function enterEditMode() {
	if (foodSelectionState.value.isEditMode) {
		// 如果已经在编辑模式，则取消编辑
		cancelEditMode()
	} else {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "辅食删除",
		});
		// 保存原始辅食数据，保持顺序
		foodSelectionState.value.originalFoodData = {
			selectedItems: [...feedingData.value.food.selectedItems],
			categories: {}
		}

		// 保存每个分类的原始数据
		Object.keys(foodCategories.value).forEach(categoryName => {
			foodSelectionState.value.originalFoodData.categories[categoryName] = {
				items: [...foodCategories.value[categoryName].items],
				customItems: [...foodCategories.value[categoryName].customItems]
			}
		})
		// 进入编辑模式
		foodSelectionState.value.isEditMode = true
		// 清空待删除列表
		foodSelectionState.value.pendingDeletes = []
	}
}

function cancelEditMode() {
	// 恢复原始辅食数据，保持原有顺序
	if (foodSelectionState.value.originalFoodData) {
		feedingData.value.food.selectedItems = [...foodSelectionState.value.originalFoodData.selectedItems]
	}

	// 恢复被删除的辅食到UI中，保持原有顺序
	foodSelectionState.value.pendingDeletes.forEach(item => {
		const category = foodCategories.value[item.categoryName]
		if (category) {
			// 检查是否已存在，避免重复添加
			if (!category.items.includes(item.foodName) && !category.customItems.includes(item.foodName)) {
				// 找到原来的位置并插入，而不是添加到末尾
				const originalIndex = item.originalIndex || 0

				// 根据原始位置判断应该添加到哪个数组
				// 如果原始位置在默认辅食范围内，添加到items；否则添加到customItems
				if (originalIndex >= 0 && originalIndex < category.items.length) {
					// 添加到默认辅食数组
					category.items.splice(originalIndex, 0, item.foodName)
				} else {
					// 添加到自定义辅食数组
					const customIndex = originalIndex - category.items.length
					if (customIndex >= 0 && customIndex <= category.customItems.length) {
						category.customItems.splice(customIndex, 0, item.foodName)
					} else {
						// 如果找不到原位置，则添加到自定义辅食末尾
						category.customItems.push(item.foodName)
					}
				}
			}
		}
	})

	// 清空待删除列表
	foodSelectionState.value.pendingDeletes = []
	// 退出编辑模式
	foodSelectionState.value.isEditMode = false
	// 清理原始数据
	foodSelectionState.value.originalFoodData = null
}

async function exitEditMode() {
	md.sensorLogTake({
		xcxClick: "小程序页面点击事件",
		pageName: "喂养工具首页",
		buttonName: "辅食删除完成",
	});
	// 防连点检查
	if (foodSelectionState.value.isDeletingFood) {
		console.log('防连点：删除完成按钮被阻止')
		return
	}
	foodSelectionState.value.isDeletingFood = true
	console.log('防连点：设置删除完成状态为true')

	// 如果有待删除的辅食，调用接口删除
	if (foodSelectionState.value.pendingDeletes.length > 0) {
		try {
			// 获取所有待删除的foodId
			const foodIds = foodSelectionState.value.pendingDeletes.map(item => item.foodId).join(',')

			// 调用接口删除辅食
			const response = await feedingFoodsCustomDelete({
				foodIds: foodIds
			})

			console.log('批量删除辅食成功:', response)

			// 清空待删除列表
			foodSelectionState.value.pendingDeletes = []

			// 重新加载辅食列表
			await loadFoodsData()

			uni.showToast({
				title: '删除成功',
				icon: 'success'
			})

		} catch (error) {
			console.error('批量删除辅食失败:', error)
			uni.showToast({
				title: '删除失败',
				icon: 'none'
			})

			// 删除失败时恢复数据
			console.log('删除失败，恢复原始数据')
			if (foodSelectionState.value.originalFoodData) {
				// 恢复原始辅食数据
				Object.keys(foodCategories.value).forEach(categoryName => {
					const originalCategory = foodSelectionState.value.originalFoodData.categories[categoryName]
					if (originalCategory) {
						foodCategories.value[categoryName].items = [...originalCategory.items]
						foodCategories.value[categoryName].customItems = [...originalCategory.customItems]
					}
				})

				// 清空待删除列表
				foodSelectionState.value.pendingDeletes = []

				console.log('数据恢复完成')
			}
		}
	}

	// 退出编辑模式
	foodSelectionState.value.isEditMode = false
	// 清理原始数据
	foodSelectionState.value.originalFoodData = null

	// 立即重置防连点状态
	foodSelectionState.value.isDeletingFood = false
	console.log('防连点：重置删除完成状态为false')
}

function showAddFoodPopup(categoryName) {
	md.sensorLogTake({
		xcxClick: "小程序页面点击事件",
		pageName: "喂养工具首页",
		buttonName: "辅食添加" + categoryName,
	});
	// 防连点检查
	if (foodSelectionState.value.isAddingFood) {
		console.log('防连点：添加辅食按钮被阻止')
		return
	}
	foodSelectionState.value.isAddingFood = true
	console.log('防连点：设置添加辅食状态为true')

	// 在编辑模式下不允许添加
	if (foodSelectionState.value.isEditMode) {
		uni.showToast({
			title: '编辑模式下不能添加辅食',
			icon: 'none'
		})
		foodSelectionState.value.isAddingFood = false
		return
	}

	// 检查分类下的自定义辅食数量限制
	const category = foodCategories.value[categoryName]
	if (category.customItems.length >= 20) {
		uni.showToast({
			title: '最多添加20种辅食',
			icon: 'none'
		})
		foodSelectionState.value.isAddingFood = false
		return
	}

	foodSelectionState.value.currentCategory = categoryName
	foodSelectionState.value.newFoodItem = ''
	// 显示弹窗
	addFoodPopup.value.open()

	// 立即重置防连点状态（弹窗显示后）
	setTimeout(() => {
		foodSelectionState.value.isAddingFood = false
		console.log('防连点：重置添加辅食状态为false')
	}, 100)
}

// 切换分类展开/缩起状态
function toggleCategoryExpansion(categoryName) {
	const category = foodCategories.value[categoryName]
	if (category) {
		category.expanded = !category.expanded
	}
}

function cancelAddFood() {
	addFoodPopup.value.close()
	foodSelectionState.value.newFoodItem = ''
}

function confirmAddFood() {
	if (foodSelectionState.value.isAddingFood) {
		console.log('防连点：添加辅食按钮被阻止')
		return
	}
	foodSelectionState.value.isAddingFood = true
	console.log('防连点：设置添加辅食状态为true')

	const itemName = foodSelectionState.value.newFoodItem.trim()
	const categoryName = foodSelectionState.value.currentCategory

	if (!itemName) {
		uni.showToast({
			title: '请输入辅食名称',
			icon: 'none'
		})
		foodSelectionState.value.isAddingFood = false
		return
	}

	addCustomFoodItem(categoryName, itemName)
	addFoodPopup.value.close()

	// 2秒后重置防连点状态
	setTimeout(() => {
		foodSelectionState.value.isAddingFood = false
		console.log('防连点：重置添加辅食状态为false')
	}, 2000)
}

async function addCustomFoodItem(categoryName, itemName) {
	// 检查字数限制
	if (itemName.length > 10) {
		uni.showToast({
			title: '辅食名称不能超过10个字',
			icon: 'none'
		})
		foodSelectionState.value.isAddingFood = false
		return
	}

	// 检查分类下的自定义辅食数量限制
	const category = foodCategories.value[categoryName]
	if (category.customItems.length >= 20) {
		uni.showToast({
			title: '最多添加20种辅食',
			icon: 'none'
		})
		foodSelectionState.value.isAddingFood = false
		return
	}

	// 检查是否已存在
	if (category.items.includes(itemName) || category.customItems.includes(itemName)) {
		uni.showToast({
			title: '该辅食已存在',
			icon: 'none'
		})
		foodSelectionState.value.isAddingFood = false
		return
	}

	try {
		// 获取辅食类型ID
		const foodTypeId = Object.keys(foodTypeMap).find(key => foodTypeMap[key] === categoryName)

		if (!foodTypeId) {
			uni.showToast({
				title: '辅食类型错误',
				icon: 'none'
			})
			foodSelectionState.value.isAddingFood = false
			return
		}

		// 调用接口添加自定义辅食
		const response = await feedingFoodsCustomAdd({
			foodName: itemName,
			foodType: parseInt(foodTypeId)
		})

		console.log('添加自定义辅食成功:', response)

		// 重新加载辅食列表
		await loadFoodsData()

		uni.showToast({
			title: '添加成功',
			icon: 'none'
		})

	} catch (error) {
		console.error('添加自定义辅食失败:', error)
		uni.showToast({
			title: '添加失败',
			icon: 'none'
		})
		// 失败时重置防连点状态
		foodSelectionState.value.isAddingFood = false
	}
}

function removeFoodItem(categoryName, itemName) {
	// 获取foodId
	const foodId = foodIdMap.value.get(itemName)

	if (!foodId) {
		uni.showToast({
			title: '找不到辅食ID',
			icon: 'none'
		})
		return
	}

	// 从UI中移除（但不调用接口）
	const category = foodCategories.value[categoryName]

	// 记录原始位置信息
	let originalIndex = -1

	// 从默认辅食中移除
	const defaultIndex = category.items.indexOf(itemName)
	if (defaultIndex > -1) {
		originalIndex = defaultIndex
		category.items.splice(defaultIndex, 1)
	}

	// 从自定义辅食中移除
	const customIndex = category.customItems.indexOf(itemName)
	if (customIndex > -1) {
		originalIndex = customIndex
		category.customItems.splice(customIndex, 1)
	}

	// 从已选择的辅食中移除
	const selectedIndex = feedingData.value.food.selectedItems.indexOf(itemName)
	if (selectedIndex > -1) {
		feedingData.value.food.selectedItems.splice(selectedIndex, 1)
	}

	// 添加到待删除列表，包含原始位置信息
	foodSelectionState.value.pendingDeletes.push({
		foodId: foodId,
		foodName: itemName,
		categoryName: categoryName,
		originalIndex: originalIndex
	})

	console.log('添加到待删除列表:', itemName, '原始位置:', originalIndex, '当前待删除:', foodSelectionState.value.pendingDeletes)
}

// 语音识别相关方法
function checkVoicePermission() {
	// 检查录音权限
	uni.getSetting({
		success: (res) => {
			console.log('录音权限检查结果:', res.authSetting)

			if (!res.authSetting['scope.record']) {
				// 没有录音权限，请求授权
				console.log('请求录音权限...')
				uni.authorize({
					scope: 'scope.record',
					success: () => {
						console.log('录音权限授权成功')
					},
					fail: (err) => {
						console.error('录音权限授权失败:', err)
						// 用户拒绝授权
						uni.showModal({
							title: '需要录音权限',
							content: '为了使用语音识别功能，需要获取录音权限。请在设置中开启录音权限。',
							confirmText: '去设置',
							cancelText: '取消',
							success: (modalRes) => {
								if (modalRes.confirm) {
									// 打开设置页面
									uni.openSetting({
										success: (settingRes) => {
											console.log('设置页面结果:', settingRes)
											if (settingRes.authSetting['scope.record']) {
												console.log('录音权限已开启')
											}
										},
										fail: (err) => {
											console.error('打开设置页面失败:', err)
										}
									})
								}
							}
						})
					}
				})
			} else {
				console.log('已有录音权限')
			}
		},
		fail: (err) => {
			console.error('检查录音权限失败:', err)
			uni.showToast({
				title: '录音权限检查失败',
				icon: 'none'
			})
		}
	})
}

// 录音状态管理
const recordingState = ref({
	isInitialized: false, // 是否已初始化录音管理器
	isRecording: false, // 是否正在录音
	recordingStartTime: null, // 录音开始时间
	recordingDuration: 0, // 录音时长
	recordingTimer: null, // 录音时长定时器
	lastStopTime: 0, // 上次停止录音的时间戳
	canStartRecording: true // 是否可以开始录音（防连点）
})

// 初始化录音管理器（只初始化一次）
function initializeRecorderManager() {
	if (recordingState.value.isInitialized) {
		console.log('录音管理器已初始化，跳过')
		return
	}

	// 检查录音管理器是否可用
	if (!recorderManager) {
		console.error('录音管理器不可用')
		return
	}

	console.log('初始化录音管理器...')

	// 清理之前的回调（兼容性处理）
	try {
		if (typeof recorderManager.offStart === 'function') {
			recorderManager.offStart()
		}
		if (typeof recorderManager.offStop === 'function') {
			recorderManager.offStop()
		}
		if (typeof recorderManager.offError === 'function') {
			recorderManager.offError()
		}
	} catch (error) {
		console.warn('清理录音管理器回调时出错:', error)
	}

	// 绑定录音开始回调
	recorderManager.onStart(() => {
		console.log('录音开始成功')
		recordingState.value.isRecording = true
		recordingState.value.recordingStartTime = Date.now()
		voiceRecognitionState.value.isRecording = true
		voiceRecognitionState.value.recordingStartTime = Date.now()

		// 设置防连点状态
		recordingState.value.canStartRecording = false

		// 启动录音时长定时器
		recordingState.value.recordingTimer = setInterval(() => {
			if (recordingState.value.isRecording && recordingState.value.recordingStartTime) {
				const duration = Math.floor((Date.now() - recordingState.value.recordingStartTime) / 1000)
				recordingState.value.recordingDuration = duration
				voiceRecognitionState.value.recordingDuration = duration
			}
		}, 1000)
	})

	// 绑定录音停止回调
	recorderManager.onStop(async (res) => {
		console.log('录音停止回调触发，结果:', res)

		// 清理录音定时器
		if (recordingState.value.recordingTimer) {
			clearInterval(recordingState.value.recordingTimer)
			recordingState.value.recordingTimer = null
		}

		// 重置录音状态
		recordingState.value.isRecording = false
		recordingState.value.recordingStartTime = null
		voiceRecognitionState.value.isRecording = false
		voiceRecognitionState.value.recordingStartTime = null

		// 1秒后恢复防连点状态
		setTimeout(() => {
			recordingState.value.canStartRecording = true
			console.log('录音冷却结束，可以重新录音')
		}, 1000)

		// 检查录音文件路径
		const tempFilePath = res.tempFilePath
		if (!tempFilePath) {
			console.error('录音文件路径不存在，完整返回结果:', res)
			uni.hideLoading()
			uni.showToast({
				title: '录音文件获取失败，请检查录音权限',
				icon: 'none'
			})
			// 重置录音状态，让用户可以重新录音
			resetRecordingState()
			return
		}

		console.log('获取到录音文件路径:', tempFilePath)

		// 检查文件是否存在
		uni.getFileSystemManager().access({
			path: tempFilePath,
			success: () => {
				console.log('录音文件存在，开始处理')
				processVoiceFile(tempFilePath)
			},
			fail: (err) => {
				console.error('录音文件不存在:', err)
				uni.showToast({
					title: '录音文件不存在，请重新录音',
					icon: 'none'
				})
				// 重置录音状态，让用户可以重新录音
				resetRecordingState()
			}
		})
	})

	// 绑定录音错误回调
	recorderManager.onError((err) => {
		console.error('录音错误:', err)

		// 重置录音状态
		resetRecordingState()

		// 1秒后恢复防连点状态
		setTimeout(() => {
			recordingState.value.canStartRecording = true
			console.log('录音错误后冷却结束，可以重新录音')
		}, 1000)

		// uni.showToast({
		// 	title: '录音失败',
		// 	icon: 'none'
		// })
	})

	recordingState.value.isInitialized = true
	console.log('录音管理器初始化完成')
}

// 重置录音状态
function resetRecordingState() {
	console.log('重置录音状态')

	// 清理录音定时器
	if (recordingState.value.recordingTimer) {
		clearInterval(recordingState.value.recordingTimer)
		recordingState.value.recordingTimer = null
	}

	// 重置录音状态
	recordingState.value.isRecording = false
	recordingState.value.recordingStartTime = null
	recordingState.value.recordingDuration = 0

	// 重置语音识别状态
	voiceRecognitionState.value.isRecording = false
	voiceRecognitionState.value.recordingStartTime = null
	voiceRecognitionState.value.recordingDuration = 0
	voiceRecognitionState.value.recognitionStatus = 'idle'

	// 注意：这里不调用 recorderManager.stop()，因为调用方会处理
	// 避免重复调用导致的问题
}

// 重置防连点状态（立即恢复）
function resetRecordingCooldown() {
	recordingState.value.canStartRecording = true
	console.log('立即重置录音冷却状态')
}

// 检查录音管理器状态
function checkRecorderStatus() {
	console.log('检查录音管理器状态:', {
		isRecording: recordingState.value.isRecording,
		voiceIsRecording: voiceRecognitionState.value.isRecording,
		recognitionStatus: voiceRecognitionState.value.recognitionStatus,
		canStartRecording: recordingState.value.canStartRecording
	})
}

// 强制重置录音管理器状态
function forceResetRecorderManager() {
	console.log('强制重置录音管理器状态')

	// 重置录音状态
	resetRecordingState()

	// 尝试停止录音管理器
	try {
		if (recorderManager) {
			recorderManager.stop()
		}
	} catch (error) {
		console.warn('强制停止录音管理器时出错:', error)
	}

	// 等待一小段时间让录音管理器完全停止
	setTimeout(() => {
		console.log('录音管理器状态重置完成')
		// 重置防连点状态
		resetRecordingCooldown()
		// 确保状态完全重置
		recordingState.value.isRecording = false
		voiceRecognitionState.value.isRecording = false
		voiceRecognitionState.value.recognitionStatus = 'idle'

		// 检查重置后的状态
		checkRecorderStatus()
	}, 300)
}

// 开始录音
async function startRecording() {
	if (!recordingState.value.isRecording) {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "语音识别录制开始按钮",
		});
	}

	console.log('开始录音请求...')
	console.log('当前录音状态:', {
		isRecording: recordingState.value.isRecording,
		recordingStartTime: recordingState.value.recordingStartTime,
		recordingDuration: recordingState.value.recordingDuration,
		canStartRecording: recordingState.value.canStartRecording,
		voiceIsRecording: voiceRecognitionState.value.isRecording,
		voiceRecordingStartTime: voiceRecognitionState.value.recordingStartTime,
		voiceRecordingDuration: voiceRecognitionState.value.recordingDuration,
		recognitionStatus: voiceRecognitionState.value.recognitionStatus
	})

	// 检查录音管理器是否已初始化
	if (!recordingState.value.isInitialized) {
		console.log('录音管理器未初始化，尝试初始化...')
		initializeRecorderManager()
	}

	// 检查录音权限
	uni.getSetting({
		success: async (res) => {
			if (!res.authSetting['scope.record']) {
				uni.showToast({
					title: '请先授权录音权限',
					icon: 'none'
				})
				return
			}

			// 防止重复录音：检查是否正在录音
			if (recordingState.value.isRecording) {
				console.log('正在录音中，忽略重复请求')
				return
			}

			// 如果录音管理器状态异常，强制重置
			if (recordingState.value.isRecording !== voiceRecognitionState.value.isRecording) {
				console.log('录音状态不一致，强制重置')
				resetRecordingState()
			}

			// 防连点检查：检查是否可以开始录音
			if (!recordingState.value.canStartRecording) {
				console.log('录音冷却中，忽略请求')
				// uni.showToast({
				// 	title: '请稍后再试',
				// 	icon: 'none',
				// 	duration: 1000
				// })
				return
			}

			// 防止快速重复点击：检查距离上次停止的时间
			const now = Date.now()
			if (now - recordingState.value.lastStopTime < 1000) {
				console.log('距离上次停止时间太短，忽略请求')
				return
			}

			console.log('开始录音...')

			// 重置录音状态
			resetRecordingState()

			// 添加小延迟确保录音管理器状态正确
			await new Promise(resolve => setTimeout(resolve, 100))

			// 开始录音
			try {
				recorderManager.start({
					duration: 60000, // 最长录音时间60秒
					sampleRate: 16000, // 采样率
					numberOfChannels: 1, // 单声道
					encodeBitRate: 96000, // 编码码率
					format: 'mp3' // 音频格式
				})
			} catch (error) {
				console.error('开始录音失败:', error)
				// 如果开始录音失败，强制重置录音管理器状态
				forceResetRecorderManager()
				uni.showToast({
					title: '录音启动失败，请重试',
					icon: 'none'
				})
			}
		},
		fail: (err) => {
			console.error('检查录音权限失败', err)
			uni.showToast({
				title: '录音权限检查失败',
				icon: 'none'
			})
		}
	})
}

// 停止录音
async function stopRecording() {
	console.log('停止录音请求...')



	// 检查录音是否真正开始
	if (!recordingState.value.isRecording || !recordingState.value.recordingStartTime) {
		console.log('录音未开始或已停止，无需停止')
		return
	}


	md.sensorLogTake({
		xcxClick: "小程序页面点击事件",
		pageName: "喂养工具首页",
		buttonName: "语音识别录制结束按钮",
	});

	console.log('停止录音...')
	recordingState.value.isRecording = false
	voiceRecognitionState.value.isRecording = false

	// 计算录音时长
	if (recordingState.value.recordingStartTime) {
		const duration = Math.floor((Date.now() - recordingState.value.recordingStartTime) / 1000)
		recordingState.value.recordingDuration = duration
		voiceRecognitionState.value.recordingDuration = duration
		console.log('录音时长:', duration, '秒')

		// 检查录音时长是否太短
		if (duration < 1) {
			uni.showToast({
				title: '录音时间太短，请重新录音',
				icon: 'none'
			})
			// 强制重置录音管理器状态
			forceResetRecorderManager()
			recordingState.value.lastStopTime = Date.now()
			return
		}

		// 检查录音时长是否太长
		if (duration > 60) {
			uni.showToast({
				title: '录音时间太长，请重新录音',
				icon: 'none'
			})
			// 强制重置录音管理器状态
			forceResetRecorderManager()
			recordingState.value.lastStopTime = Date.now()
			return
		}
	}

	// 记录停止时间
	recordingState.value.lastStopTime = Date.now()

	// 停止录音
	try {
		recorderManager.stop()
	} catch (error) {
		console.error('停止录音失败:', error)
		// 即使停止失败，也要强制重置录音管理器状态
		forceResetRecorderManager()
	}
}

// 处理语音文件
async function processVoiceFile(tempFilePath) {
	try {
		// 显示加载提示
		uni.showLoading({
			title: '正在转换并上传语音...',
			mask: true
		})

		// 上传语音文件（转换为base64）
		const uploadResponse = await uploadVoiceFile(tempFilePath)
		console.log('语音文件转换并上传成功:', uploadResponse)

		// 开始轮询识别结果
		await startPollingRecognitionResult(uploadResponse.taskId)

	} catch (error) {
		handleVoiceRecognitionError(error)
	}
}

// 上传语音文件
async function uploadVoiceFile(tempFilePath) {
	return new Promise((resolve, reject) => {
		// 检查文件路径
		if (!tempFilePath || typeof tempFilePath !== 'string') {
			console.error('无效的语音文件路径:', tempFilePath)
			reject(new Error('无效的语音文件路径'))
			return
		}

		console.log('开始读取语音文件:', tempFilePath)

		// 先检查文件是否存在
		uni.getFileSystemManager().access({
			path: tempFilePath,
			success: () => {
				console.log('文件存在，开始获取文件信息')

				// 获取文件信息
				uni.getFileSystemManager().getFileInfo({
					filePath: tempFilePath,
					success: (fileInfo) => {
						console.log('文件信息:', fileInfo)

						// 检查文件大小（限制为10MB）
						if (fileInfo.size > 10 * 1024 * 1024) {
							reject(new Error('语音文件过大，请重新录音'))
							return
						}

						// 检查文件大小是否太小（可能录音失败）
						if (fileInfo.size < 1024) {
							console.warn('文件大小过小:', fileInfo.size, '字节')
							reject(new Error('录音文件过小，可能录音失败，请重新录音'))
							return
						}

						console.log('文件大小正常，开始读取文件为base64')

						// 读取文件为base64
						uni.getFileSystemManager().readFile({
							filePath: tempFilePath,
							encoding: 'base64',
							success: async (res) => {
								try {
									console.log('语音文件读取成功，base64长度:', res.data.length, '字符')

									// 检查base64数据是否有效
									if (!res.data || res.data.length < 100) {
										console.error('base64数据无效，长度:', res.data?.length)
										reject(new Error('语音文件数据无效，请重新录音'))
										return
									}

									// 验证base64格式
									if (!/^[A-Za-z0-9+/]*={0,2}$/.test(res.data)) {
										console.error('base64格式无效')
										reject(new Error('语音文件格式无效，请重新录音'))
										return
									}

									console.log('base64数据验证通过，开始上传')

									// 添加base64格式头
									const base64WithHeader = `data:audio/mp3;base64,${res.data}`

									// 调用上传接口，传递带格式头的base64数据
									const response = await feedingVoiceUpload({
										audioData: base64WithHeader
									})

									console.log('上传接口返回:', response)

									if (response && response.data && response.data.taskId) {
										resolve(response.data)
									} else {
										reject(new Error('上传失败：未获取到taskId，返回数据：' + JSON.stringify(response)))
									}
								} catch (error) {
									console.error('上传过程中发生错误:', error)
									reject(error)
								}
							},
							fail: (err) => {
								console.error('读取语音文件失败:', err)
								reject(new Error('读取语音文件失败：' + err.errMsg))
							}
						})
					},
					fail: (err) => {
						console.error('获取文件信息失败:', err)
						reject(new Error('获取文件信息失败：' + err.errMsg))
					}
				})
			},
			fail: (err) => {
				console.error('文件不存在:', tempFilePath, err)
				reject(new Error('录音文件不存在，请重新录音'))
			}
		})
	})
}

// 开始轮询识别结果
async function startPollingRecognitionResult(taskId) {
	console.log('开始轮询识别结果，taskId:', taskId)

	voiceRecognitionState.value.taskId = taskId
	voiceRecognitionState.value.isPolling = true
	voiceRecognitionState.value.recognitionStatus = 'processing'

	// 设置轮询间隔（每2秒查询一次）
	voiceRecognitionState.value.pollingInterval = setInterval(async () => {
		try {
			const response = await feedingVoiceResult({
				taskId: taskId
			})

			console.log('轮询识别结果:', response)

			if (response && response.code === '000000' && response.data) {
				const result = response.data
				const status = result.flag // 0-处理中 1-成功 2-失败

				console.log('识别状态:', status)

				switch (status) {
					case 0: // 处理中
						console.log('语音识别处理中...')
						voiceRecognitionState.value.recognitionStatus = 'processing'
						// 继续轮询，不做任何处理
						break

					case 1: // 成功
						console.log('语音识别成功')
						voiceRecognitionState.value.recognitionStatus = 'success'
						clearPollingInterval()
						uni.hideLoading()

						// 立即重置防连点状态，让用户可以重新录音
						resetRecordingCooldown()

						// 显示识别结果
						voiceRecognitionState.value.recognizedText = result.text || '未能识别语音内容'

						// 使用与 formatCurrentTime() 一致的默认时间
						const defaultTimeString = formatCurrentTime()
						if (defaultTimeString) {
							// 解析时间字符串
							const [datePart, timePart] = defaultTimeString.split(' ')
							const [year, month, day] = datePart.split('-')
							const [hours, minutes] = timePart.split(':')

							voiceRecognitionState.value.recordDate = `${year}-${month}-${day}`
							voiceRecognitionState.value.recordTime = `${hours}:${minutes}`
							voiceRecognitionState.value.voiceDateTime = `${defaultTimeString}:00`
						} else {
							// 如果 formatCurrentTime() 返回空，使用当前时间
							const now = new Date()
							const year = now.getFullYear()
							const month = String(now.getMonth() + 1).padStart(2, '0')
							const day = String(now.getDate()).padStart(2, '0')
							const hours = String(now.getHours()).padStart(2, '0')
							const minutes = String(now.getMinutes()).padStart(2, '0')

							voiceRecognitionState.value.recordDate = `${year}-${month}-${day}`
							voiceRecognitionState.value.recordTime = `${hours}:${minutes}`
							voiceRecognitionState.value.voiceDateTime = `${year}-${month}-${day} ${hours}:${minutes}:00`
						}
						voiceRecognitionState.value.showResultPage = true

						// 显示识别成功提示
						uni.showToast({
							title: '语音识别成功',
							icon: 'success',
							duration: 2000
						})
						break

					case 2: // 失败
						console.log('语音识别失败')
						voiceRecognitionState.value.recognitionStatus = 'failed'
						clearPollingInterval()
						uni.hideLoading()
						// 强制重置录音管理器状态
						forceResetRecorderManager()
						uni.showToast({
							title: '语音识别失败',
							icon: 'none'
						})
						break

					default:
						console.log('未知的识别状态:', status)
						// 对于未知状态，继续轮询
						break
				}
			} else {
				console.log('接口返回异常:', response)
				// 如果接口返回异常，继续轮询
			}
		} catch (error) {
			console.error('轮询识别结果失败:', error)
			// 轮询失败时，如果连续失败次数过多，停止轮询并重置状态
			if (!voiceRecognitionState.value.pollingErrorCount) {
				voiceRecognitionState.value.pollingErrorCount = 0
			}
			voiceRecognitionState.value.pollingErrorCount++

			// 如果连续失败超过5次，停止轮询并重置状态
			if (voiceRecognitionState.value.pollingErrorCount >= 5) {
				console.log('轮询连续失败5次，停止轮询并重置状态')
				clearPollingInterval()
				uni.hideLoading()
				forceResetRecorderManager()
				uni.showToast({
					title: '识别服务异常，请重试',
					icon: 'none'
				})
			}
		}
	}, 2000) // 每2秒轮询一次

	// 设置最大轮询时间（30秒后停止）
	setTimeout(() => {
		if (voiceRecognitionState.value.isPolling) {
			console.log('轮询超时，停止轮询')
			clearPollingInterval()
			uni.hideLoading()
			// 强制重置录音管理器状态（超时时重置，让用户可以重新录音）
			forceResetRecorderManager()
			uni.showToast({
				title: '识别超时，请重试',
				icon: 'none'
			})
		}
	}, 30000)
}

// 清理轮询定时器
function clearPollingInterval() {
	console.log('清理轮询定时器')

	if (voiceRecognitionState.value.pollingInterval) {
		clearInterval(voiceRecognitionState.value.pollingInterval)
		voiceRecognitionState.value.pollingInterval = null
	}
	voiceRecognitionState.value.isPolling = false

	// 同时清理录音定时器
	if (recordingState.value.recordingTimer) {
		clearInterval(recordingState.value.recordingTimer)
		recordingState.value.recordingTimer = null
	}

	// 如果不是成功状态，重置识别状态和录音状态
	if (voiceRecognitionState.value.recognitionStatus !== 'success') {
		voiceRecognitionState.value.recognitionStatus = 'idle'
		resetRecordingState()
	}

	// 重置轮询错误计数
	voiceRecognitionState.value.pollingErrorCount = 0

	// 重置防连点状态，确保用户可以重新录音
	resetRecordingCooldown()
}

// 处理语音识别错误
function handleVoiceRecognitionError(error) {
	console.error('语音识别错误:', error)
	clearPollingInterval()
	uni.hideLoading()

	// 强制重置录音管理器状态
	forceResetRecorderManager()

	// 根据错误类型显示不同的提示
	let errorMessage = '语音识别失败，请重试'

	if (error.message) {
		if (error.message.includes('无效的语音文件路径')) {
			errorMessage = '录音文件获取失败，请重试'
		} else if (error.message.includes('读取语音文件失败')) {
			errorMessage = '录音文件读取失败，请重试'
		} else if (error.message.includes('上传失败')) {
			errorMessage = '语音上传失败，请重试'
		} else if (error.message.includes('语音文件过大')) {
			errorMessage = '录音文件过大，请重新录音'
		} else if (error.message.includes('获取文件信息失败')) {
			errorMessage = '录音文件信息获取失败，请重试'
		}
	}

	uni.showToast({
		title: errorMessage,
		icon: 'none'
	})
}

function getFeedingTypeLabel() {
	const typeMap = {
		breastfeeding: '母乳亲喂',
		bottle: '母乳瓶喂',
		formula: '奶粉喂养',
		food: '辅食'
	}
	return typeMap[selectedType.value] || '未知'
}

// 格式化录音时长显示
function formatRecordingDuration(seconds) {
	if (!seconds || seconds <= 0) return '0秒'

	const minutes = Math.floor(seconds / 60)
	const remainingSeconds = seconds % 60

	if (minutes > 0) {
		return `${minutes}分${remainingSeconds}秒`
	} else {
		return `${remainingSeconds}秒`
	}
}

function reRecognize() {
	console.log('重新识别...')

	// 清理轮询状态
	clearPollingInterval()

	// 强制重置录音管理器状态
	forceResetRecorderManager()

	// 清理录音定时器
	if (voiceRecognitionState.value.recordingTimer) {
		clearInterval(voiceRecognitionState.value.recordingTimer)
		voiceRecognitionState.value.recordingTimer = null
	}

	// 重置识别状态
	voiceRecognitionState.value.showResultPage = false
	voiceRecognitionState.value.recognizedText = ''
	voiceRecognitionState.value.taskId = ''
	voiceRecognitionState.value.recordDate = ''
	voiceRecognitionState.value.recordTime = ''
	voiceRecognitionState.value.voiceDateTime = ''
}

async function completeVoiceRecord() {
	// 防止重复提交
	if (isSubmitting.value) {
		return
	}

	const detailText = voiceRecognitionState.value.recognizedText.trim()

	if (!detailText) {
		uni.showToast({
			title: '还没有输入喂养信息哦～',
			icon: 'none'
		})
		return
	}

	try {
		isSubmitting.value = true

		// 显示加载提示
		// uni.showLoading({
		// 	title: '保存中...'
		// })

		// 构建记录数据（使用统一的构建函数）
		const recordData = buildRecordData()
		console.log('提交语音记录数据:', recordData)

		// 调用接口保存记录
		const response = await feedingRecords(recordData)
		console.log('保存语音记录成功:', response)

		// 隐藏加载提示
		// uni.hideLoading()

		// 刷新 home 数据
		await loadHomeData()

		// 清空计时器数据
		timerData.value.leftDuration = 0
		timerData.value.rightDuration = 0

		// 不清空喂养数据，保持用户输入

		// 关闭结果页面
		voiceRecognitionState.value.showResultPage = false
		voiceRecognitionState.value.recognizedText = ''
		voiceRecognitionState.value.recordDate = ''
		voiceRecognitionState.value.recordTime = ''
		voiceRecognitionState.value.taskId = ''
		voiceRecognitionState.value.recordingStartTime = null
		voiceRecognitionState.value.recordingDuration = 0

		// 清理录音定时器
		if (voiceRecognitionState.value.recordingTimer) {
			clearInterval(voiceRecognitionState.value.recordingTimer)
			voiceRecognitionState.value.recordingTimer = null
		}

		// 显示成功弹窗
		successPopup.value.open()

	} catch (error) {
		console.error('保存语音记录失败:', error)
		// uni.hideLoading()
		uni.showToast({
			title: '保存失败',
			icon: 'none'
		})
	} finally {
		// 添加2秒防连点
		setTimeout(() => {
			isSubmitting.value = false
		}, 2000)
	}
}



// 记录成功弹窗相关方法
async function onSuccessJump() {
	// 检查是否正在录音
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		uni.showToast({
			title: '录音进行中，不可切换页面',
			icon: 'none'
		})
		return
	}

	const res = await getHealthField();

	if (!res.success) {
		uni.showToast({
			title: "获取健康字段失败",
			icon: "none",
		});
		return;
	}

	const { sign, timestamp, appId, partnerUserId, env } = res.data;

	jump({
		type: JumpType.MINI,
		url: "/pages/partner/redirect",
		extra: {
			appId: "wx81ecfb5aa3fb512f",
			envVersion: env,
			extraData: {
				sign, // 参考 4.请求参数
				timestamp, // 参考 4.请求参数
				appId, // 参考 4.请求参数
				partnerUserId, // 参考 4.请求参数
				targetApp:
					"/h5/partner/shining-like-a-start/landing-free-consult?sysType=CRF",
			},
		},
	});	// 关闭弹窗
	successPopup.value.close()
}

function onSuccessClose() {
	// 关闭弹窗
	successPopup.value.close()
	// 跳转至记录页面
	uni.navigateTo({
		url: '/pages/feedingRecord/feedingRecord'
	})
}

// 检查是否有未完成的编辑操作
function hasUnfinishedEdit() {
	return foodSelectionState.value.isEditMode && foodSelectionState.value.pendingDeletes.length > 0
}

// 恢复未完成的编辑操作
function restoreUnfinishedEdit() {
	if (hasUnfinishedEdit()) {
		console.log('恢复未完成的辅食删除操作')
		// 显示提示
		uni.showModal({
			title: '提示',
			content: '检测到未完成的辅食删除操作，是否继续？',
			confirmText: '继续删除',
			cancelText: '取消编辑',
			success: (res) => {
				if (res.confirm) {
					// 用户选择继续删除，保持当前编辑状态
					console.log('用户选择继续删除')
				} else {
					// 用户选择取消编辑，恢复原始数据
					console.log('用户选择取消编辑')
					cancelEditMode()
				}
			}
		})
	}
}

// 宝宝切换相关方法
function showBabySwitch() {
	// 检查是否正在录音
	if (recordingState.value.isRecording || voiceRecognitionState.value.isRecording) {
		uni.showToast({
			title: '录音进行中，不可切换宝宝',
			icon: 'none'
		})
		return
	}

	// 只有当有多个宝宝时才显示切换弹窗
	if (babyList.value.length > 1) {
		md.sensorLogTake({
			xcxClick: "小程序页面点击事件",
			pageName: "喂养工具首页",
			buttonName: "切换宝宝",
		});
		showBabySwitchPopup.value = true
	}
}

async function onBabyChange(baby, index) {
	// 切换宝宝
	await userStore.changeBabySelected(baby.id)
	console.log('切换到宝宝:', baby.babyName, '索引:', index)

	// 切换宝宝后重新加载该宝宝的喂养数据
	loadHomeData()

	// 清空当前状态，避免数据混乱
	clearPreviousState()
}

// 获取辅食列表数据
async function loadFoodsData() {
	try {
		const response = await feedingFoodsCustom()
		console.log('辅食列表数据:', response)

		if (response && response.data) {
			const foodsList = response.data
			processFoodsData(foodsList)
		} else {
			// 如果没有数据，使用默认数据
			loadDefaultFoodsData()
		}

	} catch (error) {
		console.error('获取辅食列表失败:', error)
		// 使用默认数据作为fallback
		loadDefaultFoodsData()
	}
}

// 处理辅食数据
function processFoodsData(foodsList) {
	// 清空现有数据
	Object.keys(foodCategories.value).forEach(category => {
		foodCategories.value[category].items = []
		foodCategories.value[category].customItems = []
		// 保持展开状态
		foodCategories.value[category].expanded = foodCategories.value[category].expanded || false
	})

	// 清空ID映射
	foodIdMap.value.clear()

	// 按类型分组辅食 - API返回的都是自定义辅食
	foodsList.forEach(food => {
		const categoryName = foodTypeMap[food.foodType]
		if (categoryName && foodCategories.value[categoryName]) {
			// API返回的辅食都是自定义辅食，应该添加到customItems中
			foodCategories.value[categoryName].customItems.push(food.foodName)
			// 保存foodId映射
			foodIdMap.value.set(food.foodName, food.foodId)
		}
	})

	console.log('处理后的辅食数据:', foodCategories.value)
	console.log('辅食ID映射:', foodIdMap.value)
}

// 加载默认辅食数据（fallback）
function loadDefaultFoodsData() {
	foodCategories.value = {
		主食: {
			items: [],
			customItems: [],
			expanded: false
		},
		蔬菜: {
			items: [],
			customItems: [],
			expanded: false
		},
		水果: {
			items: [],
			customItems: [],
			expanded: false
		},
		其他: {
			items: [],
			customItems: [],
			expanded: false
		}
	}
}


</script>

<style lang="scss" scoped>
/* ===== 页面整体布局 ===== */
.feeding-record-add-page {
	background: #ffffff;
	min-height: 100vh;
	padding: 0;
	position: relative;
}

/* ===== 可滚动内容区域 ===== */
// .scrollable-content {
// 	height: calc(100vh);
// 	// height: 100vh;
// 	background-color: #FFF8F1;
// 	/* 减去底部按钮的高度 */
// 	z-index: 200;
// 	position: absolute;
// 	width: 100vw;
// }

/* ===== 底部完成按钮 ===== */
.bottom_complete-btn {
	// padding-top: 20rpx;
	position: fixed;
	bottom: 0rpx;
	left: 0rpx;
	right: 0rpx;
	width: 750rpx;
	height: 218rpx;
	display: flex;
	background: #fff;
	z-index: 2;
	justify-content: center;
	align-items: center;

	.complete-btn-bg {
		width: 686rpx;
		height: 94rpx;
		display: block;
	}
}

/* ===== 广告横幅 ===== */
.banner-swiper {
	position: relative;
	top: 0;
	left: 16rpx;
	width: 718rpx;
	height: 174rpx;

	.banner-img {
		width: 100%;
		height: 100%;
		border-radius: 16rpx;
	}
}

/* ===== 喂养时间区域 ===== */
.feeding-time {
	position: relative;
	// margin-top: 174rpx;
	left: 0;
	right: 0;
	display: flex;
	align-items: center;
	justify-content: space-between;
	padding: 20rpx 30rpx 5rpx 30rpx;
	background: #FFF8F1;

	.baby-info {
		display: flex;
		align-items: center;
		gap: 15rpx;
		// cursor: pointer;
		transition: opacity 0.3s ease;
		/* 移除点击高亮效果 */
		-webkit-tap-highlight-color: transparent;
		-webkit-touch-callout: none;
		-webkit-user-select: none;
		user-select: none;

		&:active {
			opacity: 0.7;
		}

		.avatar-img {
			width: 80rpx;
			height: 80rpx;
			border-radius: 50%;
		}

		.baby-name-section {
			display: flex;
			align-items: center;
			gap: 8rpx;

			.baby-name {
				font-size: 28rpx;
				color: #1d1e25;
				font-weight: 500;
			}

			.dropdown-icon {
				width: 18rpx;
				height: 12rpx;
			}
		}
	}

	.time-section {
		display: flex;
		align-items: center;

		.time-label {
			font-size: 28rpx;
			color: #6f6d67;
			margin-right: 15rpx;
		}

		.time-display {
			display: flex;
			align-items: center;
			// cursor: pointer;
			/* 移除点击高亮效果 */
			-webkit-tap-highlight-color: transparent;
			-webkit-touch-callout: none;
			-webkit-user-select: none;
			user-select: none;
		}

		.time-value {
			font-size: 28rpx;
			color: #1d1e25;
			margin-right: 5rpx;
			font-weight: bold;
		}

		.edit-icon {
			width: 61rpx;
			height: 61rpx;
			margin-top: 10rpx;
		}
	}
}

/* ===== 喂养记录链接 ===== */
.feeding-records {
	position: relative;
	// margin-top: 270rpx;
	left: 0;
	right: 0;
	display: flex;
	align-items: center;
	justify-content: flex-end;
	padding: 0rpx 30rpx 20rpx 30rpx;
	background: #FFF8F1;
	/* 移除点击高亮效果 */
	-webkit-tap-highlight-color: transparent;
	-webkit-touch-callout: none;
	-webkit-user-select: none;
	user-select: none;

	.records-link {
		font-size: 28rpx;
		color: #b27c1e;
		margin-right: 5rpx;
	}

	.arrow-right {
		width: 11rpx;
		height: 19rpx;
	}
}



/* ===== 喂养类型选择 ===== */
.feeding-types {
	position: relative;
	// margin-top: 320rpx;
	left: 0;
	right: 0;
	display: flex;
	background-color: #FFF8F1;
	justify-content: space-between;
	padding: 0rpx 30rpx;
	gap: 15rpx;

	.type-item {
		flex: 1;
		display: flex;
		flex-direction: column;
		align-items: center;
		gap: 8rpx;
		padding: 15rpx 10rpx;
		border-radius: 12rpx;
		background: transparent;
		transition: all 0.3s ease;
		/* 移除点击高亮效果 */
		-webkit-tap-highlight-color: transparent;
		-webkit-touch-callout: none;
		-webkit-user-select: none;
		user-select: none;

		.icon-bg {
			width: 228rpx;
			height: 144rpx;

			position: absolute;
		}

		.type-icon-wrapper {
			position: relative;
			width: 80rpx;
			height: 80rpx;
			display: flex;
			align-items: center;
			justify-content: center;



			.type-icon {
				width: 48rpx;
				height: 48rpx;
				position: relative;
			}
		}

		.type-label {
			font-size: 26rpx;
			color: #6f6d67;
			font-weight: 500;
			z-index: 2;
		}

		&.active {
			.type-label {
				color: #1d1e25;
				font-weight: 800;
			}
		}
	}
}

/* ===== 温馨提示 ===== */
.warm-tip {
	position: relative;
	// margin-top: 20rpx;
	left: 0;
	right: 0;
	text-align: center;
	padding: 20rpx 30rpx;
	z-index: 2;

	text {
		font-size: 24rpx;
		color: #000;
	}
}

/* ===== 表单区域 ===== */
.form-section {
	position: absolute;
	top: 80rpx;
	left: 0;
	right: 0;
	padding: 30rpx;
	// margin-top: 30rpx;
	background-color: #fff;
	// height: 300rpx;
	z-index: 2;
}

/* ===== 母乳亲喂表单 ===== */
.breastfeeding-form {

	.duration-controls {
		display: flex;
		justify-content: space-around;
		gap: 40rpx;
		padding: 30rpx;
		margin-top: 30rpx;

		.duration-item {
			display: flex;
			flex-direction: column;
			align-items: center;
			gap: 20rpx;
			position: relative;

			.duration-circle {
				width: 278rpx;
				height: 278rpx;
				position: relative;
				display: flex;
				align-items: center;
				justify-content: center;

				.circle-bg {
					position: absolute;
					width: 100%;
					height: 100%;
				}

				.circle-content {
					position: relative;
					display: flex;
					flex-direction: column;
					align-items: center;
					justify-content: center;

					.duration-number {
						font-size: 48rpx;
						color: #333;
						font-weight: bold;
					}

					.duration-unit {
						font-size: 24rpx;
						color: #666;
					}
				}
			}

			.duration-buttons {
				position: absolute;
				top: 0;
				left: 0;
				right: 0;
				bottom: 0;
				display: flex;
				justify-content: space-between;
				align-items: center;
				pointer-events: none;

				.btn-minus,
				.btn-plus {
					width: 78rpx;
					height: 180rpx;
					margin-top: -45rpx;
					pointer-events: auto;
					/* 移除点击高亮效果 */
					-webkit-tap-highlight-color: transparent;
					-webkit-touch-callout: none;
					-webkit-user-select: none;
					user-select: none;

					&.disabled {
						pointer-events: none;
					}
				}
			}

			.duration-label {
				font-size: 24rpx;
				color: #333;
			}
		}
	}
}

/* ===== 母乳瓶喂/奶粉喂养表单 ===== */
.bottle-form {
	.bottle-graphic {
		width: 100%;
		height: 574rpx;
		margin-top: -90rpx;

		.amount-bubble {
			position: absolute;
			left: 50rpx;
			top: 200rpx;
			text-align: center;
			width: 200rpx;
			height: 120rpx;
			display: flex;
			flex-direction: column;
			align-items: center;
			justify-content: center;

			.bubble-bg {
				position: absolute;
				top: 0;
				left: 0;
				width: 100%;
				height: 100%;
				z-index: -1;
			}

			.bubble-label {
				display: block;
				font-size: 24rpx;
				color: #333;
				margin-bottom: 10rpx;
				position: relative;
				z-index: 1;
			}

			.bubble-value {
				display: block;
				font-size: 36rpx;
				color: #333;
				font-weight: bold;
				position: relative;
				z-index: 1;
			}
		}

		.bottle-container {
			position: absolute;
			left: 50%;
			transform: translateX(-50%);
			width: 408rpx;
			height: 574rpx;
			display: flex;
			align-items: center;
			justify-content: center;

			.bottle-image {
				width: 408rpx;
				height: 574rpx;
				position: relative;
				z-index: 1;
			}

			.amount-picker {
				margin-top: 40rpx;
				position: absolute;
				left: 50%;
				top: 50%;
				transform: translate(-50%, -50%);
				width: 180rpx;
				height: 300rpx;
				z-index: 2;
				mask: none;
				-webkit-mask: none;

				:deep(.amount-picker::before) {
					content: none;
				}

				:deep(.amount-picker::after) {
					content: none;
				}


				.picker-item {
					height: 60rpx;
					line-height: 60rpx;
					text-align: center;
					font-size: 36rpx;
					color: #b27c1e;
					font-weight: normal;
					transition: all 0.3s ease;
					opacity: 0.6;
					transform: scale(0.9);
				}

				.picker-item.active {
					opacity: 1;
					transform: scale(1);
					font-weight: bold;
					color: #b27c1e;
					font-size: 50rpx;
				}
			}
		}

	}
}

/* ===== 辅食表单 ===== */
.food-form {
	margin-top: -80rpx;

	.selected-items {
		background: white;
		padding: 20rpx;
		border-radius: 20rpx;
		margin-bottom: 30rpx;

		text {
			font-size: 28rpx;
			color: #333;
			font-weight: bold;
		}
	}

	.divider {
		height: 1rpx;
		background: #E0E0E0;
		margin: 20rpx 0;
	}

	.food-categories {
		display: flex;
		justify-content: space-between;
		align-items: center;
		margin-bottom: 20rpx;
		padding: 0 20rpx;

		.category-title {
			font-size: 28rpx;
			color: #1d1e25;
			font-weight: bold;
		}

		.category-actions {
			display: flex;
			gap: 20rpx;

			.complete-btn {
				font-size: 26rpx;
				color: #6f6d67;
				// cursor: pointer;
				transition: all 0.3s ease;

				&.disabled {
					opacity: 0.5;
					cursor: not-allowed;
					pointer-events: none;
				}
			}

			.delete-btn {
				display: flex;
				align-items: center;
				gap: 8rpx;
				font-size: 26rpx;
				color: #6f6d67;
				// cursor: pointer;

				.delete-icon {
					width: 24rpx;
					height: 24rpx;
				}
			}
		}
	}

	.category-list {
		max-height: 550rpx;
		overflow-y: auto;
		padding-right: 10rpx;

		.category-item {
			display: flex;
			align-items: flex-start;
			// gap: 20rpx;
			margin-bottom: 20rpx;
			flex-wrap: wrap;
			padding: 0 20rpx;
			position: relative;

			.category-name {
				font-size: 26rpx;
				color: #1d1e25;
				min-width: 60rpx;
				margin-top: 8rpx;
				flex-shrink: 0;
			}

			.add-section {
				display: flex;
				flex-direction: column;
				align-items: center;
				flex-shrink: 0;
				margin-right: 20rpx;
			}

			.add-btn {
				width: 80rpx;
				height: 60rpx;
				transition: all 0.3s ease;
				flex-shrink: 0;

				&.disabled {
					opacity: 0.5;
					cursor: not-allowed;
					pointer-events: none;
				}
			}

			.limit-tip {
				font-size: 20rpx;
				color: #999;
				margin-top: 4rpx;
				text-align: center;
				white-space: nowrap;
			}

			.selected-tags {
				display: flex;
				flex-wrap: wrap;
				gap: 10rpx;
				flex: 1;
				align-items: flex-start;
				padding-right: 60rpx;

				.tag-item {
					display: inline-flex;
					align-items: center;
					background: #f6f8fa;
					color: #1d1e25;
					// padding: 8rpx 16rpx;
					padding-left: 32rpx;
					border-radius: 30rpx;
					height: 60rpx;
					font-size: 28rpx;
					// cursor: pointer;
					position: relative;
					transition: all 0.3s ease;
					border: none;
					/* 为删除按钮预留空间 */
					padding-right: 36rpx;
					flex-shrink: 0;

					&.active {
						background: #fef7f2;
						color: #dcb477;
						border: 1rpx solid #ffe9c2;

						.tag {
							color: #dcb477;
						}
					}

					// 未选中的标签样式
					&:not(.active) {
						background: #f6f8fa;
						border: none;
						color: #1d1e25;

						.tag {
							color: #1d1e25;
						}
					}

					&.hidden {
						display: none;
					}

					.tag {
						font-size: 28rpx;
						text-align: center;
						transition: all 0.3s ease;
						/* 文字不被截断，根据内容自适应宽度 */
						white-space: nowrap;
					}

					.delete-x {
						position: absolute;
						right: -5rpx;
						top: -5rpx;
						width: 28rpx;
						height: 28rpx;
						// cursor: pointer;
						z-index: 1;
					}
				}


			}

			.expand-btn {
				display: flex;
				align-items: center;
				justify-content: center;
				width: 40rpx;
				height: 40rpx;
				// cursor: pointer;
				margin-left: 10rpx;
				flex-shrink: 0;
				align-self: flex-start;
				position: absolute;
				right: 20rpx;
				top: 0;
				z-index: 10;

				.expand-icon {
					width: 24rpx;
					height: 24rpx;
				}
			}
		}
	}
}

/* ===== 添加辅食弹窗 ===== */
.add-food-popup-container {
	z-index: 10003 !important;
}

.add-food-popup {
	background: white;
	border-radius: 40rpx;
	width: 654rpx;
	min-height: 414rpx;
	box-sizing: border-box;
	display: flex;
	flex-direction: column;

	.popup-header {
		text-align: left;
		padding: 40rpx 40rpx 0 40rpx;
		margin-bottom: 30rpx;

		.popup-title {
			margin-left: 0rpx;
			font-size: 36rpx;
			color: #1d1e25;
			font-weight: bold;
		}
	}

	.popup-content2 {
		flex: 1;
		padding: 0 40rpx;
		box-sizing: border-box;
		width: 100%;

		.input-container {
			position: relative;
			margin-bottom: 40rpx;
			width: 100%;
			box-sizing: border-box;

			.food-input {
				width: 100%;
				height: 88rpx;
				border: 2rpx solid #e5e5e5;
				border-radius: 12rpx;
				padding: 0 20rpx;
				font-size: 28rpx;
				color: #333;
				box-sizing: border-box;
				background: #fff;
			}

			.char-count {
				position: absolute;
				right: 20rpx;
				bottom: 20rpx;
				font-size: 24rpx;
				color: #999;
			}
		}
	}

	.popup-buttons {
		display: flex;
		justify-content: space-between;
		padding: 0 40rpx 40rpx;
		margin-top: auto;

		.cancel-btn,
		.confirm-btn {
			width: 284rpx;
			height: 94rpx;
			transition: opacity 0.3s;

			&.disabled {
				opacity: 0.5;
			}
		}
	}
}



/* ===== 记录成功弹窗 ===== */
.success-popup {
	position: relative;
	width: 654rpx;
	height: 436rpx;
	display: flex;
	flex-direction: column;
	align-items: center;
	justify-content: center;
	// background: #ffffff;
	// border-radius: 20rpx;

	.success-bg {
		position: absolute;
		top: 0;
		left: 0;
		width: 100%;
		height: 100%;
		z-index: 1;
	}

	.success-content {
		margin-top: 190rpx;
		position: relative;
		z-index: 2;
		display: flex;
		flex-direction: column;
		align-items: center;
		justify-content: center;
		width: 100%;
		height: 100%;
		pointer-events: auto;

		.success-title {
			font-size: 36rpx;
			color: #1d1e25;
			font-weight: bold;
			margin-bottom: 60rpx;
		}

		.success-buttons {
			display: flex;
			gap: 40rpx;
			align-items: center;

			.success-btn {
				width: 284rpx;
				height: 94rpx;
				pointer-events: auto;
			}

		}
	}
}

/* ===== 记录方式选择 ===== */
.record-methods1 {
	position: absolute;
	top: 570rpx;
	left: 0;
	right: 0;
	display: flex;
	justify-content: center;
	align-items: center;
	width: 100%;
	height: 180rpx;

	.tab-image {
		width: 468rpx;
		height: 180rpx;
	}

	.click-area {
		position: absolute;
		top: 0;
		height: 100%;
		width: 156rpx;
	}

	.left {
		left: calc(50% - 234rpx);
	}

	.center {
		left: calc(50% - 78rpx);
	}

	.right {
		left: calc(50% + 78rpx);
	}
}

/* ===== 记录方式选择 - 母乳瓶喂/奶粉喂养 ===== */
.record-methods2 {
	position: absolute;
	top: 570rpx;
	left: 0;
	right: 0;
	display: flex;
	justify-content: center;
	align-items: center;
	width: 100%;
	z-index: 2;
	height: 180rpx;

	.tab-image {
		width: 304rpx;
		height: 180rpx;
	}

	.click-area {
		position: absolute;
		top: 0;
		height: 100%;
		width: 152rpx;
		display: flex;
		flex-direction: column;
		align-items: center;
		justify-content: center;
		gap: 8rpx;
	}

	.left {
		left: calc(50% - 152rpx);
	}

	.right {
		left: calc(50% + 0rpx);
	}

	.method-icon {
		width: 40rpx;
		height: 40rpx;
	}

	.method-text {
		font-size: 24rpx;
		color: #999;
		transition: color 0.3s ease;

		&.active {
			color: #333;
			font-weight: bold;
		}
	}
}

/* ===== 语音控制区域 ===== */
.voice-controls {
	position: absolute;
	left: 0;
	right: 0;
	top: 30rpx;
	padding: 30rpx;
	display: flex;
	flex-direction: column;
	align-items: center;

	.voice-tip {
		text-align: center;

		.tip-text {
			font-size: 28rpx;
			color: #6f6d67;
			font-weight: 500;
		}
	}

	.voice-example {
		text-align: center;

		.example-text {
			font-size: 38rpx;
			color: #1d1e25;
			font-weight: bolder;
		}
	}

	.voice-microphone {
		display: flex;
		align-items: center;
		justify-content: center;
		width: 278rpx;
		height: 278rpx;
		margin-top: 25rpx;

		.microphone-icon {
			width: 278rpx;
			height: 278rpx;

			&[src*="icon_luyining.gif"] {
				width: 351rpx;
				height: 339rpx;
			}
		}
	}

	.voice-click-tip {
		text-align: center;
		margin-top: 20rpx;

		.click-text {
			font-size: 26rpx;
			color: #6f6d67;
		}
	}
}

/* ===== 计时器控制区域 ===== */
.timer-controls {
	position: absolute;
	left: 0;
	right: 0;
	top: 30rpx;
	padding: 30rpx;
	display: flex;
	flex-direction: column;
	align-items: center;

	/* 总时长显示 */
	.total-duration {
		display: flex;
		flex-direction: column;
		align-items: center;
		gap: 10rpx;

		.total-duration-label {
			font-size: 28rpx;
			color: #6f6d67;
		}

		.total-duration-value {
			font-size: 48rpx;
			color: #1d1e25;
			font-weight: bold;
		}
	}



	/* 圆形计时器 */
	.circular-timers {
		display: flex;
		justify-content: space-around;
		align-items: center;
		width: 100%;

		.timer-circle {
			display: flex;
			flex-direction: column;
			align-items: center;
			gap: 20rpx;
			position: relative;

			.timer-icon {
				width: 278rpx;
				height: 278rpx;
			}

			.timer-time {
				font-size: 32rpx;
				color: #1d1e25;
				margin-top: -100rpx;

			}

			.timer-label {
				font-size: 24rpx;
				color: #6f6d67;
				margin-top: 45rpx;
			}
		}
	}
}




/* ===== 下半部分背景区域 ===== */
.bottom-section {
	position: relative;
	left: 0;
	right: 0;
	width: 100%;
	height: 1008rpx;
	z-index: 1;
	background-color: #fff;

	.bottom-bg {
		position: absolute;
		top: 0;
		left: 0;
		width: 750rpx;
		height: 1008rpx;
		z-index: 0;
	}



}


// uni-datetime-picker样式覆盖（与feedingRecord页面保持一致）
::v-deep .uni-datetime-picker--btn {
	background-color: #D4A574 !important;
}

::v-deep .uni-calendar-item--checked {
	background-color: #D4A574 !important;
}

::v-deep .uni-datetime-picker-btn-text {
	color: #D4A574 !important;
}

/* 全局时间选择器层级修复 */
::v-deep .uni-datetime-picker {
	z-index: 999999 !important;
}

::v-deep .uni-datetime-picker__mask {
	z-index: 999998 !important;
	position: fixed !important;
	top: 0 !important;
	left: 0 !important;
	right: 0 !important;
	bottom: 0 !important;
}

::v-deep .uni-datetime-picker__popup {
	z-index: 999999 !important;
	position: fixed !important;
	bottom: 218rpx !important;
	left: 50% !important;
	transform: translateX(-50%) !important;
	border-radius: 8px !important;
	padding: 30px !important;
	width: 270px !important;
	background-color: #fff !important;
}

::v-deep .uni-datetime-picker__content {
	z-index: 999999 !important;
	position: relative !important;
}

/* 确保时间选择器内部元素也有正确的层级 */
::v-deep .uni-datetime-picker__container {
	z-index: 999999 !important;
	position: relative !important;
}

::v-deep .uni-datetime-picker__timebox {
	z-index: 999999 !important;
	position: relative !important;
}

::v-deep .uni-datetime-picker__date {
	z-index: 999999 !important;
	position: relative !important;
}

::v-deep .uni-datetime-picker__time {
	z-index: 999999 !important;
	position: relative !important;
}

/* 修复时间选择器文本显示位置 */
::v-deep .uni-datetime-picker-text {
	position: relative !important;
	display: inline-block !important;
	line-height: 50px !important;
	font-size: 14px !important;
	text-align: center !important;
	vertical-align: middle !important;
}

/* 修复时间选择器内部布局 */
::v-deep .uni-datetime-picker__container-box {
	position: relative !important;
	display: flex !important;
	align-items: center !important;
	justify-content: center !important;
	margin-top: 40px !important;
}

::v-deep .uni-datetime-picker-item {
	display: flex !important;
	align-items: center !important;
	justify-content: center !important;
	height: 50px !important;
}

::v-deep .uni-datetime-picker-view {
	height: 150px !important;
}

/* ===== 语音识别结果弹窗 ===== */
.popup-mask {
	position: fixed;
	top: 0;
	left: 0;
	right: 0;
	bottom: 0;
	background: rgba(0, 0, 0, 0.5);
	z-index: 1000;
	display: flex;
	align-items: flex-end;
	justify-content: center;
	overflow: hidden;
	touch-action: none;
	/* 为固定按钮留出空间 */
}



.popup-content {
	background: #f6f8fa;
	width: 750rpx;
	max-height: 80vh;
	border-radius: 20rpx 20rpx 0 0;
	padding: 40rpx 30rpx;
	animation: slideUp 0.3s ease-out;
	// overflow-y: auto;
	z-index: 1001;
	display: flex;
	flex-direction: column;
	/* 确保内容区域在按钮之上 */
	/* 时间选择器z-index为10002，确保显示在弹窗上面 */
	position: relative;

	.popup-header {
		display: flex;
		justify-content: space-between;
		align-items: center;
		margin-bottom: 20rpx;
	}

	.popup-title {
		font-size: 36rpx;
		font-weight: 600;
		color: #333;
		text-align: left;
	}

	.popup-close {
		width: 60rpx;
		height: 60rpx;
		display: flex;
		align-items: center;
		justify-content: center;
		cursor: pointer;
	}

	.close-text {
		font-size: 40rpx;
		color: #999;
		font-weight: bold;
	}

	.form-container {
		display: flex;
		flex-direction: column;
		align-items: center;
		gap: 40rpx;
		flex: 1;
		justify-content: flex-start;
		padding-bottom: 40rpx;
		/* 为底部按钮留出空间 */
	}

	.recognition-status {
		margin-bottom: 30rpx;

		.status-text {
			font-size: 24rpx;
			color: #666;
			background: #f0f0f0;
			padding: 8rpx 16rpx;
			border-radius: 20rpx;
		}
	}

	.form-item {
		width: 687rpx;
		height: 112rpx;
		position: relative;

		.voice-time-picker {
			position: absolute;
			width: 100%;
			height: 100%;
		}

		.label {
			position: absolute;
			left: 24rpx;
			top: 50%;
			transform: translateY(-50%);
			font-size: 28rpx;
			color: #333;
			z-index: 2;
			pointer-events: none;
			width: 120rpx;
		}

		.input-container {
			position: relative;
			width: 100%;
			height: 100%;
		}

		.picker,
		.input {
			width: 100%;
			height: 112rpx;
			padding: 0rpx 24rpx 0rpx 120rpx;
			background: #ffffff;
			border-radius: 12rpx;
			font-size: 28rpx;
			text-align: right;
			color: #333;
			pointer-events: none;
			border: 1rpx solid #e9ecef;
			box-sizing: border-box;

			&.disabled {
				background: #f5f5f5;
				color: #999;
				cursor: not-allowed;
			}
		}

		.picker {
			display: flex;
			align-items: center;
			justify-content: flex-end;
			height: 100%;
		}
	}

	.popup-buttons {
		display: flex;
		gap: 20rpx;
		justify-content: center;
		margin-top: auto;
		padding-top: 40rpx;
		z-index: 999;
		/* 时间选择器z-index为10002，确保显示在按钮上面 */

		.cancel-btn,
		.confirm-btn {
			width: 331rpx;
			height: 94rpx;
			flex: none;
			transition: transform 0.1s ease-out;

			&:active {
				transform: scale(0.95);
			}
		}
	}

	/* 确保语音识别时间选择器显示在最上层 */
	:deep(.voice-time-picker .uni-datetime-picker) {
		z-index: 999999 !important;
		width: 600rpx !important;
		max-width: 90vw !important;
		background: #ffffff !important;
		border-radius: 16rpx !important;
		box-shadow: 0 8rpx 32rpx rgba(0, 0, 0, 0.2) !important;
	}

	:deep(.voice-time-picker .uni-datetime-picker__container) {
		z-index: 999999 !important;
		width: 100% !important;
		background: #ffffff !important;
		border-radius: 16rpx !important;
	}

	/* 确保主时间选择器也能突破堆叠上下文 */
	:deep(.time-section .uni-datetime-picker) {
		z-index: 999999 !important;
		width: 600rpx !important;
		max-width: 90vw !important;
		background: #ffffff !important;
		border-radius: 16rpx !important;
		box-shadow: 0 8rpx 32rpx rgba(0, 0, 0, 0.2) !important;
	}

	:deep(.time-section .uni-datetime-picker__container) {
		z-index: 999999 !important;
		width: 100% !important;
		background: #ffffff !important;
		border-radius: 16rpx !important;
	}

	/* 修复时间选择器内部日期和时间重叠问题 */
	:deep(.voice-time-picker .uni-datetime-picker__container .uni-datetime-picker__timebox) {
		display: flex !important;
		flex-direction: column !important;
		gap: 20rpx !important;
		padding: 20rpx !important;
	}

	:deep(.voice-time-picker .uni-datetime-picker__container .uni-datetime-picker__timebox .uni-datetime-picker__time) {
		margin-top: 20rpx !important;
		border-top: 1rpx solid #e5e5e5 !important;
		padding-top: 20rpx !important;
	}

	/* 确保时间选择器内部元素不重叠 */
	:deep(.voice-time-picker .uni-datetime-picker__container .uni-datetime-picker__date) {
		margin-bottom: 20rpx !important;
	}

	:deep(.voice-time-picker .uni-datetime-picker__container .uni-datetime-picker__time) {
		margin-top: 20rpx !important;
		padding-top: 20rpx !important;
		border-top: 1rpx solid #e5e5e5 !important;
	}
}

@keyframes slideUp {
	from {
		transform: translateY(100%);
	}

	to {
		transform: translateY(0);
	}
}

// 语音模式提示样式
.voice-mode-tip {
	position: absolute;
	top: -60rpx;
	left: 50%;
	transform: translateX(-50%);
	background: rgba(0, 0, 0, 0.8);
	color: white;
	padding: 10rpx 20rpx;
	border-radius: 8rpx;
	font-size: 24rpx;
	white-space: nowrap;
	z-index: 10;
}

.food-input::placeholder {
	color: #bbb;
	line-height: 70rpx;
	/* 或 110rpx，和上面保持一致 */
}

.uni-date {
	z-index: 999999 !important;
}
</style>