shoot-miniprograms/src/audioManager.js

export const audioFils = {
  激光已校准:
    "https://static.shelingxingqiu.com/attachment/2025-10-29/ddupaur1vdkyhzaqdc.mp3",
  胜利: "https://static.shelingxingqiu.com/attachment/2025-09-17/dcuo9yjp0kt5msvmvd.mp3",
  失败: "https://static.shelingxingqiu.com/attachment/2025-09-17/dcuo9yht2sdwhuqygy.mp3",
  请射箭测试距离:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcuvj8avzqyw4hpq7t.mp3",
  距离合格:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutwrda0amn5kqr4j.mp3",
  距离不足:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6hr2faw28t0ianh0.mp3",
  轮到你了:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutzdrn4lxcpv8aqr.mp3",
  第一轮:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutyyr9a7m1vz2w13.mp3",
  第二轮:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutyyr9ldnfexjxtw.mp3",
  第三轮:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutyyr97m4ipxaze4.mp3",
  第四轮:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutyyr9x5addohlzf.mp3",
  第五轮:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutyyr9d7lw2gebpv.mp3",
  决金箭轮:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutwrd9zs4oi2kujv.mp3",
  请蓝方射箭:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutzdrxcbe5ll46as.mp3",
  请红方射箭:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutzdrl3re3dhlfjd.mp3",
  中场休息:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutwrd9zdk1xyolst.mp3",
  比赛结束:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutya59b6pu0ur4um.mp3",
  比赛开始:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcuu5z3a3lumkutske.mp3",
  请开始射击:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutzdrl5u0iromqhf.mp3",
  射击无效:
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutya55ufiiw8oo55.mp3",
  未上靶:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6n45o3tsm1v4unam.mp3",
  "1环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxin1aq7gxjih5l.mp3",
  "2环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxin64tdgx2s4at.mp3",
  "3环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxinlmf87vt8z65.mp3",
  "4环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxinniv97sx0q9u.mp3",
  "5环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxin7j01kknpb7k.mp3",
  "6环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxin4syy1015rtq.mp3",
  "7环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxin3iz3dvmjdai.mp3",
  "8环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxinnjd42lhpfiw.mp3",
  "9环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxin69nj1xh7yfz.mp3",
  "10环":
    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutxinnvsx0tt7ksa.mp3",
  向上调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6ellf5pfvu3l8dhr.mp3",
  向右上调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6ellf45v88pirarr.mp3",
  向右调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6elleqnhrenggxsb.mp3",
  向右下调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6elleo6q16qctf6a.mp3",
  向下调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6ellek2mu2cri2n9.mp3",
  向左下调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6ellf25yu1pt2k5r.mp3",
  向左调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6ellen3zoalxcb06.mp3",
  向左上调整:
    "https://static.shelingxingqiu.com/attachment/2025-11-12/de6ellf37a2iw6w4pu.mp3",
  最后30秒:
    "https://static.shelingxingqiu.com/attachment/2025-11-13/de7kzzllq0futwynso.mp3",
  练习开始:
    "https://static.shelingxingqiu.com/attachment/2025-11-14/de88w0lmmt43nnfmoi.mp3",
};

// 版本控制日志函数
function debugLog(...args) {
  // 获取当前环境信息
  const accountInfo = uni.getAccountInfoSync();
  const envVersion = accountInfo.miniProgram.envVersion;

  // 只在体验版打印日志，正式版(release)和开发版(develop)不打印
  if (envVersion === "trial") {
    console.log(...args);
  }
}

class AudioManager {
  constructor() {
    this.audioMap = new Map();
    this.currentPlayingKey = null;
    this.maxRetries = 3;
    // 多轮统一重试：最多重试的轮次与每轮间隔
    this.maxRetryRounds = 10;
    this.retryRoundIntervalMs = 1500;
    // 显式授权播放标记，防止 iOS 在设置 src 后误播
    this.allowPlayMap = new Map();

    // 串行加载相关属性
    this.audioKeys = [];
    this.currentLoadingIndex = 0;
    this.isLoading = false;
    this.loadingPromise = null;

    // 连续播放队列相关属性
    this.sequenceQueue = [];
    this.sequenceIndex = 0;
    this.isSequenceRunning = false;

    // 防重复播放保护
    this.lastPlayKey = null;
    this.lastPlayAt = 0;

    // 静音开关
    this.isMuted = false;
    this.pendingPlayKey = null;
    // 新增：就绪状态映射
    this.readyMap = new Map();
    // 新增：首轮失败的音频集合与重试阶段标识
    this.failedLoadKeys = new Set();
    this.initAudios();
  }

