englishread-front/subPages/home/book.vue

<template>
  <view class="book-container">
    <!-- 自定义顶部导航栏 -->
    <uv-status-bar></uv-status-bar>
    <view class="custom-navbar" :class="{ 'navbar-hidden': !showNavbar }">
      <uv-status-bar></uv-status-bar>
      <view class="navbar-content">
        <view class="navbar-left" @click="goBack">
          <uv-icon name="arrow-left" size="20" color="#262626"></uv-icon>
        </view>
        <view class="navbar-title">{{ currentPageTitle }}</view>

      </view>
    </view>

    <!-- Swiper内容区域 -->
    <swiper 
      class="content-swiper" 
      :current="currentPage - 1"
      @change="onSwiperChange"
    >
      <swiper-item 
        v-for="(page, index) in bookPages" 
        :key="index"
        class="swiper-item"
      >
        <view class="content-area" @click="toggleNavbar">
        
          <!-- 会员限制页面 -->
          <view v-if="!isMember && pagePay[index] === 'Y'" class="member-content" >
            <text class="member-title">{{ pageTitles[index] }}</text>
            <view class="member-button" @click.stop="unlockBook">
              <text class="member-button-text">升级会员解锁</text>
            </view>
          </view>

          <!-- 图片卡片页面 -->
          <view  class="card-content" v-else-if="pageTypes[index] === '1'">
            <view class="card-line">
              <image :src="configParamContent('highlight_icon')" class="card-line-image" mode="aspectFill" />
              <text class="card-line-text">划线重点</text>
            </view>
            <view v-for="(item, itemIndex) in page"  :key="itemIndex">
              <image class="card-image" v-if="item && item.type === 'image'" :src="item.imageUrl" mode="aspectFill"></image>
              <view class="english-text-container clickable-text" v-else-if="item && item.type === 'text' && item.language === 'en' && item.content" @click.stop="handleTextClick(item.content, item, index)">
                <text 
                  v-for="(token, tokenIndex) in splitEnglishSentence(item.content)" 
                  :key="tokenIndex"
                  
                  :class="['english-token', { 'clickable-word': token.isWord && findWordDefinition(token.text) }]"
                  @tap="token.isWord && findWordDefinition(token.text) ? handleWordClick(token.text) : null"
                  user-select
                >{{ token.text }}</text>
              </view>
              <view v-else-if="item && item.type === 'text' && item.language === 'zh' && item.content" @click.stop="handleTextClick(item.content, item, index)">
                <text class="chinese-text clickable-text" user-select>{{ item.content }}</text>
              </view>
            </view>
          </view>

          <view v-else>  
            <view v-for="(item, itemIndex) in page" :key="itemIndex">
              <!-- 文本页面 -->
              <view v-if="item && item.type === 'text' && item.content" class="text-content" >
                <view :class="{ 'text-highlight': isTextHighlighted(page, itemIndex) }" @click.stop="handleTextClick(item.content, item, index)">
                  <text 
                  class="content-text clickable-text" 
                  user-select
                  >
                  {{ item.content }}
                  </text>
                </view>
              </view>

              <!-- 文本页面 -->
              <view v-else-if="item.type === 'image'" class="image-container">
                <image class="content-image" :src="item.imageUrl" mode="aspectFill"></image>
              </view>

              <!-- 视频页面 -->
              <view v-else-if="item.type === 'video'" class="video-content">
                <video :src="item.video" class="video-player" controls :poster="item.poster"></video>
              </view>

              
            </view>
          </view>
        </view>
      </swiper-item>
    </swiper>

    
    <!-- 自定义底部控制栏 -->
    <view class="custom-tabbar" :class="{ 'tabbar-hidden': !showNavbar }">
      <!-- 音频控制栏组件 -->
      <AudioControls
        :current-page="currentPage"
        :course-id="courseId"
        :voice-id="voiceId"
        :book-pages="bookPages"
        :is-text-page="isTextPage"
        :is-member="isMember"
        :current-page-requires-member="currentPageRequiresMember"
        :page-pay="pagePay"
        @previous-page="previousPage"
        @next-page="nextPage"
        @audio-state-change="onAudioStateChange"
        @highlight-change="onHighlightChange"
        @voice-change-complete="onVoiceChangeComplete"
        @voice-change-error="onVoiceChangeError"
        ref="audioControls"
      />
    
      
      <view style="background-color: #fff;position: relative;z-index: 100" >
        <view class="tabbar-content">
          <view class="tabbar-left">
            <view class="tab-button" @click="toggleCoursePopup">
              <image src="/static/课程图标.png" class="tab-icon" />
              <text class="tab-text">课程</text>
            </view>
            <view class="tab-button" @click="toggleSound">
              <image src="/static/音色切换图标.png" class="tab-icon" />
              <text class="tab-text">音色切换</text>
            </view>
          </view>
          
          <view class="tabbar-right">
            <view class="page-controls">
              <view class="page-numbers">
                <view 
                  v-for="(page, index) in bookPages" 
                  :key="index"
                  class="page-number"
                  :class="{ 'active': (index + 1) === currentPage }"
                  @click="goToPage(index + 1)"
                >
                  {{ index + 1 }}
                </view>
              </view>
            </view>
          </view>
        </view>
        <uv-safe-bottom></uv-safe-bottom>
      </view>
    </view>
    
    <!-- 课程选择弹出窗 -->
    <uv-popup 
      mode="bottom" 
      ref="coursePopup"
      round="32rpx"
      bg-color="#f8f8f8"
    >
      <view class="course-popup">
        <view class="popup-header">
          <view>
            <uv-icon name="arrow-down" color="black" size="20"></uv-icon>
          </view>
          <view class="popup-title">课程</view>
          <view class="popup-title" @click="toggleSort">
            倒序
          </view>
        </view>
        <view class="course-list">
          <view 
            v-for="(course, index) in displayCourseList" 
            :key="course.id"
            class="course-item"
            :class="{ 'active': course.id === currentCourse }"
            @click="selectCourse(course.id)"
          >
            <view class="course-number " :class="{ 'highlight': course.id === currentCourse }">{{ String(course.index).padStart(2, '0') }}</view>
            <view class="course-content">
              <view class="course-english" :class="{ 'highlight': course.id === currentCourse }">{{ course.english }}</view>
              <view class="course-chinese" :class="{ 'highlight': course.id === currentCourse }">{{ course.chinese }}</view>
            </view>
          </view>
        </view>
      </view>
    </uv-popup>
    
    <!-- 释义弹出窗 -->
    <uv-popup 
      mode="bottom" 
      
      ref="meaningPopup"
      round="32rpx"
      bg-color="#FFFFFF"
      :overlay="true"
    >
      <view class="meaning-popup" v-if="currentWordMeaning">
        <view class="meaning-header">
          <view class="close-btn" @click="closeMeaningPopup">
            <text class="close-text">关闭</text>
          </view>
          <view class="meaning-title">释义</view>
          <view style="width: 80rpx;"></view>
        </view>
        
        <view class="meaning-content">
          <image v-if="currentWordMeaning.imag" class="meaning-image" :src="currentWordMeaning.image" mode="aspectFill"></image>
          
          <view class="word-info">
            <view class="word-main">
              <text class="word-text">{{ currentWordMeaning.word }}</text>
            </view>
            <view class="phonetic-container">
                <uv-icon 
                  name="volume-fill" 
                  size="16" 
                  color="#007AFF" 
                  class="speaker-icon"
                  @click="repeatWordAudio"
                ></uv-icon>
                <text class="phonetic-text">{{ currentWordMeaning.phonetic }}</text>
            </view>
            <view class="word-meaning">
              <text class="part-of-speech">{{ currentWordMeaning.partOfSpeech }}</text>
              <text class="meaning-text">{{ currentWordMeaning.meaning }}</text>
            </view>
          </view>
          
          <view class="knowledge-gain">
            <view class="knowledge-header">
              <image src="/static/知识收获图标.png" class="knowledge-icon" mode="aspectFill" />
              <text class="knowledge-title">知识收获</text>
            </view>
            <text class="knowledge-content">{{ currentWordMeaning.knowledgeGain }}</text>
          </view>
        </view>
      </view>
    </uv-popup>
  </view>
</template>

<script>
import AudioControls from './AudioControls.vue'

