Skip to content

一分钟搭建影视站,支持Docker等部署方式

15.1 KB
Raw Blame
'use client';

import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { ApiError, api } from '@/lib/client-api';
import { QUALITY_FAIL_TTL_MS, isRetryableTimeout, qualityKey, summarizeQuality } from '@/lib/quality';
import { createProbeQueue, type ProbeQueue } from '@/lib/quality-probe-queue';
import { readQualities, useAppStore } from '@/lib/store';
import type { QualityEntry, QualityProbeItem, QualityProbeResult, SourceConfig } from '@/lib/types';

/** 探测目标:搜索结果条目里与画质相关的最小字段集 */
export interface QualityProbeTarget {
  sourceKey: string;
  vodId: string;
  /** 源配置缺失时的兜底地址(搜索结果自带);缺 detail,走不了详情页降级 */
  sourceUrl?: string;
  sourceName?: string;
}

export interface QualityProbeProgress {
  /** 本轮目标数 */
  total: number;
  /** 已拿到终态(有档位 / 未知 / 失败)的数量 */
  done: number;
  /** 拿到分辨率的数量 */
  known: number;
  /** 探测失败的数量 */
  failed: number;
  /** 已探到的最高档位 */
  best?: string;
}

/**
 * 单源卡片的探测必须共用同一个队列:每张卡片各建一个队列等于没有限流。
 * 队列只在浏览器里跑,模块级单例足够(SSR 不会调用 push)。
 */
let sharedQueue: ProbeQueue | null = null;
function getSharedQueue(): ProbeQueue {
  sharedQueue ??= createProbeQueue({
    run: (items, onResult, signal) => api.qualityProbeStream(items, onResult, signal),
  });
  return sharedQueue;
}

const toEntry = (result: QualityProbeResult): QualityEntry => ({
  height: result.height,
  from: 'probe',
  error: result.error,
  timestamp: Date.now(),
});

const dedupeByKey = (items: QualityProbeTarget[]): QualityProbeTarget[] => {
  const seen = new Set<string>();
  const out: QualityProbeTarget[] = [];
  for (const item of items) {
    const key = qualityKey(item.sourceKey, item.vodId);
    if (seen.has(key)) continue;
    seen.add(key);
    out.push(item);
  }
  return out;
};

/**
 * 画质探测控制器。
 *
 * 三种入口共用同一份状态与冷却规则:
 * - `probe`:一次 POST 流式探测一批(多源卡片展开、换源面板);
 * - `probeQueued`:交给全局队列(单源卡片进入视口),并发 2、每批 8 条;
 * - `retry`:绕过失败冷却重探(徽章点击)。
 *
 * 结果一律写回 `useAppStore.setQuality`,换页面/再次搜索时可复用(TTL 与 LRU 由 store 负责)。
 */
