import { ref, computed, watch, onMounted, onBeforeUnmount } from 'vue';
import { wxInfo } from "@/utils/tools";
import Hls from 'hls.js';
import videojs from "video.js";
// 新增：引入多码率切换插件
import 'videojs-contrib-quality-levels'; // 用于读取 m3u8 中的多码率信息
import 'videojs-hls-quality-selector'; // 用于在播放器控制条显示“清晰度”切换菜单（支持 Auto/720p/480p 等）。
import 'videojs-hls-quality-selector/dist/videojs-hls-quality-selector.css';

/**
 * - 使用方法 ：您无需修改业务代码。只要传入的视频 URL 是七牛云生成的多码率 .m3u8 地址，播放器控制条右下角会自动出现“齿轮”图标，用户点击即可切换清晰度（或选择 Auto 自动切换）。
 * - iOS 注意事项 ：在 iOS 移动端（尤其是微信），通常使用系统原生播放器，系统会根据网速自动切换码率（ABR），但通常无法显示手动切换菜单，这是 iOS H5 的系统限制。
 * - PC 和 Android 端将正常显示切换菜单。
 */

/**
 * 视频播放核心逻辑 Hook
 * 处理不同环境下的播放器选择、HLS支持、自动播放策略等
 */
export function useVideoPlayer(props, emit, videoRef, nativeVideoRef) {
  // 播放器实例
  const player = ref(null);
  const state = ref(null);
  const hlsInstance = ref(null);

  // 错误处理相关
  const showErrorOverlay = ref(false);
  const errorMessage = ref('');
  const retryCount = ref(0);
  const maxRetries = 3;

  const showNetworkSpeedOverlay = ref(false);
  const networkSpeedText = ref('');
  const hasEverPlayed = ref(false);
  let networkSpeedTimer = null;

  // 原生播放器状态
  const nativeReady = ref(false);
  let nativeListeners = null;

  // 资源探测信息
  const probeInfo = ref({
    ok: null,
    status: null,
    content_type: "",
    content_length: null,
    accept_ranges: "",
  });
  const probeLoading = ref(false);

  // 1. 环境判断与播放器选择
  const useNativePlayer = computed(() => {
    // 如果 props 强制关闭原生播放器，则返回 false (使用 Video.js)
    if (props.useNativeOnIos === false) {
      return false;
    }
    // 默认逻辑：iOS 微信环境下使用原生播放器
    return wxInfo().isIOSWeChat;
  });

  // 2. 视频源处理
  const videoUrlValue = computed(() => {
    return (props.videoUrl || "").trim();
  });

  // 3. HLS 支持判断
  const isM3U8 = computed(() => {
    const url = videoUrlValue.value.toLowerCase();
    return url.includes('.m3u8');
  });

  // 4. 视频类型判断
  const getVideoMimeType = (url) => {
    const urlText = (url || "").toLowerCase();
    if (urlText.includes(".m3u8")) return "application/x-mpegURL";
    if (urlText.includes(".mp4")) return "video/mp4";
    if (urlText.includes(".mov")) return "video/quicktime";
    return "";
  };

  // 5. 视频源配置
  const videoSources = computed(() => {
    const type = getVideoMimeType(videoUrlValue.value);
    if (type) {
      return [{ src: videoUrlValue.value, type }];
    }
    return [{ src: videoUrlValue.value }];
  });

  // 6. 错误处理逻辑
  const formatBytes = (bytes) => {
    const size = Number(bytes) || 0;
    if (!size) return "";
    const kb = 1024;
    const mb = kb * 1024;
    const gb = mb * 1024;
    if (size >= gb) return (size / gb).toFixed(2) + "GB";
    if (size >= mb) return (size / mb).toFixed(2) + "MB";
    if (size >= kb) return (size / kb).toFixed(2) + "KB";
    return String(size) + "B";
  };

  const getErrorHint = () => {
    if (probeInfo.value.status === 403) return "（403：无权限或已过期）";
    if (probeInfo.value.status === 404) return "（404：资源不存在）";
    if (probeInfo.value.status && probeInfo.value.status >= 500) return `（${probeInfo.value.status}：服务器异常）`;

    const len = probeInfo.value.content_length;
    if (len && len >= 1024 * 1024 * 1024) {
      const text = formatBytes(len);
      return text ? `（文件约${text}，建议 WiFi）` : "（文件较大，建议 WiFi）";
    }
    return "";
  };

  // 资源探测
  const probeVideo = async () => {
    const url = videoUrlValue.value;
    if (!url || typeof fetch === "undefined") return;
    if (probeLoading.value) return;

    probeLoading.value = true;
    const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
    const timeoutId = setTimeout(() => controller?.abort?.(), 8000);

    try {
      const headRes = await fetch(url, {
        method: "HEAD",
        mode: "cors",
        cache: "no-store",
        signal: controller?.signal,
      });

      const contentLength = headRes.headers.get("content-length");
      probeInfo.value = {
        ok: headRes.ok,
        status: headRes.status,
        content_type: headRes.headers.get("content-type") || "",
        content_length: contentLength ? Number(contentLength) || null : null,
        accept_ranges: headRes.headers.get("accept-ranges") || "",
      };

      if (headRes.ok && probeInfo.value.content_length) return;
    } catch (e) {
      // 忽略 HEAD 请求失败
    } finally {
      clearTimeout(timeoutId);
      probeLoading.value = false;
    }

    // 如果 HEAD 失败，尝试 GET Range 0-1
    const controller2 = typeof AbortController !== "undefined" ? new AbortController() : null;
    const timeoutId2 = setTimeout(() => controller2?.abort?.(), 8000);
    try {
      const rangeRes = await fetch(url, {
        method: "GET",
        mode: "cors",
        cache: "no-store",
        headers: { Range: "bytes=0-1" },
        signal: controller2?.signal,
      });
      const contentRange = rangeRes.headers.get("content-range") || "";
      const match = contentRange.match(/\/(\d+)\s*$/);
      const total = match ? Number(match[1]) || null : null;
      const contentLength = rangeRes.headers.get("content-length");

      probeInfo.value = {
        ok: rangeRes.ok,
        status: rangeRes.status,
        content_type: rangeRes.headers.get("content-type") || "",
        content_length: total || (contentLength ? Number(contentLength) || null : null),
        accept_ranges: rangeRes.headers.get("accept-ranges") || "",
      };
    } catch (e) {
      // 忽略错误
    } finally {
      clearTimeout(timeoutId2);
    }
  };

  // 7. 错误处理逻辑
  const handleError = (code, message = '') => {
    showErrorOverlay.value = true;
    showNetworkSpeedOverlay.value = false;
    if (networkSpeedTimer) {
      clearInterval(networkSpeedTimer);
      networkSpeedTimer = null;
    }
    switch (code) {
      case 4: // MEDIA_ERR_SRC_NOT_SUPPORTED
        errorMessage.value = '视频格式不支持或无法加载，请检查网络连接' + getErrorHint();
        if (retryCount.value < maxRetries) {
          setTimeout(retryLoad, 1000);
        }
        break;
      case 3: // MEDIA_ERR_DECODE
        errorMessage.value = '视频解码失败，可能是文件损坏';
        break;
      case 2: // MEDIA_ERR_NETWORK
        errorMessage.value = '网络连接错误，请检查网络后重试' + getErrorHint();
        if (retryCount.value < maxRetries) {
          setTimeout(retryLoad, 2000);
        }
        break;
      case 1: // MEDIA_ERR_ABORTED
        errorMessage.value = '视频加载被中止';
        break;
      default:
        errorMessage.value = message || '视频播放出现未知错误';
    }
  };

  const updateNetworkSpeed = () => {
    if (typeof navigator === 'undefined') {
      networkSpeedText.value = '未知';
      return;
    }

    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
    const downlink = connection && typeof connection.downlink === 'number' ? connection.downlink : null;
    if (downlink && downlink > 0) {
      networkSpeedText.value = `${downlink.toFixed(1)} Mbps`;
      return;
    }

    const effectiveType = connection && typeof connection.effectiveType === 'string' ? connection.effectiveType : '';
    networkSpeedText.value = effectiveType ? `${effectiveType}` : '未知';
  };

  const showNetworkSpeed = () => {
    if (!hasEverPlayed.value) return;
    if (showErrorOverlay.value) return;
    if (showNetworkSpeedOverlay.value) return;

    showNetworkSpeedOverlay.value = true;
    updateNetworkSpeed();

    if (networkSpeedTimer) clearInterval(networkSpeedTimer);
    networkSpeedTimer = setInterval(() => {
      updateNetworkSpeed();
    }, 800);
  };

  const hideNetworkSpeed = () => {
    showNetworkSpeedOverlay.value = false;
    if (networkSpeedTimer) {
      clearInterval(networkSpeedTimer);
      networkSpeedTimer = null;
    }
  };

  // 4. 原生播放器逻辑 (iOS微信)
  const initNativePlayer = () => {
    const videoEl = nativeVideoRef.value;
    if (!videoEl) return;

    // HLS 处理
    if (isM3U8.value && Hls.isSupported()) {
      // 如果原生支持 HLS (iOS Safari)，直接用 src 即可，不需要 hls.js
      // 但如果是安卓微信等不支持原生 HLS 的环境，才需要 hls.js
      // 由于 useNativePlayer 仅针对 iOS 微信，而 iOS 原生支持 HLS，所以这里直接赋值 src 即可
      // 无需额外操作
    }

    const onLoadStart = () => {
      showErrorOverlay.value = false;
      nativeReady.value = false;
    };

    const onCanPlay = () => {
      showErrorOverlay.value = false;
      retryCount.value = 0;
      nativeReady.value = true;
    };

    const onError = () => {
      handleError(videoEl.error?.code);
    };

    const onPlay = () => {
      hasEverPlayed.value = true;
      hideNetworkSpeed();
    };

    const onPause = () => {
      hideNetworkSpeed();
    };

    const onWaiting = () => {
      if (videoEl.paused) return;
      showNetworkSpeed();
    };

    const onStalled = () => {
      if (videoEl.paused) return;
      showNetworkSpeed();
    };

    const onPlaying = () => {
      hideNetworkSpeed();
    };

    videoEl.addEventListener("loadstart", onLoadStart);
    videoEl.addEventListener("canplay", onCanPlay);
    videoEl.addEventListener("error", onError);
    videoEl.addEventListener("play", onPlay);
    videoEl.addEventListener("pause", onPause);
    videoEl.addEventListener("waiting", onWaiting);
    videoEl.addEventListener("stalled", onStalled);
    videoEl.addEventListener("playing", onPlaying);

    nativeListeners = {
      videoEl,
      onLoadStart,
      onCanPlay,
      onError,
      onPlay,
      onPause,
      onWaiting,
      onStalled,
      onPlaying,
    };

    if (props.autoplay) {
      tryNativePlay();
      if (typeof document !== "undefined") {
        document.addEventListener(
          "WeixinJSBridgeReady",
          () => tryNativePlay(),
          { once: true }
        );
      }
    }
  };

  const tryNativePlay = () => {
    const videoEl = nativeVideoRef.value;
    if (!videoEl) return;

    const playPromise = videoEl.play();
    if (playPromise && typeof playPromise.catch === "function") {
      playPromise.catch(() => {
        if (typeof window !== "undefined" && window.WeixinJSBridge) {
          window.WeixinJSBridge.invoke("getNetworkType", {}, () => {
            videoEl.play().catch(() => {});
          });
        }
      });
    }
  };

  // 5. Video.js 播放器逻辑 (PC/Android)
  const videoOptions = computed(() => ({
    controls: true,
    preload: "metadata",
    responsive: true,
    autoplay: props.autoplay,
    playsinline: true,
    playbackRates: [0.5, 0.75, 1, 1.25, 1.5, 2],
    sources: videoSources.value,
    html5: {
      vhs: {
        overrideNative: !videojs.browser.IS_SAFARI, // 非 Safari 下使用 VHS 解析 HLS
      },
      nativeVideoTracks: false,
      nativeAudioTracks: false,
      nativeTextTracks: false,
      hls: {
        withCredentials: false
      }
    },
    errorDisplay: true,
    techOrder: ['html5'],
    userActions: {
      hotkeys: true,
      doubleClick: true,
    },
    controlBar: {
      progressControl: {
        seekBar: {
          mouseTimeDisplay: {
            keepTooltipsInside: true,
          },
        },
      },
    },
    ...props.options,
  }));

  // 8. Video.js 挂载处理
  const handleVideoJsMounted = (payload) => {
    state.value = payload.state;
    player.value = payload.player;

    if (player.value) {
      // 初始化多码率切换插件 (七牛云多码率支持)
      if (player.value.hlsQualitySelector) {
        player.value.hlsQualitySelector({
          displayCurrentQuality: true,
        });
      }

      player.value.on('error', () => {
        const err = player.value.error();
        handleError(err?.code, err?.message);
      });

      player.value.on('loadstart', () => {
        showErrorOverlay.value = false;
      });

      player.value.on('canplay', () => {
        showErrorOverlay.value = false;
        retryCount.value = 0;
      });

      player.value.on('play', () => {
        hasEverPlayed.value = true;
        hideNetworkSpeed();
      });

      player.value.on('pause', () => {
        hideNetworkSpeed();
      });

      player.value.on('waiting', () => {
        if (!hasEverPlayed.value) return;
        if (player.value?.paused?.()) return;
        showNetworkSpeed();
      });

      player.value.on('stalled', () => {
        if (!hasEverPlayed.value) return;
        if (player.value?.paused?.()) return;
        showNetworkSpeed();
      });

      player.value.on('playing', () => {
        hideNetworkSpeed();
      });

      if (props.autoplay) {
        player.value.play().catch(console.warn);
      }
    }
  };

  // 6. 重试逻辑
  const retryLoad = () => {
    if (retryCount.value >= maxRetries) {
      errorMessage.value = '重试次数已达上限，请稍后再试';
      return;
    }

    retryCount.value++;
    showErrorOverlay.value = false;
    hideNetworkSpeed();

    if (useNativePlayer.value) {
      const videoEl = nativeVideoRef.value;
      if (videoEl) {
        nativeReady.value = false;
        const currentSrc = videoEl.currentSrc || videoEl.src;
        videoEl.pause();
        videoEl.removeAttribute("src");
        videoEl.load();
        videoEl.src = currentSrc || videoUrlValue.value;
        videoEl.load();
        tryNativePlay();
      }
    } else {
      if (player.value && !player.value.isDisposed()) {
        player.value.load();
      }
    }
  };

  // 7. 生命周期与监听
  watch(() => videoUrlValue.value, () => {
    retryCount.value = 0;
    showErrorOverlay.value = false;
    hideNetworkSpeed();
    hasEverPlayed.value = false;
    void probeVideo();

    // 如果是原生播放器且 URL 变化，需要手动处理 HLS (如果是非 iOS Safari 环境)
    if (useNativePlayer.value && isM3U8.value) {
       // iOS 原生支持，不需要额外操作
       // 如果未来支持 Android 原生播放器且不支持 HLS，需在此处初始化 hls.js
    }
  });

  onMounted(() => {
    void probeVideo();
    if (useNativePlayer.value) {
      initNativePlayer();
    }
  });

  onBeforeUnmount(() => {
    if (nativeListeners?.videoEl) {
      nativeListeners.videoEl.removeEventListener("loadstart", nativeListeners.onLoadStart);
      nativeListeners.videoEl.removeEventListener("canplay", nativeListeners.onCanPlay);
      nativeListeners.videoEl.removeEventListener("error", nativeListeners.onError);
      nativeListeners.videoEl.removeEventListener("play", nativeListeners.onPlay);
      nativeListeners.videoEl.removeEventListener("pause", nativeListeners.onPause);
      nativeListeners.videoEl.removeEventListener("waiting", nativeListeners.onWaiting);
      nativeListeners.videoEl.removeEventListener("stalled", nativeListeners.onStalled);
      nativeListeners.videoEl.removeEventListener("playing", nativeListeners.onPlaying);
    }

    if (hlsInstance.value) {
      hlsInstance.value.destroy();
    }

    hideNetworkSpeed();
    if (videoRef.value?.$player) {
      videoRef.value.$player.dispose();
    }
  });

  return {
    player,
    state,
    useNativePlayer,
    videoUrlValue,
    videoOptions,
    showErrorOverlay,
    errorMessage,
    showNetworkSpeedOverlay,
    networkSpeedText,
    retryLoad,
    handleVideoJsMounted,
    tryNativePlay
  };
}