  // 初始化音频（两阶段：首轮串行加载全部，次轮仅串行加载失败项一次）
  initAudios() {
    if (this.isLoading) {
      debugLog("音频正在加载中，跳过重复初始化");
      return this.loadingPromise;
    }
    debugLog("开始串行加载音频...");
    this.isLoading = true;
    this.audioKeys = Object.keys(audioFils);
    this.currentLoadingIndex = 0;
    this.failedLoadKeys.clear();

    this.loadingPromise = new Promise((resolve) => {
      const finalize = () => {
        const runRounds = (round) => {
          // 达到最大轮次或没有失败项，收尾
          if (this.failedLoadKeys.size === 0 || round > this.maxRetryRounds) {
            this.isLoading = false;
            resolve();
            return;
          }

          const retryKeys = Array.from(this.failedLoadKeys);
          this.failedLoadKeys.clear();
          debugLog(`开始第 ${round} 轮串行加载，共 ${retryKeys.length} 个`);

          this.loadKeysSequentially(retryKeys, () => {
            // 如仍有失败项，继续下一轮；否则结束
            if (this.failedLoadKeys.size > 0 && round < this.maxRetryRounds) {
              setTimeout(() => runRounds(round + 1), this.retryRoundIntervalMs);
            } else {
              this.isLoading = false;
              resolve();
            }
          });
        };

        // 启动第 1 轮重试（如有失败项）
        runRounds(1);
      };
      this.loadNextAudio(finalize);
    });
    return this.loadingPromise;
  }

  // 按自定义列表串行加载音频（避免并发过多）
  loadKeysSequentially(keys, onComplete) {
    let idx = 0;
    const list = Array.from(keys);
    const next = () => {
      if (idx >= list.length) {
        if (onComplete) onComplete();
        return;
      }
      const k = list[idx++];

      // 已就绪的音频不再重载，避免把 ready 状态重置为 false
      if (this.readyMap.get(k)) {
        setTimeout(next, 50);
        return;
      }

      // 未就绪：已存在则重载；不存在则创建
      if (this.audioMap.has(k)) {
        this.retryLoadAudio(k);
        setTimeout(next, 100);
      } else {
        this.createAudio(k, () => {
          setTimeout(next, 100);
        });
        return; // createAudio 内部会触发 next
      }
    };
    next();
  }

  // 串行加载下一个音频（首轮）
  loadNextAudio(onComplete) {
    if (this.currentLoadingIndex >= this.audioKeys.length) {
      debugLog("首轮加载遍历完成", this.currentLoadingIndex);
      if (onComplete) onComplete();
      return;
    }
    const key = this.audioKeys[this.currentLoadingIndex];
    debugLog(
      `开始加载音频 ${this.currentLoadingIndex + 1}/${
        this.audioKeys.length
      }: ${key}`
    );
    this.createAudio(key, () => {
      setTimeout(() => {
        this.loadNextAudio(onComplete);
      }, 100);
    });
  }