export default {
  components: {
    AudioControls
  },
  data() {
    return {
      isMember: false,
      memberId: '',
      voiceId: null,
      courseId: '',
      showNavbar: true,
      currentPage: 1,
      currentCourse: 1, // 当前课程索引
      currentWordMeaning: null, // 当前显示的单词释义
      isReversed: false, // 是否倒序显示
      // 文本高亮相关
      currentHighlightIndex: -1, // 当前高亮的文本索引
      wordAudioCache: {}, // 單詞語音緩存
      currentWordAudio: null, // 當前播放的單詞音頻實例
      
      // 音频状态相关
      isAudioLoading: false, // 音频是否正在加载
      hasAudioData: false, // 是否有音频数据
      audioLoadFailed: false, // 音频加载是否失败
      courseIdList: [],
      bookTitle: '',
      courseList: [
     
      ],

      // 二维数组 代表每个页面
      bookPages: [
        
      ],
      // 存储每个页面的标题
      pageTitles: [],
      // 存储每个页面的type信息
      pageTypes: [],
      // 存储每个页面的单词释义数据
      pageWords: [],
      // 存储每个页面的付费状态
      pagePay: [],
    }
  },
  computed: {
    displayCourseList() {
      return this.isReversed ? [...this.courseList].reverse() : this.courseList;
    },
    // 判断当前页面是否为文字类型
    isTextPage() {
      // 如果是卡片页面（type为'1'），不显示音频控制栏
      if (this.currentPageType === '1') {
        return false;
      }
      
      const currentPageData = this.bookPages[this.currentPage - 1];
      // currentPageData是一个数组 其中的一个元素的type是text就会返回true
      return currentPageData && currentPageData.some(item => item.type === 'text');
    },


    // 动态页面标题
    currentPageTitle() {
      return this.pageTitles[this.currentPage - 1] || this.bookTitle;
    },
    
    // 当前页面类型
    currentPageType() {
      return this.pageTypes[this.currentPage - 1] || '';
    },
    
    // 当前页面的单词释义数据
    currentPageWords() {
      return this.pageWords[this.currentPage - 1] || [];
    },
    
    // 当前页面是否需要会员
    currentPageRequiresMember() {
      return this.pagePay[this.currentPage - 1] === 'Y';
    }
  },
  methods: {
    // 獲取用戶會員信息 判斷是否和傳參傳過來的會員id相同
    async getMemberInfo(){
      const memberRes = await this.$api.member.getUserMemberInfo()
      if (memberRes.code === 200) {
        this.isMember = memberRes.result.map(item => item.memberId).includes(this.memberId)
        console.log('isMember:', this.isMember);
      }
      
    },
    
    // 处理AudioControls组件的事件
    onAudioStateChange(audioState) {
      // 更新高亮状态
      this.currentHighlightIndex = audioState.currentHighlightIndex;
      
      // 更新音频加载状态（用于控制UI显示）
      if (audioState.hasOwnProperty('isLoading')) {
        this.isAudioLoading = audioState.isLoading;
      }
      
      // 更新音频数据状态
      if (audioState.hasOwnProperty('hasAudioData')) {
        this.hasAudioData = audioState.hasAudioData;
      }
      
      // 更新音频加载失败状态
      if (audioState.hasOwnProperty('audioLoadFailed')) {
        this.audioLoadFailed = audioState.audioLoadFailed;
      }
    },
    
    // 处理音色切换完成事件
    onVoiceChangeComplete(data) {
      console.log('音色切换完成:', data);
      // 可以在这里添加一些UI反馈，比如显示切换成功的提示
      if (data.hasAudioData) {
        console.log('新音色当前页面音频已加载完成');
      } else {
        console.log('当前页面没有音频数据');
      }
      
      // 如果启用了预加载所有页面
      if (data.preloadAllPages) {
        console.log('正在后台预加载所有页面的新音色音频...');
        // 可以显示一个提示，告诉用户正在后台加载
        uni.showToast({
          title: '正在加载新音色...',
          icon: 'loading',
          duration: 2000
        });
      }
    },
    
    // 处理音色切换错误事件
    onVoiceChangeError(error) {
      console.error('音色切换失败:', error);
      // 可以在这里显示错误提示给用户
      uni.showToast({
        title: '音色切换失败，请重试',
        icon: 'none',
        duration: 2000
      });
    },
    
    // 处理文本点击事件
    handleTextClick(textContent, item, pageIndex) {
      console.log('点击文本:', textContent);
      console.log('textContent类型:', typeof textContent);
      console.log('textContent是否为undefined:', textContent === undefined);
      console.log('完整item对象:', item);
      console.log('item.content:', item ? item.content : 'item为空');
      console.log('当前页面索引:', this.currentPage);
      console.log('点击的页面索引:', pageIndex);
      console.log('当前页面数据:', this.bookPages[this.currentPage - 1]);
      console.log('页面数据长度:', this.bookPages[this.currentPage - 1] ? this.bookPages[this.currentPage - 1].length : '页面不存在');
      
      // 检查是否点击的是当前页面
      if (pageIndex !== undefined && pageIndex !== this.currentPage - 1) {
        console.log('点击的不是当前页面，忽略点击事件');
        return;
      }
      
      // 验证参数有效性
      if (!item) {
        console.error('handleTextClick: item参数为空');
        uni.showToast({
          title: '数据错误，请刷新页面',
          icon: 'none'
        });
        return;
      }
      
      // 如果textContent为undefined，尝试从item中获取
      if (!textContent && item && item.content) {
        textContent = item.content;
        console.log('从item中获取到content:', textContent);
      }
      
      // 最终验证textContent
      if (!textContent || typeof textContent !== 'string' || textContent.trim() === '') {
        console.error('handleTextClick: 无效的文本内容', textContent);
        uni.showToast({
          title: '文本内容无效',
          icon: 'none'
        });
        return;
      }
      
      // 检查是否有音频控制组件的引用
      if (!this.$refs.audioControls) {
        console.log('音频控制组件未找到');
        uni.showToast({
          title: '音频控制组件未准备好',
          icon: 'none'
        });
        return;
      }
      
      // 检查当前页面是否为文本页面
      // 对于卡片页面（type为'1'），不显示错误提示，因为单词点击会单独处理
      if (!this.isTextPage) {
        // 如果是卡片页面，静默返回，不显示错误提示
        if (this.currentPageType === '1') {
          console.log('卡片页面的文本点击，单词播放由handleWordClick处理');
          return;
        }
        
        console.log('当前页面不是文本页面');
        uni.showToast({
          title: '当前页面不支持音频播放',
          icon: 'none'
        });
        return;
      }
      
      // 调用AudioControls组件的播放指定音频方法
      const success = this.$refs.audioControls.playSpecificAudio(textContent);
      
      if (success) {
        console.log('成功播放指定音频段落');
      } else {
        console.log('播放指定音频段落失败');
      }
    },
    
    onHighlightChange(highlightData) {
      // 兼容旧格式（直接传递索引）和新格式（传递对象）
      if (typeof highlightData === 'number') {
        // 旧格式：直接是索引
        this.currentHighlightIndex = highlightData;
      } else if (typeof highlightData === 'object' && highlightData !== null) {
        // 新格式：包含详细信息的对象
        this.currentHighlightIndex = highlightData.highlightIndex;
        
        // 可以在这里处理分段音频的额外信息
        if (highlightData.isSegmented) {
          console.log('分段音频高亮:', {
            highlightIndex: highlightData.highlightIndex,
            segmentIndex: highlightData.segmentIndex,
            startIndex: highlightData.startIndex,
            endIndex: highlightData.endIndex,
            currentText: highlightData.currentText
          });
        }
      } else {
        // 清除高亮
        this.currentHighlightIndex = -1;
      }
    },
    

    // 获取音色列表 拿第一个做默认的音色id
    async getVoiceList() {
      const voiceRes = await this.$api.music.list()
      if(voiceRes.code === 200){
        console.log('音色列表API返回:', voiceRes.result);
        console.log('第一个音色数据:', voiceRes.result[0]);
        this.voiceId = Number(voiceRes.result[0].voiceType)
        console.log('获取默认音色ID:', this.voiceId, '类型:', typeof this.voiceId);
      }
    },
    toggleNavbar() {
      this.showNavbar = !this.showNavbar
    },
    goBack() {
      uni.navigateBack()
    },
    toggleCoursePopup() {
      if (this.$refs.coursePopup) {
        this.$refs.coursePopup.open()
      }
      // console.log('123123123');
      
    },
    toggleSort() {
      this.isReversed = !this.isReversed
    },
    selectCourse(courseId) {
      this.currentCourse = courseId
      if (this.$refs.coursePopup) {
        this.$refs.coursePopup.close()
      }
      // 这里可以添加切换课程的逻辑
      // console.log('选择课程:', courseId)
      this.getCourseList(courseId)
    },
    showWordMeaning() {
        if (this.$refs.meaningPopup) {
          this.$refs.meaningPopup.open()
        }
    },
    closeMeaningPopup() {
      if (this.$refs.meaningPopup) {
        this.$refs.meaningPopup.close()
      }
      this.currentWordMeaning = null
    },
    
    // 将英文句子分割成单词数组
    splitEnglishSentence(sentence) {
      // 使用正则表达式分割句子，保留标点符号
      const tokens = sentence.match(/\b\w+\b|[^\w\s]/g) || [];
      return tokens.map((token, index) => ({
        text: token,
        index: index,
        isWord: /\b\w+\b/.test(token), // 判断是否为单词
        hasDefinition: false // 是否有释义，稍后会设置
      }));
    },
    
    // 查找单词释义
    findWordDefinition(word) {
      const currentPageWords = this.pageWords[this.currentPage - 1] || [];
      // 不区分大小写匹配
      return currentPageWords.find(wordData => 
        wordData.word.toLowerCase() === word.toLowerCase()
      );
    },
    
    async playWordAudio(word) {
      try {
        console.log('開始播放單詞語音:', word);

        // 停止當前播放的單詞語音
        if (this.currentWordAudio) {
          this.currentWordAudio.destroy();
          this.currentWordAudio = null;
        }
        
        // 調用語音轉換API
        console.log('playWordAudio - voiceId值:', this.voiceId, '类型:', typeof this.voiceId);
        const audioRes = await this.$api.music.textToVoice({
          text: word,
          voiceType: this.voiceId
        });

        console.log('單詞語音API響應:', audioRes);

        // 檢查響應並播放音頻
        if (audioRes && audioRes.result && audioRes.result.url) {
          // 新格式：使用返回的url字段
          const audioUrl = audioRes.result.url;
          
          // 創建並播放音頻
          const audio = uni.createInnerAudioContext();
          audio.src = audioUrl;
          
          audio.onPlay(() => {
            console.log('開始播放單詞語音:', word);
          });

          audio.onEnded(() => {
            console.log('單詞語音播放完成:', word);
            audio.destroy();
            if (this.currentWordAudio === audio) {
              this.currentWordAudio = null;
            }
          });

          audio.onError((error) => {
            console.error('單詞語音播放失敗:', error);
            audio.destroy();
            if (this.currentWordAudio === audio) {
              this.currentWordAudio = null;
            }
            uni.showToast({
              title: '語音播放失敗',
              icon: 'none'
            });
          });

          // 保存當前音頻實例並播放
          this.currentWordAudio = audio;
          audio.play();
        } else {
          console.error('單詞語音請求失敗:', audioRes);
          uni.showToast({
            title: '語音播放失敗',
            icon: 'none'
          });
        }
      } catch (error) {
        console.error('播放單詞語音異常:', error);
        uni.showToast({
          title: '語音播放失敗',
          icon: 'none'
        });
      }
    },



    // 重複播放單詞語音（用於釋義彈窗中的揚聲器圖標）
    repeatWordAudio() {
      if (this.currentWordMeaning && this.currentWordMeaning.word) {
        console.log('重複播放單詞語音:', this.currentWordMeaning.word);
        this.playWordAudio(this.currentWordMeaning.word);
      } else {
        console.warn('沒有當前單詞可以播放');
      }
    },

    // 处理单词点击事件
    handleWordClick(word) {
      const definition = this.findWordDefinition(word);
      console.log('查找单词:', word, '释义:', definition);
      
      // 獲取單詞的讀音
      if (word) {
        this.playWordAudio(word);
      }

      if (definition) {
        this.currentWordMeaning = {
          word: definition.word,
          phonetic: definition.soundmark || '',
          partOfSpeech: '', // 可以根据需要添加词性
          meaning: definition.paraphrase || '',
          knowledgeGain: definition.knowledge || ''
        };
        this.showWordMeaning();
      } else {
        console.log('未找到单词释义:', word);
      }
    },
    
    // 计算音频总时长
    async calculateTotalDuration() {
      let totalDuration = 0;
      for (let i = 0; i < this.currentPageAudios.length; i++) {
        const audio = this.currentPageAudios[i];
        
        // 優先使用API返回的時長信息
        if (audio.duration && audio.duration > 0) {
          console.log(`使用API返回的時長 ${i + 1}:`, audio.duration, '秒');
          totalDuration += audio.duration;
          continue;
        }
        
        // 如果沒有API時長信息，嘗試獲取音頻時長
        try {
          const duration = await this.getAudioDuration(audio.url);
          audio.duration = duration;
          totalDuration += duration;
          console.log(`獲取到音頻時長 ${i + 1}:`, duration, '秒');
        } catch (error) {
          console.error('获取音频时长失败:', error);
          // 如果无法获取时长，根據文字長度估算（更精確的估算）
          const textLength = audio.text.length;
          // 假設每分鐘可以讀150-200個字符，這裡用180作為平均值
          const estimatedDuration = Math.max(2, textLength / 3); // 每3個字符約1秒
          audio.duration = estimatedDuration;
          totalDuration += estimatedDuration;
          console.log(`估算音頻時長 ${i + 1}:`, estimatedDuration, '秒 (文字長度:', textLength, ')');
        }
      }
      this.totalTime = totalDuration;
      console.log('音频总时长:', totalDuration, '秒');
    },
    
    // 获取音频时长
    getAudioDuration(audioUrl) {
      return new Promise((resolve, reject) => {
        const audio = uni.createInnerAudioContext();
        audio.src = audioUrl;
        
        let resolved = false;
        
        // 监听音频加载完成事件
        audio.onCanplay(() => {
          console.log('音频可以播放，duration:', audio.duration);
          if (!resolved && audio.duration && audio.duration > 0) {
            resolved = true;
            resolve(audio.duration);
            audio.destroy();
          }
        });
        
        // 监听音频元数据加载完成事件
        audio.onLoadedmetadata = () => {
          console.log('音频元数据加载完成，duration:', audio.duration);
          if (!resolved && audio.duration && audio.duration > 0) {
            resolved = true;
            resolve(audio.duration);
            audio.destroy();
          }
        };
        
        // 监听音频时长更新事件
        audio.onDurationChange = () => {
          console.log('音频时长更新，duration:', audio.duration);
          if (!resolved && audio.duration && audio.duration > 0) {
            resolved = true;
            resolve(audio.duration);
            audio.destroy();
          }
        };
        
        // 如果以上方法都無法獲取時長，嘗試播放一小段來獲取時長
        audio.onPlay(() => {
          console.log('音频开始播放，duration:', audio.duration);
          if (!resolved) {
            setTimeout(() => {
              if (!resolved && audio.duration && audio.duration > 0) {
                resolved = true;
                resolve(audio.duration);
                audio.destroy();
              }
            }, 100); // 播放100ms後檢查時長
          }
        });
        
        audio.onError((error) => {
          console.error('音频加载失败:', error);
          if (!resolved) {
            resolved = true;
            reject(error);
            audio.destroy();
          }
        });
        
        // 設置較長的超時時間，並在超時前嘗試播放
        setTimeout(() => {
          if (!resolved) {
            console.log('嘗試播放音頻以獲取時長');
            audio.play();
          }
        }, 1000);
        
        // 最終超時處理
        setTimeout(() => {
          if (!resolved) {
            console.warn('獲取音頻時長超時，使用默認值');
            resolved = true;
            reject(new Error('获取音频时长超时'));
            audio.destroy();
          }
        }, 5000);
      });
    },
    
    // 音频控制方法
    togglePlay() {
      if (this.currentPageAudios.length === 0) {
        uni.showToast({
          title: '当前页面没有音频内容',
          icon: 'none'
        });
        return;
      }
      
      if (this.isPlaying) {
        this.pauseAudio();
      } else {
        this.playAudio();
      }
    },
    
    // 播放音频
    playAudio() {
      if (this.currentPageAudios.length === 0) return;
      
      // 如果没有当前音频实例或者需要切换音频
      if (!this.currentAudio || this.currentAudio.src !== this.currentPageAudios[this.currentAudioIndex].url) {
        this.createAudioInstance();
      }
      
      this.currentAudio.play();
      this.isPlaying = true;
      // 更新高亮状态
      this.updateHighlightIndex();
    },
    
    // 暂停音频
    pauseAudio() {
      if (this.currentAudio) {
        this.currentAudio.pause();
      }
      this.isPlaying = false;
      // 暂停时清除高亮
      this.currentHighlightIndex = -1;
    },
    
    // 创建音频实例
    createAudioInstance() {
      // 销毁之前的音频实例
      if (this.currentAudio) {
        this.currentAudio.destroy();
      }
      
      // 優先使用微信原生API以支持playbackRate
      let audio;
      if (typeof wx !== 'undefined' && wx.createInnerAudioContext) {
        console.log('使用微信原生音頻API');
        audio = wx.createInnerAudioContext();
      } else {
        console.log('使用uni-app音頻API');
        audio = uni.createInnerAudioContext();
      }
      audio.src = this.currentPageAudios[this.currentAudioIndex].url;
      
      // 在音頻可以播放時檢測playbackRate支持
      audio.onCanplay(() => {
        console.log('🎵 音頻可以播放，開始檢測playbackRate支持');
        this.checkPlaybackRateSupport(audio);
        
        // 檢測完成後，設置用戶期望的播放速度
        setTimeout(() => {
          if (this.playbackRateSupported) {
            console.log('設置播放速度:', this.playSpeed);
            audio.playbackRate = this.playSpeed;
            
            // 驗證設置結果
            setTimeout(() => {
              console.log('最終播放速度:', audio.playbackRate);
              if (Math.abs(audio.playbackRate - this.playSpeed) > 0.01) {
                console.log('⚠️ 播放速度設置可能未生效');
              } else {
                console.log('✅ 播放速度設置成功');
              }
            }, 50);
          } else {
            console.log('❌ 當前環境不支持播放速度控制');
          }
        }, 50);
      });
      
      // 音频事件监听
      audio.onPlay(() => {
        console.log('音频开始播放');
        this.isPlaying = true;
      });
      
      audio.onPause(() => {
        console.log('音频暂停');
        this.isPlaying = false;
      });
      
      audio.onTimeUpdate(() => {
        this.updateCurrentTime();
      });
      
      audio.onEnded(() => {
        console.log('当前音频播放结束');
        this.onAudioEnded();
      });
      
      audio.onError((error) => {
        console.error('音频播放错误:', error);
        this.isPlaying = false;
        uni.showToast({
          title: '音频播放失败',
          icon: 'none'
        });
      });
      
      this.currentAudio = audio;
    },
    
    // 更新当前播放时间
    updateCurrentTime() {
      if (!this.currentAudio) return;
      
      let totalTime = 0;
      // 计算之前音频的总时长
      for (let i = 0; i < this.currentAudioIndex; i++) {
        totalTime += this.currentPageAudios[i].duration;
      }
      // 加上当前音频的播放时间
      totalTime += this.currentAudio.currentTime;
      
      this.currentTime = totalTime;
      
      // 如果不是正在拖動滑動條，則同步更新滑動條的值
      if (!this.isDragging) {
        this.sliderValue = this.currentTime;
      }
      
      // 更新当前高亮的文本索引
      this.updateHighlightIndex();
    },
    
    // 更新高亮文本索引
    updateHighlightIndex() {
      if (!this.isPlaying || this.currentPageAudios.length === 0) {
        this.currentHighlightIndex = -1;
        return;
      }
      
      // 根据当前播放的音频索引设置高亮
      this.currentHighlightIndex = this.currentAudioIndex;
      console.log('更新高亮索引:', this.currentHighlightIndex, '当前音频索引:', this.currentAudioIndex);
    },
    
    // 判断当前文本是否应该高亮
    isTextHighlighted(page, index) {
      // 只有当前页面且是文本类型才可能高亮
      if (page !== this.bookPages[this.currentPage - 1]) return false;
      
      // 计算当前页面中text类型元素的索引
      let textIndex = 0;
      for (let i = 0; i <= index; i++) {
        if (page[i].type === 'text') {
          if (i === index) {
            const shouldHighlight = textIndex === this.currentHighlightIndex;
            if (shouldHighlight) {
              console.log('高亮文本:', textIndex, '当前高亮索引:', this.currentHighlightIndex);
            }
            return shouldHighlight;
          }
          textIndex++;
        }
      }
      return false;
    },
    
    // 音频播放结束处理
    onAudioEnded() {
      if (this.currentAudioIndex < this.currentPageAudios.length - 1) {
        // 播放下一个音频
        this.currentAudioIndex++;
        this.playAudio();
      } else {
        // 所有音频播放完毕
        if (this.isLoop) {
          // 循环播放
          this.currentAudioIndex = 0;
          this.playAudio();
        } else {
          // 停止播放
          this.isPlaying = false;
          this.currentTime = this.totalTime;
          this.currentHighlightIndex = -1;
        }
      }
    },
    toggleLoop() {
      this.isLoop = !this.isLoop;
    },
    
    toggleSpeed() {
      // 檢查是否支持播放速度控制
      if (!this.playbackRateSupported) {
        uni.showToast({
          title: '當前設備不支持播放速度控制',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      const currentIndex = this.speedOptions.indexOf(this.playSpeed);
      const nextIndex = (currentIndex + 1) % this.speedOptions.length;
      const oldSpeed = this.playSpeed;
      this.playSpeed = this.speedOptions[nextIndex];
      
      console.log(`播放速度切換: ${oldSpeed}x -> ${this.playSpeed}x`);
      
      // 如果当前有音频在播放，更新播放速度
      if (this.currentAudio) {
        const wasPlaying = this.isPlaying;
        const currentTime = this.currentAudio.currentTime;
        
        // 設置新的播放速度
        this.currentAudio.playbackRate = this.playSpeed;
        
        // 如果正在播放，需要重啟播放才能使播放速度生效
        if (wasPlaying) {
          this.currentAudio.pause();
          setTimeout(() => {
            this.currentAudio.seek(currentTime);
            this.currentAudio.play();
          }, 50);
        }
        
        console.log('音頻實例播放速度已更新為:', this.currentAudio.playbackRate);
        
        // 顯示速度變更提示
        uni.showToast({
          title: `播放速度: ${this.playSpeed}x`,
          icon: 'none',
          duration: 1000
        });
      }
    },
    
    // 滑動條值實時更新 (@input 事件)
    onSliderInput(value) {
      // 在拖動過程中實時更新顯示的時間，但不影響實際播放
      if (this.isDragging) {
        // 可以在這裡實時更新顯示時間，讓用戶看到拖動到的時間點
        // 但不改變實際的 currentTime，避免影響播放邏輯
        console.log('實時更新滑動條值:', value);
      }
    },
    
    // 滑動條拖動過程中的處理 (@changing 事件)
    onSliderChanging(value) {
      // 第一次觸發 changing 事件時，暫停播放並標記為拖動狀態
      if (!this.isDragging) {
        if (this.isPlaying) {
          this.pauseAudio();
          console.log('開始拖動滑動條，暫停播放');
        }
        this.isDragging = true;
      }
      
      // 更新滑動條的值，但不改變實際播放位置
      this.sliderValue = value;
      console.log('拖動中，滑動條值:', value);
    },
    
    // 滑動條拖動結束的處理 (@change 事件)
    onSliderChange(value) {
      console.log('滑動條變化，跳轉到位置:', value, '是否為拖動:', this.isDragging);
      
      // 如果不是拖動狀態（即單點），需要先暫停播放
      if (!this.isDragging && this.isPlaying) {
        this.pauseAudio();
        console.log('單點滑動條，暫停播放');
      }
      
      // 重置拖動狀態
      this.isDragging = false;
      this.sliderValue = value;
      
      // 跳轉到指定位置，但不自動恢復播放
      this.seekToTime(value, false);
      
      console.log('滑動條操作完成，保持暫停狀態，需要手動點擊播放');
    },
    
    // 跳轉到指定時間
    seekToTime(targetTime, shouldResume = false) {
      if (!this.currentPageAudios || this.currentPageAudios.length === 0) {
        console.log('沒有音頻數據，無法跳轉');
        return;
      }
      
      // 確保目標時間在有效範圍內
      targetTime = Math.max(0, Math.min(targetTime, this.totalTime));
      console.log('跳轉到時間:', targetTime, '秒', '總時長:', this.totalTime, '是否恢復播放:', shouldResume);
      
      let accumulatedTime = 0;
      let targetAudioIndex = -1;
      let targetAudioTime = 0;
      
      // 找到目標時間對應的音頻片段
      for (let i = 0; i < this.currentPageAudios.length; i++) {
        const audioDuration = this.currentPageAudios[i].duration || 0;
        console.log(`音頻片段 ${i}: 時長=${audioDuration}, 累計時間=${accumulatedTime}, 範圍=[${accumulatedTime}, ${accumulatedTime + audioDuration}]`);
        
        if (targetTime >= accumulatedTime && targetTime <= accumulatedTime + audioDuration) {
          targetAudioIndex = i;
          targetAudioTime = targetTime - accumulatedTime;
          break;
        }
        accumulatedTime += audioDuration;
      }
      
      // 如果沒有找到合適的音頻片段，使用最後一個
      if (targetAudioIndex === -1 && this.currentPageAudios.length > 0) {
        targetAudioIndex = this.currentPageAudios.length - 1;
        targetAudioTime = this.currentPageAudios[targetAudioIndex].duration || 0;
        console.log('使用最後一個音頻片段作為目標');
      }
      
      console.log('目標音頻索引:', targetAudioIndex, '目標音頻時間:', targetAudioTime);
      
      if (targetAudioIndex === -1) {
        console.error('無法找到目標音頻片段');
        return;
      }
      
      // 如果需要切換到不同的音頻片段
      if (targetAudioIndex !== this.currentAudioIndex) {
        console.log(`切換音頻片段: ${this.currentAudioIndex} -> ${targetAudioIndex}`);
        this.currentAudioIndex = targetAudioIndex;
        this.createAudioInstance();
        
        // 等待音頻實例創建完成後再跳轉
        this.waitForAudioReady(() => {
          if (this.currentAudio) {
            this.currentAudio.seek(targetAudioTime);
            this.currentTime = targetTime;
            console.log('切換音頻並跳轉到:', targetAudioTime, '秒');
            
            // 如果拖動前正在播放，則恢復播放
            if (shouldResume) {
              this.currentAudio.play();
              this.isPlaying = true;
              console.log('恢復播放狀態');
            }
          }
        });
      } else {
        // 在當前音頻片段內跳轉
        if (this.currentAudio) {
          this.currentAudio.seek(targetAudioTime);
          this.currentTime = targetTime;
          console.log('在當前音頻內跳轉到:', targetAudioTime, '秒');
          
          // 如果拖動前正在播放，則恢復播放
          if (shouldResume) {
            this.currentAudio.play();
            this.isPlaying = true;
            console.log('恢復播放狀態');
          }
        }
      }
    },
    
    // 等待音頻實例準備就緒
    waitForAudioReady(callback, maxAttempts = 10, currentAttempt = 0) {
      if (currentAttempt >= maxAttempts) {
        console.error('音頻實例準備超時');
        return;
      }
      
      if (this.currentAudio && this.currentAudio.src) {
        // 音頻實例已準備好
        setTimeout(callback, 50); // 稍微延遲確保完全準備好
      } else {
        // 繼續等待
        setTimeout(() => {
          this.waitForAudioReady(callback, maxAttempts, currentAttempt + 1);
        }, 100);
      }
    },
    
    // 初始檢測播放速度支持（不依賴音頻實例）
    checkInitialPlaybackRateSupport() {
      try {
        const systemInfo = uni.getSystemInfoSync();
        console.log('初始檢測 - 系統信息:', systemInfo);
        
        // 檢查基礎庫版本 - playbackRate需要2.11.0及以上
        const SDKVersion = systemInfo.SDKVersion || '0.0.0';
        const versionArray = SDKVersion.split('.').map(v => parseInt(v));
        const isVersionSupported = versionArray[0] > 2 || 
          (versionArray[0] === 2 && versionArray[1] > 11) ||
          (versionArray[0] === 2 && versionArray[1] === 11 && versionArray[2] >= 0);
        
        if (!isVersionSupported) {
          this.playbackRateSupported = false;
          console.log(`初始檢測 - 基礎庫版本過低 (${SDKVersion})，需要2.11.0及以上才支持播放速度控制`);
          return;
        }
        
        // Android 6以下版本不支持
        if (systemInfo.platform === 'android') {
          const androidVersion = systemInfo.system.match(/Android (\d+)/);
          if (androidVersion && parseInt(androidVersion[1]) < 6) {
            this.playbackRateSupported = false;
            console.log('初始檢測 - Android版本過低，需要Android 6及以上才支持播放速度控制');
            return;
          }
        }
        
        // 檢查微信原生API是否可用
        if (typeof wx === 'undefined' || !wx.createInnerAudioContext) {
          console.log('初始檢測 - 微信原生API不可用，可能影響playbackRate支持');
        } else {
          console.log('初始檢測 - 微信原生API可用');
        }
        
        // 如果通過基本檢測，暫時設為支持，等音頻實例創建後再詳細檢測
        this.playbackRateSupported = true;
        console.log('初始檢測 - 基本條件滿足，等待音頻實例檢測');
        
      } catch (error) {
        console.error('初始檢測播放速度支持時出錯:', error);
        this.playbackRateSupported = false;
      }
    },
    
    // 檢查播放速度控制支持
    checkPlaybackRateSupport(audio) {
      try {
        // 檢查基礎庫版本和平台支持
        const systemInfo = uni.getSystemInfoSync();
        console.log('系統信息:', systemInfo);
        console.log('平台:', systemInfo.platform);
        console.log('基礎庫版本:', systemInfo.SDKVersion);
        console.log('系統版本:', systemInfo.system);
        
        // 根據uni-app文檔，微信小程序需要基礎庫2.11.0+才支持playbackRate
        const SDKVersion = systemInfo.SDKVersion || '0.0.0';
        const versionArray = SDKVersion.split('.').map(v => parseInt(v));
        const isVersionSupported = versionArray[0] > 2 || 
          (versionArray[0] === 2 && versionArray[1] > 11) ||
          (versionArray[0] === 2 && versionArray[1] === 11 && versionArray[2] >= 0);
        
        console.log('基礎庫版本檢查:', {
          version: SDKVersion,
          parsed: versionArray,
          supported: isVersionSupported
        });
        
        if (!isVersionSupported) {
          this.playbackRateSupported = false;
          console.log(`❌ 基礎庫版本不支持 (${SDKVersion})，微信小程序需要2.11.0+才支持playbackRate`);
          return;
        }
        
        // Android平台需要6.0+版本支持
        if (systemInfo.platform === 'android') {
          const androidVersion = systemInfo.system.match(/Android (\d+)/);
          console.log('Android版本檢查:', androidVersion);
          if (androidVersion && parseInt(androidVersion[1]) < 6) {
            this.playbackRateSupported = false;
            console.log(`❌ Android版本不支持 (${androidVersion[1]})，需要Android 6+才支持playbackRate`);
            return;
          }
        }
        
        // 檢查音頻實例是否支持playbackRate
        console.log('🔍 音頻實例檢查:');
        console.log('- playbackRate初始值:', audio.playbackRate);
        console.log('- playbackRate類型:', typeof audio.playbackRate);
        
        // 嘗試設置並檢測是否真正支持
        const testRate = 1.25;
        const originalRate = audio.playbackRate || 1.0;
        
        try {
          audio.playbackRate = testRate;
          console.log('- 設置測試速度:', testRate);
          console.log('- 設置後的值:', audio.playbackRate);
          
          // 檢查設置是否生效
          if (Math.abs(audio.playbackRate - testRate) < 0.01) {
            this.playbackRateSupported = true;
            console.log('✅ playbackRate功能正常');
          } else {
            this.playbackRateSupported = false;
            console.log('❌ playbackRate設置無效，可能不被支持');
          }
          
        } catch (error) {
          this.playbackRateSupported = false;
          console.log('❌ playbackRate設置出錯:', error);
        }
        
      } catch (error) {
        console.error('檢查播放速度支持時出錯:', error);
        this.playbackRateSupported = false;
      }
    },
    
    // 上一个音频
    previousAudio() {
      // 如果正在加载音频，禁止切换
      if (this.isAudioLoading) {
        return;
      }
      
      if (this.currentPageAudios.length === 0) return;
      
      if (this.currentAudioIndex > 0) {
        this.currentAudioIndex--;
        if (this.isPlaying) {
          this.playAudio();
        }
      }
    },
    
    // 下一个音频
    nextAudio() {
      // 如果正在加载音频，禁止切换
      if (this.isAudioLoading) {
        return;
      }
      
      if (this.currentPageAudios.length === 0) return;
      
      if (this.currentAudioIndex < this.currentPageAudios.length - 1) {
        this.currentAudioIndex++;
        if (this.isPlaying) {
          this.playAudio();
        }
      }
    },

    async previousPage() {
        if (this.currentPage > 1) {
          this.currentPage--;
          // 获取对应页面的数据（如果还没有获取过）
          if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
            await this.getBookPages(this.courseIdList[this.currentPage - 1]);
          }
        }
    },
    async nextPage() {
      if (this.currentPage < this.bookPages.length) {
        this.currentPage++;
        // 获取对应页面的数据（如果还没有获取过）
        if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
          await this.getBookPages(this.courseIdList[this.currentPage - 1]);
        }
      }
    },
    toggleSound() {
      // 检查是否正在加载音频，如果是则阻止音色切换
      if (this.isAudioLoading) {
        uni.showToast({
          title: '音频加载中，请稍后再试',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      // 检查AudioControls组件是否正在加载音频
      if (this.$refs.audioControls && this.$refs.audioControls.isAudioLoading) {
        uni.showToast({
          title: '音频加载中，请稍后再试',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      console.log('音色切换')
      uni.navigateTo({
        url: '/subPages/home/music?voiceId=' + this.voiceId
      })
    },
    unlockBook() {
      console.log('解锁全书')
      // 这里可以跳转到会员页面或者调用解锁接口
      uni.navigateTo({
        url: '/subPages/member/recharge'
      })
    },
    async goToPage(page) {
      this.currentPage = page
      console.log('跳转到页面:', page)
      // 获取对应页面的数据（如果还没有获取过）
      if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
        await this.getBookPages(this.courseIdList[this.currentPage - 1]);
      }
    },
    async onSwiperChange(e) {
      this.currentPage = e.detail.current + 1
      // 获取对应页面的数据（如果还没有获取过）
      if (this.courseIdList[this.currentPage - 1] && this.bookPages[this.currentPage - 1].length === 0) {
        await this.getBookPages(this.courseIdList[this.currentPage - 1]);
      }
    },
    async getCourseList(id) {
      const res = await this.$api.book.coursePage({
        id: id
      })
      if (res.code === 200) {
        // 课程切换时，先清理音频控制组件的所有数据
        if (this.$refs.audioControls) {
          this.$refs.audioControls.resetForCourseChange();
        }
        
        // 清空当前页面相关数据
        this.currentPage = 1; // 重置到第一页
        this.currentCourse = 1; // 重置当前课程索引
        this.currentWordMeaning = null; // 清空单词释义
        this.currentWordAudio = null; // 清空单词音频
        this.currentHighlightIndex = -1; // 清空高亮索引
        
        // 清理单词音频缓存
        this.clearWordAudioCache();
        
        // 重新初始化课程数据
        this.courseIdList = res.result.map(item => item.id)
        // 初始化二维数组 换一种方式
        this.bookPages = this.courseIdList.map(() => [])
        // 初始化标题数组
        this.pageTitles = this.courseIdList.map(() => '')
        // 初始化页面类型数组
        this.pageTypes = this.courseIdList.map(() => '')
        // 初始化页面单词数组
        this.pageWords = this.courseIdList.map(() => [])
        
        console.log('课程切换完成，courseId:', id, '总页数:', this.courseIdList.length);
        
        // 初始化第一页
        if (this.courseIdList.length > 0) {
          await this.getBookPages(this.courseIdList[0])
          
          // 课程切换后，确保音频控件能正确加载新课程的音频
          console.log('课程切换完成，准备加载音频，当前页面类型:', this.isTextPage);
          
          // 使用$nextTick确保DOM和数据都已更新
          this.$nextTick(async () => {
            if (this.$refs.audioControls) {
              console.log('开始自动加载课程音频');
              try {
                // 直接调用getCurrentPageAudio方法，更可靠
                await this.$refs.audioControls.getCurrentPageAudio();
                console.log('课程切换后音频加载完成');
              } catch (error) {
                console.error('课程切换后音频加载失败:', error);
              }
            }
          });
          
          // 预加载后续几页的内容（异步执行，不阻塞当前页面显示）
          this.preloadNextPages()
        }
      }
    },
    async getBookPages(id) {
      const res = await this.$api.book.coursesPageDetail({
        id: id
      })
      if (res.code === 200) {
        // 使用$set确保响应式更新
        const rawPageData = JSON.parse(res.result.content)
        console.log('获取到的原始页面数据:', rawPageData)
        
        // 过滤掉无效的数据项
        const filteredPageData = rawPageData.filter(item => {
          return item && typeof item === 'object' && (item.type || item.content)
        })
        console.log('过滤后的页面数据:', filteredPageData)
        
        // 确保当前页面存在
        if (this.currentPage - 1 < this.bookPages.length) {
          this.$set(this.bookPages, this.currentPage - 1, filteredPageData)
          // 保存页面标题
          this.$set(this.pageTitles, this.currentPage - 1, res.result.title || '')
          // 保存页面类型
          this.$set(this.pageTypes, this.currentPage - 1, res.result.type || '')
          // 保存页面单词释义数据
          this.$set(this.pageWords, this.currentPage - 1, res.result.words || [])
          // 保存页面付费状态
          this.$set(this.pagePay, this.currentPage - 1, res.result.pay || 'N')
        }
      }
    },
    // 获取课程列表
    async getCoursePageList (bookId) {
      const res = await this.$api.book.course({
        id: bookId
      })
      if (res.code === 200) {
        this.courseList = res.result.records
        // 打上序列号
        this.courseList = this.courseList.map((item, index) => ({
          ...item,
          index,
        }))
      }
    },
    
    // 清理音频缓存
    clearAudioCache() {
      this.audioCache = {};
      console.log('音频缓存已清理');
    },

    // 清理單詞語音緩存
    clearWordAudioCache() {
      this.wordAudioCache = {};
      console.log('單詞語音緩存已清理');
    },
    
    // 限制缓存大小，保留最近访问的页面
    limitCacheSize(maxSize = 10) {
      const cacheKeys = Object.keys(this.audioCache);
      if (cacheKeys.length > maxSize) {
        // 删除最旧的缓存项
        const keysToDelete = cacheKeys.slice(0, cacheKeys.length - maxSize);
        keysToDelete.forEach(key => {
          delete this.audioCache[key];
        });
        console.log('缓存大小已限制，删除了', keysToDelete.length, '个缓存项');
      }
    },
    
    // 预加载后续页面内容
    async preloadNextPages() {
      try {
        console.log('开始预加载后续页面内容');
        
        // 优化策略：只预加载接下来的2-3页内容，避免过多请求
        const preloadCount = Math.min(3, this.courseIdList.length - 1); // 预加载3页或剩余页数
        
        // 串行预加载，避免并发请求过多
        for (let i = 1; i <= preloadCount; i++) {
          if (i < this.courseIdList.length && this.bookPages[i].length === 0) {
            try {
              console.log(`预加载第${i + 1}页内容`);
              await this.preloadSinglePage(this.courseIdList[i], i);
              
              // 每页之间间隔800ms，给服务器更多缓冲时间
              if (i < preloadCount) {
                await new Promise(resolve => setTimeout(resolve, 800));
              }
            } catch (error) {
              console.error(`预加载第${i + 1}页失败:`, error);
              // 继续预加载下一页
            }
          }
        }
        
        console.log('页面内容预加载完成');
        
        // 延迟1.5秒后再通知AudioControls组件开始预加载音频，避免接口冲突
        setTimeout(() => {
          if (this.$refs.audioControls) {
            this.$refs.audioControls.startPreloadAudio();
          }
        }, 1500);
        
      } catch (error) {
        console.error('预加载页面内容失败:', error);
      }
    },
    
    // 预加载单个页面
    async preloadSinglePage(courseId, pageIndex) {
      try {
        const res = await this.$api.book.coursesPageDetail({
          id: courseId
        });
        
        if (res.code === 200) {
          const rawPageData = JSON.parse(res.result.content);
          const filteredPageData = rawPageData.filter(item => {
            return item && typeof item === 'object' && (item.type || item.content);
          });
          
          // 使用$set确保响应式更新
          this.$set(this.bookPages, pageIndex, filteredPageData);
          this.$set(this.pageTitles, pageIndex, res.result.title || '');
          this.$set(this.pageTypes, pageIndex, res.result.type || '');
          this.$set(this.pageWords, pageIndex, res.result.words || []);
          this.$set(this.pagePay, pageIndex, res.result.pay || 'N');
          
          console.log(`第${pageIndex + 1}页内容预加载完成`);
        }
      } catch (error) {
        console.error(`预加载第${pageIndex + 1}页失败:`, error);
        throw error;
      }
    },
    
      // 自動加載第一頁音頻並播放
  async autoLoadAndPlayFirstPage() {
    try {
      console.log('開始自動加載第一頁音頻');
      
      // 確保當前是第一頁且是文字頁面
      if (this.currentPage === 1 && this.isTextPage) {
        console.log('當前是第一頁文字頁面，開始加載音頻');
        
        // 加載音頻
        await this.getCurrentPageAudio();
        
        // 檢查是否成功加載音頻
        if (this.currentPageAudios && this.currentPageAudios.length > 0) {
          console.log('音頻加載成功，getCurrentPageAudio已經自動播放第一個音頻');
          // getCurrentPageAudio方法已經處理了第一個音頻的播放，這裡不需要再次調用playAudio
        } else {
          console.log('第一頁沒有音頻數據');
        }
      } else {
        console.log('當前頁面不是第一頁文字頁面，跳過自動播放');
      }
    } catch (error) {
      console.error('自動加載和播放音頻失敗:', error);
    }
  },
  },
  async onLoad(args) {
    // 监听音色切换事件，传递给AudioControls组件处理
    uni.$on('selectVoice', async (voiceId) => {
      if (this.voiceId === voiceId) {
        console.log('音色未變化，跳過處理');
        return;
      }
      
      // 检查是否正在加载音频，如果是则阻止音色切换
      if (this.isAudioLoading || (this.$refs.audioControls && this.$refs.audioControls.isAudioLoading)) {
        console.log('音频正在加载中，阻止音色切换');
        uni.showToast({
          title: '音频加载中，请稍后再试',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      // 更新本地音色ID
      this.voiceId = voiceId;
      
      // 清理單詞語音資源
      this.clearWordAudioCache();
      if (this.currentWordAudio) {
        this.currentWordAudio.destroy();
        this.currentWordAudio = null;
      }
      
      // 通知AudioControls组件处理音色切换
      if (this.$refs.audioControls) {
        try {
          console.log('开始处理音色切换，清理所有音频缓存并重新获取所有页面音频');
          // 传入选项：preloadAllPages: true 表示要预加载所有页面的音频
          await this.$refs.audioControls.handleVoiceChange(voiceId, { 
            preloadAllPages: true 
          });
          console.log('音色切换处理完成');
        } catch (error) {
          console.error('音色切换处理失败:', error);
        }
      }
    })
    
    this.courseId = args.courseId
    this.memberId = args.memberId
    
    // 先获取点进来的课程的页面列表
    await Promise.all([this.getVoiceList(),this.getMemberInfo(),this.getCourseList(this.courseId), this.getCoursePageList(args.bookId)])
   
   // 页面加载完成后，通知AudioControls组件自动加载第一页音频
   this.$nextTick(() => {
     if (this.$refs.audioControls) {
       this.$refs.audioControls.autoLoadAndPlayFirstPage();
     }
   });
    
  },
  // 页面卸载时清理资源
  onUnload() {
    uni.$off('selectVoice')
    // 清理單詞語音資源
    if (this.currentWordAudio) {
      this.currentWordAudio.destroy();
      this.currentWordAudio = null;
    }
    // 清理單詞語音緩存
    this.clearWordAudioCache();
    
    // 通知AudioControls组件清理资源
    if (this.$refs.audioControls) {
      this.$refs.audioControls.destroyAudio();
    }
  },
  
  // 页面隐藏时暂停音频
  onHide() {
    // 通知AudioControls组件暂停音频
    if (this.$refs.audioControls) {
      this.$refs.audioControls.pauseOnHide();
    }
  }
}
</script>

<style lang="scss" scoped>
.book-container {
  width: 100%;
  height: 100vh;
  background-color: #F8F8F8;
  position: relative;
  overflow: hidden;
}

.custom-navbar {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  background-color: #F8F8F8;
  z-index: 1000;
  transition: transform 0.3s ease;
  
  &.navbar-hidden {
    transform: translateY(-100%);
  }
}

.navbar-content {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 20rpx 32rpx;
  // padding-top: calc(20rpx + var(--status-bar-height, 0));
  height: 60rpx;
}

.navbar-left,
.navbar-right {
  width: 80rpx;
  display: flex;
  align-items: center;
}

.navbar-right {
  
  justify-content: flex-end;
  flex: 1;
}

.navbar-title {
  transform: translateX(-50rpx);
  flex: 1;
  text-align: center;
  font-family: PingFang SC;
  font-weight: 500;
  font-size: 32rpx;
  color: #262626;
  line-height: 48rpx;
}

.content-swiper {
  flex: 1;
  height: calc(100vh - 100rpx);
  // margin-top: 100rpx;
  margin-bottom: 100rpx;
}

.swiper-item {
  height: 100%;
}

.content-area {
  flex: 1;
  padding: 0 40rpx;
  padding-top: 100rpx;
  // background: linear-gradient(180deg, #DEFFFF 0%, #FBFEFF 22.65%, #F0FBFF 100%);
  height: 100%;
  box-sizing: border-box;
  overflow-y: auto;
}

.card-content {
  background: linear-gradient(180deg, #DEFFFF 0%, #FBFEFF 22.65%, #F0FBFF 100%);
  display: flex;
  flex-direction: column;
  gap: 32rpx;
  height: 1172rpx;
  margin-top: 20rpx;
  border-radius: 32rpx;
    // height: 100%;
    padding: 40rpx;
    // margin: 0 
    border: 1px solid #FFFFFF;
    box-sizing: border-box;
    .card-line {
      display: flex;
      align-items: center;
      // margin-bottom: 20rpx;
    }
  
    .card-line-image {
      width: 48rpx;
      height: 48rpx;
      margin-right: 16rpx;
    }
  
    .card-line-text {
      font-family: PingFang SC;
      font-weight: 600;
      font-size: 30rpx;
      line-height: 48rpx;
      color: #3B3D3D;
    }
  
    .card-image {
      width: 590rpx;
      height: 268rpx;
      border-radius: 24rpx;
      // margin-bottom: 20rpx;
    }
    .english-text {
      display: block;
      font-family: PingFang SC;
      font-weight: 600;
      font-size: 32rpx;
      line-height: 48rpx;
      color: #3B3D3D;
      // margin-bottom: 16rpx;
    }
    
    .english-text-container {
      display: flex;
      flex-wrap: wrap;
      align-items: baseline;
    }
    
    .english-token {
      font-family: PingFang SC;
      font-weight: 600;
      font-size: 32rpx;
      line-height: 48rpx;
      color: #3B3D3D;
      margin-right: 10rpx;
    }
    
    .clickable-word {
      background: $primary-color;
      text-decoration: underline;
      cursor: pointer;
      transition: all 0.2s ease;
    }
    
    .clickable-word:hover {
      background-color: rgba(0, 122, 255, 0.1);
      border-radius: 4rpx;
    }

    .chinese-text {
      display: block;
      font-family: PingFang SC;
      font-weight: 400;
      font-size: 28rpx;
      line-height: 48rpx;
      color: #4F4F4F;
    }
  }

/* 会员限制页面样式 */
.member-content {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  height: 90%;
  background-color: #F8F8F8;
  padding: 40rpx;
  margin: -40rpx;
  box-sizing: border-box;
}

.member-title {
  font-family: PingFang SC;
  font-weight: 500;
  font-size: 40rpx;
  line-height: 1;
  color: #6f6f6f;
  text-align: center;
  margin-bottom: 48rpx;
}

.member-button {
  width: 670rpx;
  height: 72rpx;
  background: #06DADC;
  border-radius: 200rpx;
  display: flex;
  align-items: center;
  justify-content: center;
}

.member-button-text {
  font-family: PingFang SC;
  font-weight: 400;
  font-size: 30rpx;
  color: #FFFFFF;
}

.video-content {
  width: 100vw;
  margin: 200rpx -40rpx 0;
  height: 500rpx;
  background-color: #FFFFFF;
  // padding: 40rpx;
  border-radius: 24rpx;
  display: flex;
  align-items: center;
  justify-content: center;
  .video-player{
    width: 670rpx;
    margin: 0 auto;
    height: 376rpx;
  }
}



.text-content {
  width: 100vw;
  background-color: #F6F6F6;
  height: 100%;
  padding: 40rpx;
  margin: -40rpx;
  box-sizing: border-box;
}

.content-text {
  font-family: PingFang SC;
  // font-weight: 400;
  font-size: 28rpx;
  color: #3B3D3D;
  line-height: 48rpx;
  letter-spacing: 0;
  text-align: justify;
  word-break: break-all;
  transition: all 0.3s ease;
}

.clickable-text {
  cursor: pointer;

  
  &:active {
    background-color: rgba(6, 218, 220, 0.1);
    border-radius: 4rpx;
  }
}

.text-highlight {
  background-color: $primary-color;
  // color: #fff;
  // padding: 8rpx 16rpx;
  // border-radius: 8rpx;
  // box-shadow: 0 2rpx 8rpx rgba(6, 218, 220, 0.3);
}

.custom-tabbar {
  position: fixed;
  bottom: 0;
  left: 0;
  right: 0;
  // background-color: #fff;
  border-top: 1rpx solid #EEEEEE;
  z-index: 1000;
  transition: transform 0.3s ease;
  
  &.tabbar-hidden {
    transform: translateY(100%);
  }
}

.tabbar-content {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 24rpx 62rpx;
  // z-index: 100;
  // position: relative;
  // background-color: #fff;
  // padding-bottom: calc(24rpx + env(safe-area-inset-bottom));
  height: 88rpx;
}

.tabbar-left {
  display: flex;
  align-items: center;
  gap: 35rpx;
}

.tab-button {
  display: flex;
  align-items: center;
  flex-direction: column;
  gap: 8rpx;
}

.tab-icon {
  width: 52rpx;
  height: 52rpx;
}

.tab-text {
  font-family: PingFang SC;
  // font-weight: 400;
  font-size: 22rpx;
  color: #999;
  line-height: 24rpx;
}

.tabbar-right {
  flex: 1;
  display: flex;
  justify-content: flex-end;
}

.page-controls {
  display: flex;
  align-items: center;
}

.page-numbers {
  display: flex;
  align-items: center;
  gap: 8rpx;
  overflow-x: auto;
  max-width: 400rpx;
  
  &::-webkit-scrollbar {
    display: none;
  }
}

.page-number {
  min-width: 84rpx;
  height: 58rpx;
  display: flex;
  align-items: center;
  justify-content: center;
  border-radius: 100rpx;
  font-family: PingFang SC;
  // font-weight: 400;
  font-size: 30rpx;
  color: #3B3D3D;
  background-color: transparent;
  border: 1px solid #3B3D3D;
  transition: all 0.3s ease;
  
  &.active {
    border: 1px solid $primary-color;
    color: $primary-color;
  }
}

/* 课程弹出窗样式 */
.course-popup {
  padding: 0 32rpx;
  max-height: 80vh;
}

.popup-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 20rpx 0;
  border-bottom: 2rpx solid #EEEEEE
  // margin-bottom: 40rpx;
}

.popup-title {
  font-family: PingFang SC;
  font-weight: 500;
  font-size: 34rpx;
  color: #181818;
}


.course-list {
  max-height: 60vh;
  overflow-y: auto;
}

.course-item {
  display: flex;
  align-items: center;
  gap: 24rpx;
  padding-top: 24rpx;
  padding-right: 8rpx;
  padding-bottom: 24rpx;
  padding-left: 8rpx;

  border-bottom: 1px solid #EEEEEE;
  cursor: pointer;
  
  &:last-child {
    border-bottom: none;
  }
}

.course-number {
  width: 80rpx;
  font-family: PingFang SC;
  // font-weight: 400;
  font-size: 36rpx;
  color: #999;
  &.highlight {
    color: $primary-color;
  }
  // margin-right: 24rpx;
}

.course-content {
  flex: 1;
}

.course-english {
  font-family: PingFang SC;
  font-weight: 600;
  font-size: 36rpx;
  line-height: 44rpx;
  color: #252545;
  margin-bottom: 8rpx;
  
  &.highlight {
    color: $primary-color;
  }
}

.course-chinese {
  font-size: 28rpx;
  line-height: 48rpx;
  color: #3B3D3D;
  &.highlight {
    color: $primary-color;
  }
}

/* 释义弹窗样式 */
.meaning-popup {
  // width: 670rpx;
  background-color: #FFFFFF;
  // border-radius: 32rpx;
  overflow: hidden;
}

.meaning-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 32rpx;
  border-bottom: 2rpx solid #EEEEEE;
}

.close-btn {
  width: 80rpx;
}

.close-text {
  font-family: PingFang SC;
  font-size: 32rpx;
  color: #8b8b8b;
}

.meaning-title {
  font-family: PingFang SC;
  font-weight: 500;
  font-size: 34rpx;
  color: #181818;
}

.meaning-content {
  padding: 32rpx;
}

.meaning-image {
  width: 670rpx;
  height: 268rpx;
  border-radius: 24rpx;
  margin-bottom: 32rpx;
}

.word-info {
  margin-bottom: 32rpx;
}

.word-main {
  display: flex;
  align-items: center;
  gap: 16rpx;
  margin-bottom: 8rpx;
}

.word-text {
  font-family: PingFang SC;
  font-weight: 500;
  font-size: 40rpx;
  color: #181818;
}

.phonetic-container{
  display: flex;
  gap: 24rpx;
  align-items: center;
  
  .speaker-icon {
    cursor: pointer;
    transition: opacity 0.2s ease;
    padding: 8rpx;
    border-radius: 8rpx;
    
    &:hover {
      opacity: 0.7;
      background-color: rgba(0, 122, 255, 0.1);
    }
  }
  
  .phonetic-text {
    font-family: PingFang SC;
    font-size: 28rpx;
    color: #262626;
    margin-bottom: 16rpx;
  }
}

.word-meaning {
  display: flex;
  gap: 16rpx;
}

.part-of-speech {
  font-family: PingFang SC;
  font-size: 28rpx;
  color: #262626;
}

.meaning-text {
  font-family: PingFang SC;
  font-size: 28rpx;
  color: #181818;
  flex: 1;
}

.knowledge-gain {
  background: linear-gradient(180deg, #DEFFFF 0%, #FBFEFF 22.65%, #F0FBFF 100%);
  border-radius: 24rpx;
  padding: 32rpx 40rpx;
}

.knowledge-header {
  display: flex;
  align-items: center;
  gap: 16rpx;
  margin-bottom: 20rpx;
}

.knowledge-icon {
  width: 48rpx;
  height: 48rpx;
}

.knowledge-title {
  font-family: PingFang SC;
  font-weight: 600;
  font-size: 30rpx;
  color: #3B3D3D;
}

.knowledge-content {
  font-family: PingFang SC;
  font-size: 28rpx;
  color: #4f4f4f;
  line-height: 48rpx;
}


</style>