export function useQualityProbe(sources?: SourceConfig[]) {
  const [qualities, setQualities] = useState<Record<string, QualityEntry>>({});
  const [probing, setProbing] = useState<Record<string, true>>({});
  const [targets, setTargets] = useState<QualityProbeTarget[]>([]);

  /** 在飞键:防同一个键并发重复请求 */
  const inflightRef = useRef<Set<string>>(new Set());
  /** 拿到终态的时间:失败要冷却 QUALITY_FAIL_TTL_MS,成功的终态由缓存判断,不需要冷却 */
  const settledRef = useRef<Map<string, number>>(new Map());
  /** 当前直连批次:被下一批掐掉时靠它解锁未完成的键 */
  const batchRef = useRef<Set<string>>(new Set());
  const abortRef = useRef<AbortController | null>(null);
  /** 交给全局队列、尚未返回的键:卸载时从队列里撤回 */
  const queuedRef = useRef<Set<string>>(new Set());
  const mountedRef = useRef(true);
  /**
   * probe 需要读最新的 qualities 判断「是否已有结论」,但把 qualities 放进依赖会让
   * probe 每次结果到达就换身份;调用方在 effect 里依赖 probe 时就会反复重跑
   * (每次 setQualities 都是新对象)。用 ref 读当前值,让 probe 保持稳定。
   */
  const qualitiesRef = useRef<Record<string, QualityEntry>>({});
  qualitiesRef.current = qualities;
  /** 已经自动重试过的键:超时只补一次,避免「超时→重试→超时」循环打源站 */
  const retriedRef = useRef<Set<string>>(new Set());
  /** 让延迟重试能拿到最新的 probe(probe 依赖 resolveItem,闭包会过期) */
  const probeRef = useRef<((items: QualityProbeTarget[], opts?: { force?: boolean }) => void) | null>(null);

  useEffect(() => {
    mountedRef.current = true;
    // Set 实例只在首次渲染创建,捕获它就能在卸载时读到最新内容(避免 lint 的 ref 快照警告)
    const queued = queuedRef.current;
    return () => {
      mountedRef.current = false;
      abortRef.current?.abort();
      if (queued.size > 0) getSharedQueue().cancel([...queued]);
      queued.clear();
    };
  }, []);

  const resolveItem = useCallback(
    (target: QualityProbeTarget): QualityProbeItem | undefined => {
      const source =
        sources?.find((s) => s.key === target.sourceKey) ??
        (target.sourceUrl
          ? ({
              key: target.sourceKey,
              name: target.sourceName ?? target.sourceKey,
              url: target.sourceUrl,
            } as SourceConfig)
          : undefined);
      return source ? { source, id: target.vodId } : undefined;
    },
    [sources]
  );

  const mark = useCallback((keys: string[], value: boolean) => {
    setProbing((prev) => {
      const next = { ...prev };
      for (const key of keys) {
        if (value) next[key] = true;
        else delete next[key];
      }
      return next;
    });
  }, []);

  /**
   * 超时自动补一次。
   * 失败里只有超时是「这次没够着」——冷启动、CDN 抖动、源站响应慢;
   * 同一条请求 300ms 后再打一次成功率明显更高,可避免把可用源标成「未测到」。
   * 只补一次:retriedRef 记住已重试的键,仍失败就交给用户手动重试。
   */
  const scheduleTimeoutRetry = useCallback(
    (collected: Record<string, QualityEntry>, targetByKey: Map<string, QualityProbeTarget>) => {
      const retries: QualityProbeTarget[] = [];
      for (const [key, entry] of Object.entries(collected)) {
        if (!isRetryableTimeout(entry.error)) continue;
        if (retriedRef.current.has(key)) continue;
        const target = targetByKey.get(key);
        if (!target) continue;
        retriedRef.current.add(key);
        retries.push(target);
      }
      if (retries.length === 0) return;
      setTimeout(() => {
        if (!mountedRef.current) return;
        probeRef.current?.(retries, { force: true });
      }, 300);
    },
    []
  );

  /** 读取缓存并把目标登记为「进度分母」:卡片收起时也能显示最高画质 */
  const prime = useCallback((items: QualityProbeTarget[]) => {
    const list = dedupeByKey(items);
    setTargets(list);
    if (list.length === 0) return;
    const cached = readQualities(list.map((i) => ({ sourceKey: i.sourceKey, vodId: i.vodId })));
    if (Object.keys(cached).length > 0) setQualities((prev) => ({ ...cached, ...prev }));
  }, []);

  const probe = useCallback(
    (items: QualityProbeTarget[], opts?: { force?: boolean }) => {
      const list = dedupeByKey(items);
      if (list.length === 0) return;
      setTargets(list);

      const cached = readQualities(list.map((i) => ({ sourceKey: i.sourceKey, vodId: i.vodId })));
      setQualities((prev) => ({ ...cached, ...prev }));

      const force = opts?.force === true;
      const now = Date.now();
      const pending = list.filter((target) => {
        const key = qualityKey(target.sourceKey, target.vodId);
        if (inflightRef.current.has(key)) return false;
        if (force) return true;
        const known = cached[key] ?? qualitiesRef.current[key];
        // 已有结论(含「测不出」)是终态,重探还是同一个结果
        if (known && !known.error) return false;
        const last = settledRef.current.get(key);
        return last === undefined || now - last > QUALITY_FAIL_TTL_MS;
      });

      // 没有新要探的键:让上一批跑完,不打断它
      if (pending.length === 0) return;

      // 掐掉上一批并同步解锁:否则这些键既不在飞、又因 inflight 选不进本批,徽章会一直空着
      const previous = batchRef.current;
      if (previous.size > 0) {
        for (const key of previous) inflightRef.current.delete(key);
        mark([...previous], false);
      }
      batchRef.current.clear();
      abortRef.current?.abort();

      const mapped = pending
        .map((target) => {
          const item = resolveItem(target);
          return item ? { key: qualityKey(target.sourceKey, target.vodId), item } : undefined;
        })
        .filter((v): v is { key: string; item: QualityProbeItem } => Boolean(v));
      if (mapped.length === 0) return;

      const keys = mapped.map((m) => m.key);
      const targetByKey = new Map(list.map((t) => [qualityKey(t.sourceKey, t.vodId), t]));
      const batch = new Set(keys);
      // 结果先攒着,流结束一次性写全局:逐条写会让 persist 把整个 qualityMap(最多 400 条)序列化十几遍
      const collected: Record<string, QualityEntry> = {};
      for (const key of keys) inflightRef.current.add(key);
      batchRef.current = batch;
      mark(keys, true);

      const controller = new AbortController();
      abortRef.current = controller;

      api
        .qualityProbeStream(
          mapped.map((m) => m.item),
          (result) => {
            const key = qualityKey(result.sourceKey, result.vodId);
            const entry = toEntry(result);
            setQualities((prev) => ({ ...prev, [key]: entry }));
            collected[key] = entry;
            inflightRef.current.delete(key);
            settledRef.current.set(key, Date.now());
            // 探成功就忘掉「已重试过」:下次再超时仍然值得补一次
            if (!entry.error) retriedRef.current.delete(key);
            mark([key], false);
          },
          controller.signal
        )
        .catch((err: unknown) => {
          // 主动中止(新批接管 / 组件卸载)不是探测结论,保持「未知」
          if (err instanceof DOMException && err.name === 'AbortError') return;
          // 未登录:登录框已弹出,把每个源都标成失败只会误导
          if (err instanceof ApiError && (err.status === 401 || err.status === 503)) return;
          // 传输层失败(网关拦截 / 容器重启 / 断网):逐条落成失败结论,徽章上能看出原因。
          // 原先这里静默吞掉,界面只剩一片「未测到」,线上无从判断是哪一环挂了。
          const message = err instanceof Error && err.message ? err.message : '探测请求失败';
          const at = Date.now();
          for (const key of keys) {
            if (collected[key]) continue;
            collected[key] = { from: 'probe', error: message, timestamp: at };
            settledRef.current.set(key, at);
          }
          setQualities((prev) => ({ ...prev, ...collected }));
        })
        .finally(() => {
          if (Object.keys(collected).length > 0) useAppStore.getState().setQuality(collected);
          // 超时补一次放在接管守卫之前:结果已经拿到,是否被接管都不影响这一批的补探测
          scheduleTimeoutRetry(collected, targetByKey);
          // 被新一批接管时跳过清理:未完成的键已由新批同步段重新调度(finally 是 microtask,必然晚于它)
          if (batchRef.current !== batch) return;
          for (const key of batch) inflightRef.current.delete(key);
          batchRef.current.clear();
          mark(keys, false);
        });
    },
    [mark, resolveItem, scheduleTimeoutRetry]
  );
  // 延迟重试走的入口:scheduleTimeoutRetry 的定时器里不能直接用 probe(会捕获旧闭包)
  probeRef.current = probe;

  /**
   * 经全局队列探测(单源卡片进入视口)。
   * 不阻塞渲染、不打断直连批次:队列自己限并发,这里只负责把结果摊到本卡片上。
   */
  const probeQueued = useCallback(
    (items: QualityProbeTarget[]) => {
      const list = dedupeByKey(items);
      if (list.length === 0) return;
      setTargets(list);

      const cached = readQualities(list.map((i) => ({ sourceKey: i.sourceKey, vodId: i.vodId })));
      setQualities((prev) => ({ ...cached, ...prev }));

      const now = Date.now();
      const pending = list.filter((target) => {
        const key = qualityKey(target.sourceKey, target.vodId);
        if (inflightRef.current.has(key)) return false;
        const known = cached[key];
        if (known && !known.error) return false;
        const last = settledRef.current.get(key);
        return last === undefined || now - last > QUALITY_FAIL_TTL_MS;
      });

      const mapped = pending
        .map((target) => {
          const item = resolveItem(target);
          return item ? { key: qualityKey(target.sourceKey, target.vodId), item } : undefined;
        })
        .filter((v): v is { key: string; item: QualityProbeItem } => Boolean(v));
      if (mapped.length === 0) return;

      const keys = mapped.map((m) => m.key);
      for (const key of keys) {
        inflightRef.current.add(key);
        queuedRef.current.add(key);
      }

      void getSharedQueue()
        // 「探测中」在批次真正发出时才点亮:排队还没轮到就显示转圈是在说谎
        .push(mapped.map((m) => m.item), () => {
          if (mountedRef.current) mark(keys, true);
        })
        .then((results) => {
          const collected: Record<string, QualityEntry> = {};
          for (const result of Object.values(results)) {
            const key = qualityKey(result.sourceKey, result.vodId);
            collected[key] = toEntry(result);
            settledRef.current.set(key, Date.now());
          }
          // 「已取消」只说明我们没等,不是源站的回答:展示可以,但不该污染长期缓存
          const writable = Object.fromEntries(
            Object.entries(collected).filter(([, entry]) => entry.error !== '探测已取消')
          );
          if (mountedRef.current) setQualities((prev) => ({ ...prev, ...collected }));
          if (Object.keys(writable).length > 0) useAppStore.getState().setQuality(writable);
        })
        // 队列内部已兜住所有失败,这里只防意外异常变成 unhandled rejection
        .catch(() => {})
        .finally(() => {
          for (const key of keys) {
            inflightRef.current.delete(key);
            queuedRef.current.delete(key);
          }
          if (mountedRef.current) mark(keys, false);
        });
    },
    [mark, resolveItem]
  );

  /** 绕过失败冷却重探:只有用户明确点「重试」才走这里 */
  const retry = useCallback(
    (items: QualityProbeTarget[]) => {
      for (const item of items) settledRef.current.delete(qualityKey(item.sourceKey, item.vodId));
      probe(items, { force: true });
    },
    [probe]
  );

  const progress = useMemo<QualityProbeProgress>(() => {
    const entries = targets.map((t) => qualities[qualityKey(t.sourceKey, t.vodId)]);
    const summary = summarizeQuality(entries);
    return {
      total: targets.length,
      done: summary.total,
      known: summary.known,
      failed: summary.failed,
      best: summary.best,
    };
  }, [targets, qualities]);

  return { qualities, probing, progress, prime, probe, probeQueued, retry };
}