  // 创建单个音频实例（统一在失败时记录，而非立即重试）
  createAudio(key, callback) {
    this.currentLoadingIndex++;
    const src = audioFils[key];

    const setupAudio = (realSrc) => {
      const audio = uni.createInnerAudioContext();
      audio.autoplay = false;
      audio.src = realSrc;
      try {
        if (typeof audio.volume === "number") {
          audio.volume = this.isMuted ? 0 : 1;
        } else if (typeof audio.muted !== "undefined") {
          audio.muted = this.isMuted;
        }
      } catch (_) {}
      this.allowPlayMap.set(key, false);
      audio.onPlay(() => {
        if (!this.allowPlayMap.get(key)) {
          try {
            audio.stop();
          } catch (_) {}
        }
      });

      const loadTimeout = setTimeout(() => {
        debugLog(`音频 ${key} 加载超时`);
        this.recordLoadFailure(key);
        try {
          audio.destroy();
        } catch (_) {}
        if (callback) callback();
      }, 10000);

      audio.onCanplay(() => {
        if (!this.allowPlayMap.get(key)) {
          try {
            audio.pause();
          } catch (_) {}
        }
        clearTimeout(loadTimeout);
        this.readyMap.set(key, true);
        this.failedLoadKeys.delete(key);
        debugLog(`音频 ${key} 已加载完成`, this.getLoadProgress());
        uni.$emit("audioLoaded", key);
        const loadedAudioKeys = uni.getStorageSync("loadedAudioKeys") || {};
        loadedAudioKeys[key] = true;
        uni.setStorageSync("loadedAudioKeys", loadedAudioKeys);
        if (callback) callback();
      });

      audio.onError((res) => {
        clearTimeout(loadTimeout);
        debugLog(`音频 ${key} 加载失败：`, res.errMsg);
        this.recordLoadFailure(key);
        this.audioMap.delete(key);
        audio.destroy();
        if (this.readyMap.get(key)) {
          this.readyMap.set(key, false);
        } else {
          if (callback) callback();
        }
      });

      audio.onEnded(() => {
        if (this.currentPlayingKey === key) {
          this.currentPlayingKey = null;
        }
        this.allowPlayMap.set(key, false);
        this.onAudioEnded(key);
      });

      audio.onStop(() => {
        if (this.currentPlayingKey === key) {
          this.currentPlayingKey = null;
        }
        this.allowPlayMap.set(key, false);
      });

      this.audioMap.set(key, audio);
    };

    // 统一先下载到本地再加载
    uni.downloadFile({
      url: src,
      timeout: 20000,
      success: (res) => {
        // 成功必须有临时文件路径
        if (res.tempFilePath) {
          setupAudio(res.tempFilePath);
        } else {
          this.recordLoadFailure(key);
          if (callback) callback();
        }
      },
      fail: () => {
        this.recordLoadFailure(key);
        if (callback) callback();
      },
    });
  }

  // 新增：记录失败（首轮与次轮都会用到）
  recordLoadFailure(key) {
    this.failedLoadKeys.add(key);
  }

  // 重新加载音频
  retryLoadAudio(key) {
    const oldAudio = this.audioMap.get(key);
    if (oldAudio) oldAudio.destroy();
    this.createAudio(key);
  }

  // 播放指定音频或音频数组（数组则按顺序连续播放）
  play(input, interrupt = true) {
    // 统一规范化为队列
    let queue = [];
    if (Array.isArray(input)) {
      queue = input.filter((k) => !!audioFils[k]);
    } else if (typeof input === "string") {
      queue = !!audioFils[input] ? [input] : [];
    } else {
      debugLog("play 参数类型无效，仅支持字符串或字符串数组");
      return;
    }

    if (queue.length === 0) {
      debugLog("连续播放队列为空或无效");
      return;
    }

    if (interrupt) {
      // 立即打断并启动新的播放序列
      this.stopAll();
      this.isSequenceRunning = false;
      this.sequenceQueue = [];
      this.sequenceIndex = 0;

      this.sequenceQueue = queue;
      this.sequenceIndex = 0;
      this.isSequenceRunning = true;
      this._playSingle(queue[0], false);
      return;
    }

    // 不打断当前播放：把新的队列加入到序列中，等待当前播放结束后衔接
    if (this.currentPlayingKey) {
      if (this.isSequenceRunning) {
        // 已有序列在跑：直接追加
        this.sequenceQueue = this.sequenceQueue.concat(queue);
      } else {
        // 没有序列但当前有正在播放的：以当前为序列的起点
        this.isSequenceRunning = true;
        this.sequenceQueue = [this.currentPlayingKey].concat(queue);
        this.sequenceIndex = 0;
        // 不触发 _playSingle，等待当前音频自然结束后由 onAudioEnded 接管
      }
    } else {
      // 当前没有播放：直接启动新的序列
      this.sequenceQueue = queue;
      this.sequenceIndex = 0;
      this.isSequenceRunning = true;
      this._playSingle(queue[0], false);
    }
  }

  // 内部方法：播放单个 key
  _playSingle(key, forceStopAll = false) {
    // 200ms 内的同 key 重复播放直接忽略，避免“比比赛开始”这类重复首音
    const now = Date.now();
    if (this.lastPlayKey === key && now - this.lastPlayAt < 250) {
      debugLog(`忽略快速重复播放: ${key}`);
      return;
    }

    if (forceStopAll) {
      this.stopAll();
    } else if (this.currentPlayingKey && this.currentPlayingKey !== key) {
      this.stop(this.currentPlayingKey);
    } else if (this.currentPlayingKey === key) {
      // 同一音频正在播放：不重启，避免听到重复开头
      return;
    }

    const audio = this.audioMap.get(key);
    if (audio) {
      // 播放前确保遵循当前静音状态
      try {
        if (typeof audio.volume === "number") {
          audio.volume = this.isMuted ? 0 : 1;
        } else if (typeof audio.muted !== "undefined") {
          audio.muted = this.isMuted;
        }
      } catch (_) {}
      // 同一音频：避免 stop() 触发 onStop 清除授权，使用 pause()+seek(0)
      try {
        audio.pause();
      } catch (_) {}
      try {
        if (typeof audio.seek === "function") {
          audio.seek(0);
        } else {
          audio.startTime = 0;
        }
      } catch (_) {
        audio.startTime = 0;
      }

      // 显式授权播放并立即播放
      this.allowPlayMap.set(key, true);

      audio.play();
      this.currentPlayingKey = key;
      this.lastPlayKey = key;
      this.lastPlayAt = Date.now();
    } else {
      debugLog(`音频 ${key} 不存在，尝试重新加载...`);
      this.retryLoadAudio(key);
      const handler = (loadedKey) => {
        if (loadedKey === key) {
          try {
            uni.$off("audioLoaded", handler);
          } catch (_) {}
          // 再次校验是否存在且就绪
          const a = this.audioMap.get(key);
          if (a && this.readyMap.get(key)) {
            this._playSingle(key, false);
          }
        }
      };
      try {
        uni.$on("audioLoaded", handler);
      } catch (_) {}
    }
  }

  // 连续播放：在某个音频结束后，若处于队列播放状态则继续下一个
  onAudioEnded(key) {
    if (!this.isSequenceRunning) return;
    const currentKey = this.sequenceQueue[this.sequenceIndex];
    if (currentKey !== key) return;

    const nextIndex = this.sequenceIndex + 1;
    if (nextIndex < this.sequenceQueue.length) {
      this.sequenceIndex = nextIndex;
      const nextKey = this.sequenceQueue[nextIndex];
      this._playSingle(nextKey, false);
    } else {
      // 队列播放完成
      this.isSequenceRunning = false;
      this.sequenceQueue = [];
      this.sequenceIndex = 0;
    }
  }

  // 停止指定音频
  stop(key) {
    const audio = this.audioMap.get(key);
    if (audio) {
      audio.stop();
      this.allowPlayMap.set(key, false);
      if (this.currentPlayingKey === key) {
        this.currentPlayingKey = null;
      }
    }
  }

  // 停止所有音频
  stopAll() {
    for (const [k, audio] of this.audioMap.entries()) {
      try {
        audio.stop();
      } catch (_) {}
      this.allowPlayMap.set(k, false);
    }
    this.currentPlayingKey = null;
  }

  // 设置静音开关：true 静音，false 取消静音
  setMuted(muted) {
    this.isMuted = !!muted;
    for (const audio of this.audioMap.values()) {
      try {
        if (typeof audio.volume === "number") {
          audio.volume = this.isMuted ? 0 : 1;
        } else if (typeof audio.muted !== "undefined") {
          audio.muted = this.isMuted;
        }
      } catch (_) {}
    }
    debugLog(`静音状态已设置为: ${this.isMuted}`);
  }

  // 新增：返回音频加载进度（0~1）
  getLoadProgress() {
    const keys = Object.keys(audioFils);
    const total = keys.length;
    if (total === 0) return 0;
    let loaded = 0;
    for (const k of keys) {
      if (this.readyMap.get(k)) loaded++;
    }
    return Number((loaded / total).toFixed(2));
  }
}

// 导出单例
export default new AudioManager();