import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Observable, of, BehaviorSubject, forkJoin } from 'rxjs';
import { catchError, map, switchMap, shareReplay, first, tap, timeout } from 'rxjs/operators';
import { Video, VideoDetail, Comment } from '../models/video.model';
import { InstanceService, Provider } from './instance.service';
import { I18nService } from './i18n.service';
import { UserService } from './user.service';

export interface PagedResult<T> {
  items: T[];
  nextCursor?: string | null;
}

@Injectable({ providedIn: 'root' })
export class YoutubeApiService {
  private twitchAuthToken$ = new BehaviorSubject<string | null>(null);
  // Client ID renvoyé par le serveur avec le token (source de vérité côté back)
  private twitchServerClientId: string | null = null;
  // Quota exceeded flag to surface to UI components
  public quotaExceeded$ = new BehaviorSubject<boolean>(false);

  // Lightweight in-memory caches (session scope)
  private readonly CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
  private searchCache = new Map<string, { ts: number; data: PagedResult<Video> }>();
  private trendingCache = new Map<string, { ts: number; data: PagedResult<Video> }>();

  // ---- YouTube multi-key rotation ----
  private ytKeys: string[] = [];
  private ytKeyIndex = 0;
  private ytKeyBans = new Map<string, number>(); // key -> bannedUntil epoch ms
  // Ban duration (default 6h) can be overridden via window.YT_KEY_BAN_MS
  private readonly YT_KEY_BAN_MS = (() => {
    try { const v = Number((globalThis as any)?.YT_KEY_BAN_MS); return Number.isFinite(v) && v > 0 ? v : 6 * 60 * 60 * 1000; } catch { return 6 * 60 * 60 * 1000; }
  })();

  constructor(private http: HttpClient, private instances: InstanceService, private i18n: I18nService, private users: UserService) {
    this.getTwitchAuthToken().subscribe(this.twitchAuthToken$);
    this.ytKeys = this.loadYouTubeKeys();
  }

  /**
   * Langues acceptées pour les Shorts : langue d'interface + langue par
   * défaut des préférences + langues de transcripts (`downloadLanguages`).
   * Ex. UI en anglais + transcripts fr/en ⇒ ['en', 'fr'] : les Shorts sont
   * cherchés dans ces langues, jamais dans d'autres quand l'API le permet
   * (YouTube relevanceLanguage, PeerTube languageOneOf, Twitch language).
   */
  public getShortsLanguages(): string[] {
    const out: string[] = [];
    const push = (v: unknown) => {
      const base = String(v || '').trim().toLowerCase().split('-')[0];
      if (/^[a-z]{2,3}$/.test(base) && !out.includes(base)) out.push(base);
    };
    // 1) Préférences d'abord (l'UI guide la langue primaire des recherches).
    try { push(this.i18n.lang()); } catch {}
    try {
      const prefs = this.users.preferences() as { language?: unknown; downloadLanguages?: unknown } | null;
      push((prefs as any)?.language);
      const dl = (prefs as any)?.downloadLanguages;
      if (Array.isArray(dl)) for (const l of dl) push(l);
    } catch {}
    // 2) L'app ne propose que FR/EN : ces deux langues sont TOUJOURS acceptées
    //    (on filtre les autres uniquement quand le provider expose `language`).
    push('en');
    push('fr');
    return out;
  }

  /** Langue primaire (2 lettres) pour les APIs qui n'acceptent qu'un code ISO 639-1. */
  private primaryShortsLang2(): string | null {
    try {
      const langs = this.getShortsLanguages();
      const two = langs.find(l => l.length === 2);
      return two || null;
    } catch {
      return null;
    }
  }

  private normalizeDuration(raw: any): number {
    if (typeof raw === 'number' && Number.isFinite(raw)) {
      return raw > 0 ? Math.round(raw) : 0;
    }

    if (typeof raw === 'string') {
      const value = raw.trim();
      if (!value) return 0;

      const numeric = Number(value);
      if (Number.isFinite(numeric)) {
        return numeric > 0 ? Math.round(numeric) : 0;
      }

      const spaced = value.replace(/[,]/g, '').trim();
      const spaceMatch = spaced.match(/^(\d+)[\s]+(\d{1,2}):(\d{2})$/);
      if (spaceMatch) {
        const hours = Number(spaceMatch[1]);
        const minutes = Number(spaceMatch[2]);
        const seconds = Number(spaceMatch[3]);
        const total = hours * 3600 + minutes * 60 + seconds;
        if (total > 0) return total;
      }

      const colonized = value.replace(/[^0-9:]/g, '');
      if (colonized.includes(':')) {
        const segments = colonized.split(':').filter(Boolean).map(part => Number(part));
        if (segments.length >= 2 && segments.every(segment => Number.isFinite(segment))) {
          while (segments.length < 3) segments.unshift(0);
          const [hours, minutes, seconds] = segments.slice(-3);
          const total = hours * 3600 + minutes * 60 + seconds;
          if (total > 0) return total;
        }
      }
    }

    return 0;
  }

  // Some Odysee API responses return thumbnail URLs on hosts like "thumbs.odycdn.com"
  // that can be flaky or blocked by the browser. Prefer the canonical
  // "thumbnails.odycdn.com" host and ensure https scheme.
  private normalizeOdyseeThumb(url?: string): string {
    if (!url) return '';
    try {
      let u = String(url).trim();
      if (!u) return '';
      // Ensure protocol
      if (u.startsWith('//')) u = 'https:' + u;
      if (!/^https?:\/\//i.test(u)) u = 'https://' + u.replace(/^\/*/, '');
      // Replace non-canonical host variants
      try {
        const parsed = new URL(u);
        const host = parsed.hostname.toLowerCase();
        if (host === 'thumbs.odycdn.com' || host === 'thumb.odycdn.com') {
          parsed.hostname = 'thumbnails.odycdn.com';
          return parsed.toString();
        }
        // Already canonical
        return parsed.toString();
      } catch {
        // Fallback simple replace
        return u.replace('thumbs.odycdn.com', 'thumbnails.odycdn.com');
      }
    } catch {
      return url || '';
    }
  }

  // Build a proxied URL through our backend to avoid ORB/CORS on Odysee CDN
  private proxiedOdyseeThumb(url?: string): string {
    const norm = this.normalizeOdyseeThumb(url);
    if (!norm) return '';
    try {
      return `/proxy/api/img/odysee?u=${encodeURIComponent(norm)}`;
    } catch {
      return `/proxy/api/img/odysee?u=${encodeURIComponent(String(norm))}`;
    }
  }

  // ... (rest of the code remains the same)

  // ===================== Twitch Search Helpers =====================
  /**
   * Découpe une requête thème (ex. "cooking food Food Cooking Recipe") en
   * mots-clés unitaires exploitables par Helix : /search/channels et
   * /search/categories ne matchent que des noms proches, jamais de longues
   * phrases multi-mots. On retourne jusqu'à 3 mots distincts >= 3 lettres.
   */
  private twitchQueryKeywords(query: string, max = 3): string[] {
    const words = String(query || '')
      .toLowerCase()
      .split(/[^a-z0-9à-ÿ]+/i)
      .map(w => w.trim())
      .filter(w => w.length >= 3);
    const seen = new Set<string>();
    const out: string[] = [];
    for (const w of words) {
      if (seen.has(w)) continue;
      seen.add(w);
      out.push(w);
      if (out.length >= max) break;
    }
    // Repli : requête brute courte si aucun mot exploitable.
    if (!out.length) {
      const raw = String(query || '').trim();
      if (raw) out.push(raw.slice(0, 40));
    }
    return out;
  }

  private fetchTwitchChannelsForKeyword(token: string, headers: HttpHeaders, keyword: string, first: number, after = ''): Observable<any> {
    const q = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(keyword)}&first=${first}${after}`;
    const f = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(keyword)}&first=${first}${after}`;
    return this.http.get<any>(q, { headers }).pipe(
      catchError(() => this.http.get<any>(f, { headers }))
    );
  }

  private fetchTwitchCategoryForKeyword(token: string, headers: HttpHeaders, keyword: string): Observable<any> {
    const q = `/api/twitch-api/helix/search/categories?query=${encodeURIComponent(keyword)}&first=5`;
    const f = `/proxy/twitch-api/helix/search/categories?query=${encodeURIComponent(keyword)}&first=5`;
    return this.http.get<any>(q, { headers }).pipe(
      catchError(() => this.http.get<any>(f, { headers }))
    );
  }

  /** Chaînes Twitch (lives + hors-ligne) pour une requête, façon directory. */
  public searchTwitchAllChannelsPage(query: string, cursor?: string | null, limit = 20): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        const q = String(query || '').trim();
        if (!q) return of({ items: [], nextCursor: null });
        // 1) Essai requête complète d'abord (pertinent pour "just chatting", noms de jeux...).
        return this.fetchTwitchChannelsForKeyword(token, headers, q, limit, after).pipe(
          switchMap(res => {
            const list = Array.isArray(res?.data) ? res.data : [];
            if (list.length > 0 || cursor) {
              return of({
                items: list.map((i: any) => this.mapTwitchChannelToVideo(i)),
                nextCursor: res?.pagination?.cursor || null,
              } as PagedResult<Video>);
            }
            // 2) Repli mot-à-mot : chaque mot-clé testé séparément, résultats fusionnés.
            const keywords = this.twitchQueryKeywords(q, 3);
            if (!keywords.length) return of({ items: [], nextCursor: null } as PagedResult<Video>);
            const calls = keywords.map(k =>
              this.fetchTwitchChannelsForKeyword(token, headers, k, Math.min(10, limit)).pipe(
                catchError(() => of({ data: [], pagination: {} }))
              )
            );
            return forkJoin(calls).pipe(
              map((responses: any[]) => {
                const seen = new Set<string>();
                const merged: any[] = [];
                let next: string | null = null;
                for (const r of responses) {
                  const arr = Array.isArray(r?.data) ? r.data : [];
                  if (!next && r?.pagination?.cursor) next = r.pagination.cursor;
                  for (const c of arr) {
                    const key = String(c?.id || c?.broadcaster_login || c?.display_name || '');
                    if (!key || seen.has(key)) continue;
                    seen.add(key);
                    merged.push(c);
                  }
                }
                return {
                  items: merged.slice(0, limit).map((i: any) => this.mapTwitchChannelToVideo(i)),
                  nextCursor: next,
                } as PagedResult<Video>;
              })
            );
          }),
          catchError((e) => { console.error('Twitch search channels error', e); return of({ items: [], nextCursor: null }); })
        );
      })
    );
  }

  /** Catégorie Twitch la plus pertinente (ex. "sports" -> Sports + box-art). */
  public searchTwitchCategory(query: string): Observable<{ id: string; name: string; boxArtUrl?: string } | null> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of(null);
        const q = String(query || '').trim();
        if (!q) return of(null);
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        // Essaie la requête complète puis chaque mot-clé (une longue phrase ne matche jamais une catégorie).
        const attempts = [q, ...this.twitchQueryKeywords(q, 3).filter(k => k !== q.toLowerCase())];
        const calls = attempts.slice(0, 4).map(a =>
          this.fetchTwitchCategoryForKeyword(token, headers, a).pipe(
            map(res => ({ attempt: a, list: Array.isArray(res?.data) ? res.data : [] })),
            catchError(() => of({ attempt: a, list: [] }))
          )
        );
        // Séquentiel : premier match exact, sinon premier non-vide.
        const tryNext = (idx: number): Observable<{ id: string; name: string; boxArtUrl?: string } | null> => {
          if (idx >= calls.length) return of(null);
          return calls[idx].pipe(
            switchMap(({ attempt, list }: any) => {
              if (list.length) {
                const needle = String(attempt || '').toLowerCase();
                const exact = list.find((c: any) => String(c?.name || '').toLowerCase() === needle);
                const best = exact || list[0];
                if (best?.id) return of({ id: String(best.id), name: String(best.name || ''), boxArtUrl: best.box_art_url || undefined });
              }
              return tryNext(idx + 1);
            })
          );
        };
        return tryNext(0).pipe(catchError(() => of(null)));
      })
    );
  }

  /** Top streams d'une catégorie Twitch (directory/category façon twitch.tv). */
  public getTwitchGameStreamsPage(gameId: string, cursor?: string | null, limit = 24): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        const langParam = this.primaryShortsLang2() ? `&language=${encodeURIComponent(this.primaryShortsLang2() as string)}` : '';
        const primary = `/api/twitch-api/helix/streams?game_id=${encodeURIComponent(gameId)}&first=${limit}${after}${langParam}`;
        const fallback = `/proxy/twitch-api/helix/streams?game_id=${encodeURIComponent(gameId)}&first=${limit}${after}${langParam}`;
        return this.http.get<any>(primary, { headers }).pipe(
          catchError(() => this.http.get<any>(fallback, { headers })),
          map(res => ({
            items: (res.data || []).map((i: any) => this.mapTwitchStreamToVideo(i)),
            nextCursor: res.pagination?.cursor || null,
          } as PagedResult<Video>)),
          catchError((e) => { console.error('Twitch game streams error', e); return of({ items: [], nextCursor: null }); })
        );
      })
    );
  }

  /** Search live channels matching query (around 20), with pagination cursor. */
  public searchTwitchChannelsPage(query: string, cursor?: string | null): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        const primary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=20&live_only=true${after}`;
        const fallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=20&live_only=true${after}`;
        return this.http.get<any>(primary, { headers }).pipe(
          catchError(() => this.http.get<any>(fallback, { headers })),
          switchMap(res => {
            const data = Array.isArray(res?.data) ? res.data : [];
            const live = data.filter((i: any) => i?.is_live === true).slice(0, 20);
            const baseItems = live.map((i: any) => this.mapTwitchChannelToVideo(i));
            const logins: string[] = live.map((i: any) => i?.broadcaster_login || i?.user_login).filter(Boolean);
            if (logins.length === 0) {
              return of({ items: baseItems, nextCursor: res?.pagination?.cursor || null } as PagedResult<Video>);
            }
            // Fetch viewer counts for these channels
            const queryLogins = logins.map(l => `user_login=${encodeURIComponent(l)}`).join('&');
            const sPrimary = `/api/twitch-api/helix/streams?${queryLogins}`;
            const sFallback = `/proxy/twitch-api/helix/streams?${queryLogins}`;
            return this.http.get<any>(sPrimary, { headers }).pipe(
              catchError(() => this.http.get<any>(sFallback, { headers })),
              map((sres: any) => {
                const streams: any[] = Array.isArray(sres?.data) ? sres.data : [];
                const vc = new Map<string, number>();
                for (const s of streams) {
                  const login = s?.user_login || s?.broadcaster_login;
                  if (login) vc.set(String(login).toLowerCase(), Number(s?.viewer_count || 0));
                }
                const items = baseItems.map((v: Video) => {
                  const key = String(v.videoId || '').toLowerCase();
                  const views = vc.get(key);
                  return typeof views === 'number' ? { ...v, views } : v;
                });
                return { items, nextCursor: res?.pagination?.cursor || null } as PagedResult<Video>;
              }),
              catchError(() => of({ items: baseItems, nextCursor: res?.pagination?.cursor || null } as PagedResult<Video>))
            );
          }),
          catchError((e) => { console.error('Twitch search channels error', e); return of({ items: [], nextCursor: null }); })
        );
      })
    );
  }

  /** Search VODs: find channels by query then fetch recent videos per channel; flatten to ~20. */
  public searchTwitchVodsPage(query: string, cursor?: string | null): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const q = String(query || '').trim();
        if (!q) return of({ items: [], nextCursor: null });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        // Chaînes candidates : requête complète + mots-clés unitaires (Helix ne matche pas les phrases).
        const keywords = [q, ...this.twitchQueryKeywords(q, 3).filter(k => k !== q.toLowerCase())].slice(0, 4);
        const channelCalls = keywords.map((k, idx) =>
          this.fetchTwitchChannelsForKeyword(token, headers, k, 10, idx === 0 ? after : '').pipe(
            catchError(() => of({ data: [], pagination: {} }))
          )
        );
        return forkJoin(channelCalls).pipe(
          switchMap((responses: any[]) => {
            const seenCh = new Set<string>();
            const channels: any[] = [];
            let next: string | null = null;
            for (const r of responses) {
              const arr = Array.isArray(r?.data) ? r.data : [];
              if (!next && r?.pagination?.cursor) next = r.pagination.cursor;
              for (const c of arr) {
                const key = String(c?.id || '');
                if (!key || seenCh.has(key)) continue;
                seenCh.add(key);
                channels.push(c);
              }
            }
            const userIds: string[] = channels.map((c: any) => c?.id).filter(Boolean).slice(0, 6);
            // Langue de l'utilisateur (filtre natif Helix /videos).
            const vodLang = this.primaryShortsLang2() ? `&language=${encodeURIComponent(this.primaryShortsLang2() as string)}` : '';
            const fetchVodsForUsers = (ids: string[]) => {
              if (!ids.length) return of([] as any[]);
              // Fan-out réduit : 6 chaînes × 6 VODs suffisent, le budget
              // taux/quota Helix et la limite de 6 connexions navigateur
              // remercient (une page Explore en lance déjà 4 sections).
              const perUserRequests = ids.slice(0, 6).map(uid => {
                // type=all to include archive, upload, highlight; fetch a few more to increase hit rate
                const vPrimary = `/api/twitch-api/helix/videos?user_id=${encodeURIComponent(uid)}&first=6&type=all${vodLang}`;
                const vFallback = `/proxy/twitch-api/helix/videos?user_id=${encodeURIComponent(uid)}&first=6&type=all${vodLang}`;
                return this.http.get<any>(vPrimary, { headers }).pipe(
                  catchError(() => this.http.get<any>(vFallback, { headers })),
                  map(vres => Array.isArray(vres?.data) ? vres.data : []),
                  catchError(() => of([] as any[]))
                );
              });
              return forkJoin(perUserRequests).pipe(map((lists: any[][]) => lists.flat()));
            };
            // Complément par catégorie (game_id) quand les chaînes ne suffisent pas (thèmes génériques).
            const fetchVodsByCategory = (): Observable<any[]> => {
              const cats = this.twitchQueryKeywords(q, 2);
              if (!cats.length) return of([]);
              const catCalls = cats.slice(0, 2).map(k =>
                this.fetchTwitchCategoryForKeyword(token, headers, k).pipe(catchError(() => of({ data: [] })))
              );
              return forkJoin(catCalls).pipe(
                switchMap((catRes: any[]) => {
                  const gameIds: string[] = [];
                  for (const cr of catRes) {
                    const list = Array.isArray(cr?.data) ? cr.data : [];
                    if (list[0]?.id) gameIds.push(String(list[0].id));
                  }
                  if (!gameIds.length) return of([]);
                  const gameCalls = gameIds.slice(0, 2).map(gid => {
                    const gPrimary = `/api/twitch-api/helix/videos?game_id=${encodeURIComponent(gid)}&first=10&sort=trending&type=all${vodLang}`;
                    const gFallback = `/proxy/twitch-api/helix/videos?game_id=${encodeURIComponent(gid)}&first=10&sort=trending&type=all${vodLang}`;
                    return this.http.get<any>(gPrimary, { headers }).pipe(
                      catchError(() => this.http.get<any>(gFallback, { headers })),
                      map(vres => Array.isArray(vres?.data) ? vres.data : []),
                      catchError(() => of([] as any[]))
                    );
                  });
                  return forkJoin(gameCalls).pipe(map((lists: any[][]) => lists.flat()));
                })
              );
            };
            return fetchVodsForUsers(userIds).pipe(
              switchMap(vodsByUser => {
                if (vodsByUser.length >= 4) {
                  return of({
                    items: vodsByUser.slice(0, 20).map((i: any) => this.mapTwitchItemToVideo(i)),
                    nextCursor: next,
                  } as PagedResult<Video>);
                }
                return fetchVodsByCategory().pipe(
                  map(vodsByGame => ({
                    items: [...vodsByUser, ...vodsByGame].slice(0, 20).map((i: any) => this.mapTwitchItemToVideo(i)),
                    nextCursor: next,
                  } as PagedResult<Video>))
                );
              })
            );
          }),
          catchError((e) => { console.error('Twitch search VODs error', e); return of({ items: [], nextCursor: null }); })
        );
      })
    );
  }

  private fetchOdysee(body: any) {
    const prod = `/api/odysee/api/v1/proxy`;
    const dev = `/proxy/odysee/api/v1/proxy`;
    return this.http.post<any>(prod, body).pipe(
      catchError(() => this.http.post<any>(dev, body))
    );
  }

  private lbryToOdyseeUrl(lbryUrl: string): string {
    if (!lbryUrl || typeof lbryUrl !== 'string') return '';
    // Convert lbry://@Channel#id/Video#id => https://odysee.com/@Channel:id/Video:id
    try {
      const noScheme = lbryUrl.replace('lbry://', '');
      const parts = noScheme.split('/');
      const segs = parts.map(seg => seg.replace('#', ':'));
      return `https://odysee.com/${segs.join('/')}`;
    } catch {
      return '';
    }
  }

  getTrendingVideos(): Observable<Video[]> {
    return this.getTrendingPage().pipe(map(r => r.items));
  }

  searchVideos(query: string): Observable<Video[]> {
    return this.searchVideosPage(query).pipe(map(r => r.items));
  }

  getVideoDetails(id: string): Observable<VideoDetail | null> {
    // Not implemented yet per-provider; return null so Watch page shows fallback.
    return of(null);
  }

  // Pagination-enabled APIs
  getTrendingPage(cursor?: string | null, providerOverride?: Provider | null): Observable<PagedResult<Video>> {
    const provider = providerOverride || this.instances.selectedProvider();
    const region = this.instances.region();
    switch (provider) {
      case 'youtube': {
        const key = this.getActiveYouTubeKey();
        if (!key) {
          console.warn('YOUTUBE_API_KEY not found. Set it to enable YouTube trending.');
          return of({ items: [], nextCursor: null });
        }
        const params = new URLSearchParams({
          chart: 'mostPopular',
          regionCode: String(region),
          maxResults: '24',
          // Optimize quota usage: only get essential parts
          part: 'snippet,contentDetails,statistics',
          // Add safeSearch for better content filtering
          safeSearch: 'moderate',
          // Video category for trending (Music = 10, Gaming = 20, etc.)
          videoCategoryId: '0', // All categories
          key: String(key),
        });

        if (cursor) params.set('pageToken', cursor);
        // Cache key: provider|chart|region|cursor
        const cacheKey = `yt:trending|${region}|${cursor || ''}`;
        const cached = this.trendingCache.get(cacheKey);
        const now = Date.now();
        if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
          return of(cached.data);
        }
        const path = `/youtube/v3/videos`;
        return this.fetchYouTube(path, params, key).pipe(
          map(res => ({
            items: (res.items || []).map((i: any) => this.mapYouTubeItemToVideo(i)),
            nextCursor: res.nextPageToken || null,
          } as PagedResult<Video>)),
          map((out) => {
            this.trendingCache.set(cacheKey, { ts: now, data: out });
            return out;
          }),
          catchError((e) => {
            // Surface quotaExceeded if present + ban dead keys (quota ou clé expirée/invalide)
            try {
              const reason = e?.error?.error?.errors?.[0]?.reason || '';
              const msg = String(e?.error?.error?.message || e?.message || '');
              if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
                this.quotaExceeded$.next(true);
                this.banYouTubeKey(key);
              } else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
                this.banYouTubeKey(key);
              }
            } catch {}
            console.error('YouTube trending error', e);
            return of({ items: [], nextCursor: null });
          })
        );
      }
      case 'odysee': {
        // Use LBRY/Odysee claim_search with trending order
        const page = cursor ? Number(cursor) : 1;
        const body = {
          method: 'claim_search',
          params: {
            page: page,
            page_size: 24,
            no_totals: true,
            claim_type: 'stream',
            stream_types: ['video'],
            order_by: ['trending_group', 'trending_mixed']
          }
        };
        return this.fetchOdysee(body).pipe(
          map(res => {
            const items = (res?.result?.items || res?.result?.claims || res?.items || []) as any[];
            return {
              items: items.map(i => this.mapOdyseeItemToVideo(i)),
              nextCursor: items.length > 0 ? String(page + 1) : null,
            } as PagedResult<Video>;
          }),
          catchError((e) => { console.error('Odysee trending error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'dailymotion': {
        const page = cursor ? String(cursor) : '1';
        const limit = 24;
        const params = new URLSearchParams({
          sort: 'trending',
          limit: String(limit),
          page: String(page),
          country: String(region).toLowerCase(),
          fields: 'id,title,thumbnail_url,thumbnail_480_url,thumbnail_720_url,duration,views_total,language,allow_embed,owner.id,owner.screenname,owner.avatar_80_url,created_time',
        });
        return this.fetchDailymotion('/videos', params).pipe(
          map(res => {
            const list = (res.list || res.result || res.items || res.data || []) as any[];
            const currentPage = Number(page) || 1;
            const hasMore = typeof res.has_more === 'boolean' ? res.has_more : (list.length === limit);
            return {
              items: list.map((i: any) => this.mapDailymotionItemToVideo(i)),
              nextCursor: hasMore ? String(currentPage + 1) : null,
            } as PagedResult<Video>;
          }),
          catchError((e) => { console.error('Dailymotion trending error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'twitch': {
        // Use Helix Streams for a "trending" like experience (popular live streams)
        return this.getTwitchTopStreamsPage(cursor);
      }
      case 'rumble': {
        // Rumble utilise maintenant le web scraping côté serveur, pas d'API key requise
        const page = cursor ? Number(cursor) : 1;
        const params = new URLSearchParams({
          sort: 'trending',
          limit: '24',
          page: String(page),
        });
        return this.fetchRumble('/browse', params).pipe(
          map(res => {
            const list = (res?.items || res?.result || res?.data || []) as any[];
            const backendCursor = res?.nextCursor != null ? String(res.nextCursor) : null;
            const next = backendCursor ?? (list.length > 0 ? String(page + 1) : null);
            return {
              items: list.map(i => this.mapRumbleItemToVideo(i)),
              nextCursor: next,
            } as PagedResult<Video>;
          }),
          catchError((e) => { console.error('Rumble trending error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'peertube': {
        const instance = this.instances.activePeerTubeInstance();
        const start = cursor ? Number(cursor) : 0;
        const primary = `/api/peertube/${instance}/api/v1/videos?sort=-trending&count=24&start=${start}`;
        const fallback = `/proxy/api/peertube/${instance}/api/v1/videos?sort=-trending&count=24&start=${start}`;
        return this.http.get<any>(primary).pipe(
          catchError(() => this.http.get<any>(fallback)),
          map(res => ({
            items: (res.data || []).map((i: any) => this.mapPeerTubeItemToVideo(i, instance)),
            nextCursor: res.data?.length > 0 ? String(start + 24) : null,
          } as PagedResult<Video>)),
          catchError((e) => { console.error(`PeerTube (${instance}) trending error`, e); return of({ items: [], nextCursor: null }); })
        );
      }
      default:
        console.warn('Provider not yet implemented for trending:', provider);
        return of({ items: [], nextCursor: null });
    }
  }

  searchVideosPage(query: string, cursor?: string | null, providerOverride?: Provider | null): Observable<PagedResult<Video>> {
    const provider = providerOverride || this.instances.selectedProvider();
    const region = this.instances.region();
    if (!query) return of({ items: [], nextCursor: null });
    switch (provider) {
      case 'youtube': {
        const key = this.getActiveYouTubeKey();
        if (!key) return of({ items: [], nextCursor: null });
        const params = new URLSearchParams({
          type: 'video',
          // search.list only supports 'snippet'
          part: 'snippet',
          // Optimize for quota usage: reduce initial results
          maxResults: '25',
          q: String(query),
          regionCode: String(region),
          // Add safeSearch for better content filtering
          safeSearch: 'moderate',
          // Only return videos playable in an iframe (avoids player error 153).
          videoEmbeddable: 'true',
          key: String(key),
        });
        // Prefer results matching user's language when available
        try {
          const lang = String(this.i18n.lang()).toLowerCase();
          if (lang) params.set('relevanceLanguage', lang);
        } catch {}
        if (cursor) params.set('pageToken', cursor);
        // Cache key: provider|search|region|query|cursor
        const cacheKey = `yt:search|${region}|${query}|${cursor || ''}`;
        const cached = this.searchCache.get(cacheKey);
        const now = Date.now();
        if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
          return of(cached.data);
        }
        const path = `/youtube/v3/search`;
        return this.fetchYouTube(path, params, key).pipe(
          map(res => ({
            items: (res.items || []).map((i: any) => this.mapYouTubeSearchItemToVideo(i)),
            nextCursor: res.nextPageToken || null,
          } as PagedResult<Video>)),
          // Enrich with durations and view counts
          switchMap((out) => {
            const ids = out.items.map(v => v.videoId).filter(Boolean);
            if (!ids.length) return of(out);
            return this.getYouTubeContentAndStats(ids).pipe(
              map((stats) => {
                const enriched = out.items.map(v => {
                  const s = stats[v.videoId];
                  if (!s) return v;
                  // duration -1 = non-embeddable (erreur 153) : on garde la
                  // vidéo en recherche (avec durée 0) mais les Shorts la filtrent.
                  const duration = typeof s.duration === 'number' && s.duration >= 0 ? s.duration : 0;
                  return { ...v, duration, views: s.views };
                });
                const next = { ...out, items: enriched } as PagedResult<Video>;
                this.searchCache.set(cacheKey, { ts: now, data: next });
                return next;
              })
            );
          }),
          catchError((e) => {
            // Surface quotaExceeded if present + ban dead keys (quota ou clé expirée/invalide)
            try {
              const reason = e?.error?.error?.errors?.[0]?.reason || '';
              const msg = String(e?.error?.error?.message || e?.message || '');
              if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
                this.quotaExceeded$.next(true);
                this.banYouTubeKey(key);
              } else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
                this.banYouTubeKey(key);
              }
            } catch {}
            console.error('YouTube search error', e);
            return of({ items: [], nextCursor: null });
          })
        );
      }
      case 'odysee': {
        const page = cursor ? Number(cursor) : 1;
        const body = {
          method: 'claim_search',
          params: {
            page: page,
            page_size: 24,
            no_totals: true,
            claim_type: 'stream',
            stream_types: ['video'],
            text: String(query),
            order_by: ['trending_group', 'trending_mixed']
          }
        };
        return this.fetchOdysee(body).pipe(
          map(res => {
            const items = (res?.result?.items || res?.result?.claims || res?.items || []) as any[];
            return {
              items: items.map(i => this.mapOdyseeItemToVideo(i)),
              nextCursor: items.length > 0 ? String(page + 1) : null,
            } as PagedResult<Video>;
          }),
          catchError((e) => { console.error('Odysee search error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'dailymotion': {
        const page = cursor ? String(cursor) : '1';
        const limit = 24;
        const params = new URLSearchParams({
          limit: String(limit),
          page: String(page),
          country: String(region).toLowerCase(),
          fields: 'id,title,thumbnail_url,thumbnail_480_url,thumbnail_720_url,duration,views_total,owner.screenname,owner.avatar_80_url,created_time',
          search: String(query),
        });
        return this.fetchDailymotion('/videos', params).pipe(
          map(res => {
            const list = (res.list || res.result || res.items || res.data || []) as any[];
            const currentPage = Number(page) || 1;
            const hasMore = typeof res.has_more === 'boolean' ? res.has_more : (list.length === limit);
            return {
              items: list.map((i: any) => this.mapDailymotionItemToVideo(i)),
              nextCursor: hasMore ? String(currentPage + 1) : null,
            } as PagedResult<Video>;
          }),
          catchError((e) => { console.error('Dailymotion search error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'rumble': {
        // Rumble utilise maintenant le web scraping côté serveur, pas d'API key requise
        const limit = 24;
        const offset = cursor ? Number(cursor) : 0;
        const params = new URLSearchParams({
          q: String(query),
          limit: String(limit),
          offset: String(offset),
        });
        return this.fetchRumble('/search', params).pipe(
          map(res => {
            const list = (res?.items || res?.result || res?.data || []) as any[];
            // Prefer backend-provided nextCursor if present (page-based). Translate it to offset-based cursor for the frontend.
            let next: string | null = null;
            if (res?.nextCursor != null && res?.page != null && res?.limit != null) {
              try {
                const nextPage = Number(res.nextCursor);
                const perPage = Number(res.limit);
                if (!isNaN(nextPage) && !isNaN(perPage)) next = String((nextPage - 1) * perPage);
              } catch {}
            }
            if (next == null) {
              const hasMore = list.length === limit;
              next = hasMore ? String(offset + limit) : null;
            }
            return {
              items: list.map(i => this.mapRumbleItemToVideo(i)),
              nextCursor: next,
            } as PagedResult<Video>;
          }),
          // Si la recherche est vide (scraper challengé / page changée),
          // repli sur le flux trending pour ne jamais afficher un bloc vide.
          switchMap(out => {
            if ((out?.items?.length || 0) > 0) return of(out);
            const page = 1;
            const bParams = new URLSearchParams({ sort: 'trending', limit: '24', page: String(page) });
            return this.fetchRumble('/browse', bParams).pipe(
              map(res => {
                const list = (res?.items || res?.result || res?.data || []) as any[];
                return { items: list.map(i => this.mapRumbleItemToVideo(i)), nextCursor: null } as PagedResult<Video>;
              }),
              catchError(() => of(out))
            );
          }),
          catchError((e) => { console.error('Rumble search error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'twitch': {
        // Recherche thématique robuste : chaînes live d'abord, puis VODs +
        // clips, avec fallback top streams (évite les blocs vides sur les
        // pages de thèmes où la recherche Helix pure ne matche rien).
        return this.getTwitchAuthToken().pipe(timeout(30000),
          switchMap(token => {
            if (!token) return of({ items: [], nextCursor: null });
            const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
            const primary = `/api/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=24&after=${cursor || ''}&live_only=true`;
            const fallback = `/proxy/twitch-api/helix/search/channels?query=${encodeURIComponent(query)}&first=24&after=${cursor || ''}&live_only=true`;
            return this.http.get<any>(primary, { headers }).pipe(
              catchError(() => this.http.get<any>(fallback, { headers })),
              map(res => {
                const data = Array.isArray(res?.data) ? res.data : [];
                const live = data.filter((i: any) => i?.is_live === true);
                return {
                  items: live.map((i: any) => this.mapTwitchChannelToVideo(i)),
                  nextCursor: res.pagination?.cursor || null,
                } as PagedResult<Video>;
              }),
              // Si la recherche live est vide/maigre, compléter avec VODs+clips puis top streams.
              switchMap(liveRes => {
                if ((liveRes?.items?.length || 0) >= 4) return of(liveRes);
                return this.searchTwitchThemePage(query, cursor).pipe(
                  map(themeRes => {
                    const seen = new Set((liveRes.items || []).map(v => v.videoId));
                    const extra = (themeRes?.items || []).filter(v => !seen.has(v.videoId));
                    return { items: [...(liveRes.items || []), ...extra], nextCursor: themeRes?.nextCursor || liveRes.nextCursor } as PagedResult<Video>;
                  }),
                  catchError(() => of(liveRes))
                );
              }),
              catchError((e) => { console.error('Twitch search error', e); return of({ items: [], nextCursor: null }); })
            );
          })
        );
      }
      case 'peertube': {
        const instance = this.instances.activePeerTubeInstance();
        const start = cursor ? Number(cursor) : 0;
        const primary = `/api/peertube/${instance}/api/v1/search/videos?search=${encodeURIComponent(query)}&count=24&start=${start}`;
        const fallback = `/proxy/api/peertube/${instance}/api/v1/search/videos?search=${encodeURIComponent(query)}&count=24&start=${start}`;
        return this.http.get<any>(primary).pipe(
          catchError(() => this.http.get<any>(fallback)),
          map(res => ({
            items: (res.data || []).map((i: any) => this.mapPeerTubeItemToVideo(i, instance)),
            nextCursor: res.data?.length > 0 ? String(start + 24) : null,
          } as PagedResult<Video>)),
          catchError((e) => { console.error(`PeerTube (${instance}) search error`, e); return of({ items: [], nextCursor: null }); })
        );
      }
      default:
        return of({ items: [], nextCursor: null });
    }
  }

  // YouTube mappers
  private mapYouTubeItemToVideo = (i: any): Video => {
    const id = i.id;
    const sn = i.snippet || {};
    const stats = i.statistics || {};
    const cd = i.contentDetails || {};
    const thumb = sn.thumbnails?.high?.url || sn.thumbnails?.medium?.url || sn.thumbnails?.default?.url || '';
    const publishedAt = sn.publishedAt || '';
    const channelId = sn.channelId || '';
    return {
      url: `/watch/${id}`,
      videoId: id,
      type: 'video',
      provider: 'youtube',
      title: sn.title || '',
      thumbnail: thumb,
      uploaderName: sn.channelTitle || '',
      uploaderUrl: channelId ? `https://www.youtube.com/channel/${channelId}` : '',
      // Ne jamais utiliser la miniature vidéo comme avatar chaîne : la page /watch
      // résout le vrai avatar via /api/details puis /api/channels, avec fallback initiales.
      uploaderAvatar: '',
      channelId: channelId || undefined,
      channelExternalId: channelId || undefined,
      channelAvatarUrl: undefined,
      uploadedDate: publishedAt,
      duration: this.parseISODurationToSeconds(cd.duration || 'PT0S'),
      views: Number(stats.viewCount || 0),
      uploaded: publishedAt ? Date.parse(publishedAt) : 0,
    } as Video;
  };

  private mapYouTubeSearchItemToVideo = (i: any, live = false): Video => {
    const id = i.id?.videoId || i.id;
    const sn = i.snippet || {};
    const thumb = sn.thumbnails?.high?.url || sn.thumbnails?.medium?.url || sn.thumbnails?.default?.url || '';
    const publishedAt = sn.publishedAt || '';
    const channelId = sn.channelId || '';
    // liveBroadcastContent === 'live' => réellement en direct ; 'upcoming' => à venir
    const broadcast = String(sn?.liveBroadcastContent || '').toLowerCase();
    const isLive = live || broadcast === 'live';
    return {
      url: `/watch/${id}`,
      videoId: id,
      type: isLive ? 'live' : 'video',
      provider: 'youtube',
      title: sn.title || '',
      thumbnail: thumb,
      uploaderName: sn.channelTitle || '',
      uploaderUrl: channelId ? `https://www.youtube.com/channel/${channelId}` : '',
      uploaderAvatar: '',
      channelId: channelId || undefined,
      channelExternalId: channelId || undefined,
      channelAvatarUrl: undefined,
      uploadedDate: publishedAt,
      duration: 0,
      views: 0,
      uploaded: publishedAt ? Date.parse(publishedAt) : 0,
      isLive,
    } as Video;
  };

  /**
   * Recherche de directs YouTube (search.list eventType=live + type=video).
   * Contrairement à une recherche textuelle "live", ne retourne que des
   * diffusions réellement en direct. `query` optionnel : sans requête on
   * cherche "live" avec le filtre live pour garantir des résultats.
   */
  public searchYouTubeLivePage(query?: string, cursor?: string | null): Observable<PagedResult<Video>> {
    const region = this.instances.region();
    const key = this.getActiveYouTubeKey();
    if (!key) return of({ items: [], nextCursor: null });
    const q = String(query || '').trim() || 'live';
    const params = new URLSearchParams({
      type: 'video',
      part: 'snippet',
      maxResults: '25',
      q,
      regionCode: String(region),
      safeSearch: 'moderate',
      videoEmbeddable: 'true',
      eventType: 'live',
      order: 'viewCount',
      key: String(key),
    });
    if (cursor) params.set('pageToken', cursor);
    const cacheKey = `yt:live|${region}|${q}|${cursor || ''}`;
    const cached = this.searchCache.get(cacheKey);
    const now = Date.now();
    if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
      return of(cached.data);
    }
    const path = `/youtube/v3/search`;
    return this.fetchYouTube(path, params, key).pipe(
      map(res => ({
        items: (res.items || []).map((i: any) => this.mapYouTubeSearchItemToVideo(i, true)),
        nextCursor: res.nextPageToken || null,
      } as PagedResult<Video>)),
      switchMap((out) => {
        const ids = out.items.map(v => v.videoId).filter(Boolean);
        if (!ids.length) return of(out);
        return this.getYouTubeContentAndStats(ids).pipe(
          map((stats) => {
            const enriched = out.items.map(v => {
              const s = stats[v.videoId];
              if (!s) return v;
              const duration = typeof s.duration === 'number' && s.duration >= 0 ? s.duration : 0;
              return { ...v, duration, views: s.views, type: 'live', isLive: true };
            });
            const next = { ...out, items: enriched } as PagedResult<Video>;
            this.searchCache.set(cacheKey, { ts: now, data: next });
            return next;
          })
        );
      }),
      catchError((e) => {
        try {
          const reason = e?.error?.error?.errors?.[0]?.reason || '';
          const msg = String(e?.error?.error?.message || e?.message || '');
          if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
            this.quotaExceeded$.next(true);
            this.banYouTubeKey(key);
          } else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
            this.banYouTubeKey(key);
          }
        } catch {}
        console.error('YouTube live search error', e);
        return of({ items: [], nextCursor: null });
      })
    );
  }

  /**
   * Flux Shorts par provider (page #/shorts).
   * Contrairement à une recherche plein-texte "shorts" (qui retourne surtout
   * des vidéos longues ensuite éliminées par le filtre client), on filtre la
   * durée côté serveur quand l'API le permet :
   *  - YouTube : search.list `videoDuration=short` (< 4 min), resserré à ≤70 s côté client.
   *  - Dailymotion : `shorter_than=2` (en minutes), resserré à ≤75 s côté client.
   *  - PeerTube : `durationMin=1&durationMax=75` (en secondes).
   *  - Autres (odysee/rumble/...) : recherche générique + filtre client uniquement.
   * Les durées YouTube sont enrichies ici (comme searchVideosPage) pour éviter
   * un second appel videos.list côté composant (économie de quota).
   */
  public searchShortsPage(query = 'shorts', cursor?: string | null, providerOverride?: Provider | null): Observable<PagedResult<Video>> {
    const provider = providerOverride || this.instances.selectedProvider();
    const region = this.instances.region();
    const q = String(query || '').trim() || 'shorts';
    switch (provider) {
      case 'youtube': {
        const key = this.getActiveYouTubeKey();
        if (!key) return of({ items: [], nextCursor: null });
        const params = new URLSearchParams({
          type: 'video',
          part: 'snippet',
          maxResults: '25',
          q,
          regionCode: String(region),
          safeSearch: 'moderate',
          videoEmbeddable: 'true',
          // Le filtre clé : sans lui, "shorts" ne retourne que des vidéos longues.
          videoDuration: 'short',
          order: 'viewCount',
          key: String(key),
        });
        try {
          // Langue de l'utilisateur en priorité (relevanceLanguage YouTube).
          const lang = this.getShortsLanguages()[0];
          if (lang) params.set('relevanceLanguage', lang);
        } catch {}
        if (cursor) params.set('pageToken', cursor);
        const cacheKey = `yt:shorts|${region}|${q}|${this.getShortsLanguages().join(',')}|${cursor || ''}`;
        const cached = this.searchCache.get(cacheKey);
        const now = Date.now();
        if (cached && (now - cached.ts) < this.CACHE_TTL_MS) {
          return of(cached.data);
        }
        const path = `/youtube/v3/search`;
        return this.fetchYouTube(path, params, key).pipe(
          map(res => ({
            items: (res.items || []).map((i: any) => this.mapYouTubeSearchItemToVideo(i)),
            nextCursor: res.nextPageToken || null,
          } as PagedResult<Video>)),
          switchMap((out) => {
            const ids = out.items.map(v => v.videoId).filter(Boolean);
            if (!ids.length) return of(out);
            return this.getYouTubeContentAndStats(ids).pipe(
              map((stats) => {
                const enriched = out.items.map(v => {
                  const s = stats[v.videoId];
                  if (!s) return v;
                  // duration -1 = non-embeddable (erreur 153) : on garde la
                  // vidéo en recherche (avec durée 0) mais les Shorts la filtrent.
                  const duration = typeof s.duration === 'number' && s.duration >= 0 ? s.duration : 0;
                  return { ...v, duration, views: s.views };
                });
                const next = { ...out, items: enriched } as PagedResult<Video>;
                this.searchCache.set(cacheKey, { ts: now, data: next });
                return next;
              })
            );
          }),
          catchError((e) => {
            try {
              const reason = e?.error?.error?.errors?.[0]?.reason || '';
              const msg = String(e?.error?.error?.message || e?.message || '');
              if (e?.status === 403 && (reason === 'quotaExceeded' || /quota/i.test(msg))) {
                this.quotaExceeded$.next(true);
                this.banYouTubeKey(key);
              } else if (e?.status === 400 && (reason === 'API_KEY_INVALID' || /api key (expired|invalid)/i.test(msg))) {
                this.banYouTubeKey(key);
              }
            } catch {}
            console.error('YouTube shorts search error', e);
            return of({ items: [], nextCursor: null });
          })
        );
      }
      case 'dailymotion': {
        const page = cursor ? String(cursor) : '1';
        const limit = 24;
        const params = new URLSearchParams({
          limit: String(limit),
          page: String(page),
          // Dailymotion compte en minutes : 2 = ≤ 2 min, resserré à ≤75 s côté client.
          shorter_than: '2',
          country: String(region).toLowerCase(),
          // `allow_embed` indispensable : sans lui, les vidéos non-embeddables
          // passent le filtre et le player répond "Forbidden".
          fields: 'id,title,thumbnail_url,thumbnail_480_url,thumbnail_720_url,duration,views_total,language,allow_embed,owner.screenname,owner.avatar_80_url,created_time',
          search: q,
        });
        return this.fetchDailymotion('/videos', params).pipe(
          map(res => {
            const list = (res.list || res.result || res.items || res.data || []) as any[];
            const currentPage = Number(page) || 1;
            const hasMore = typeof res.has_more === 'boolean' ? res.has_more : (list.length === limit);
            return {
              items: list.map((i: any) => this.mapDailymotionItemToVideo(i)),
              nextCursor: hasMore ? String(currentPage + 1) : null,
            } as PagedResult<Video>;
          }),
          catchError((e) => { console.error('Dailymotion shorts search error', e); return of({ items: [], nextCursor: null }); })
        );
      }
      case 'peertube': {
        const instance = this.instances.activePeerTubeInstance();
        const start = cursor ? Number(cursor) : 0;
        const dmParams = `search=${encodeURIComponent(q)}&count=24&start=${start}&durationMin=1&durationMax=75&sort=-views`;
        const primary = `/api/peertube/${instance}/api/v1/search/videos?${dmParams}`;
        const fallback = `/proxy/api/peertube/${instance}/api/v1/search/videos?${dmParams}`;
        return this.http.get<any>(primary).pipe(
          catchError(() => this.http.get<any>(fallback)),
          map(res => ({
            items: (res.data || []).map((i: any) => this.mapPeerTubeItemToVideo(i, instance)),
            nextCursor: res.data?.length > 0 ? String(start + 24) : null,
          } as PagedResult<Video>)),
          catchError((e) => { console.error(`PeerTube (${instance}) shorts search error`, e); return of({ items: [], nextCursor: null }); })
        );
      }
      default:
        // Odysee/Rumble/... : pas de filtre durée côté serveur → recherche générique + filtre client.
        return this.searchVideosPage(q, cursor, providerOverride);
    }
  }

  /**
   * Shorts PeerTube : vidéos LOCALES uniquement (`isLocal=true`).
   * Les résultats fédérés (distants) échouent à l'embed avec "Cannot get
   * this video regarding follow constraints" / "This video does not exist"
   * quand l'instance active ne suit pas l'instance d'origine. En local,
   * l'embed `/videos/embed/<uuid>` fonctionne toujours.
   */
  public searchPeerTubeShortsPage(query = 'shorts', cursor?: string | null): Observable<PagedResult<Video>> {
    const instance = this.instances.activePeerTubeInstance();
    const start = cursor ? Number(cursor) : 0;
    const q = String(query || '').trim();
    const params = new URLSearchParams({
      count: '24',
      start: String(start),
      sort: '-views',
      isLocal: 'true',
      nsfw: 'false',
      // Bornes de durée côté serveur : sans elles, le feed rendait des vidéos
      // longues (rejetées ensuite) et pouvait se retrouver quasi vide.
      durationMin: '1',
      durationMax: '90',
    });
    // Langues de l'utilisateur (filtre natif PeerTube, ignoré si inconnu).
    try {
      for (const l of this.getShortsLanguages()) params.append('languageOneOf', l);
    } catch {}
    if (q) params.set('search', q);
    const primary = `/api/peertube/${instance}/api/v1/videos?${params.toString()}`;
    const fallback = `/proxy/api/peertube/${instance}/api/v1/videos?${params.toString()}`;
    return this.http.get<any>(primary).pipe(
      catchError(() => this.http.get<any>(fallback)),
      map(res => {
        const list = (res?.data || res?.result || []) as any[];
        return {
          items: (list || []).map((i: any) => this.mapPeerTubeItemToVideo(i, instance)),
          nextCursor: list.length > 0 ? String(start + 24) : null,
        } as PagedResult<Video>;
      }),
      catchError((e) => { console.error(`PeerTube (${instance}) shorts error`, e); return of({ items: [], nextCursor: null }); })
    );
  }

  /**
   * Shorts Rumble natifs (rumble.com/shorts, vertical ≤ 90 s) + recherche
   * plein-texte, fusionnés. Le flux natif garantit des IDs /vXXXX propres,
   * compatibles avec l'embed officiel (fini "Video not found").
   * Curseur opaque : numéro de page.
   */
  public searchRumbleShortsPage(query = 'shorts', cursor?: string | null): Observable<PagedResult<Video>> {
    const page = cursor ? Math.max(1, Number(cursor) || 1) : 1;
    const q = String(query || '').trim();
    const shortsParams = new URLSearchParams({ limit: '24', page: String(page) });
    const shorts$ = this.fetchRumble('/shorts', shortsParams).pipe(
      catchError(() => of({ items: [] }))
    );
    const search$ = q
      ? this.fetchRumble('/search', new URLSearchParams({ q, limit: '24', offset: String((page - 1) * 24) })).pipe(
          catchError(() => of({ items: [] }))
        )
      : of({ items: [] });
    return forkJoin([shorts$, search$]).pipe(
      map(([a, b]: any[]) => {
        const seen = new Set<string>();
        const merged: any[] = [];
        for (const it of [...(a?.items || []), ...(b?.items || [])]) {
          const id = String(it?.videoId || it?.id || '');
          if (!id || seen.has(id)) continue;
          seen.add(id);
          merged.push(it);
        }
        return {
          items: merged.map(i => this.mapRumbleItemToVideo(i)),
          nextCursor: merged.length > 0 ? String(page + 1) : null,
        } as PagedResult<Video>;
      }),
      catchError((e) => { console.error('Rumble shorts error', e); return of({ items: [], nextCursor: null }); })
    );
  }

  // Dailymotion mapper.
  // allow_embed=false (embed désactivé par le propriétaire) => le player
  // répond "Forbidden" : propagé via `raw.allowEmbed` pour que les Shorts
  // (et toute page d'embed) puissent exclure ces vidéos.
  private mapDailymotionItemToVideo = (i: any): Video => ({
    url: `/watch/${i.id}`,
    videoId: i.id || '',
    type: 'video',
    provider: 'dailymotion',
    title: i.title || '',
    thumbnail: i.thumbnail_720_url || i.thumbnail_480_url || i.thumbnail_url || '',
    uploaderName: i['owner.screenname'] || '',
    uploaderUrl: '',
    uploaderAvatar: i['owner.avatar_80_url'] || i.thumbnail_480_url || i.thumbnail_url || '',
    channelId: i['owner.id'] || undefined,
    channelExternalId: i['owner.id'] || undefined,
    channelAvatarUrl: i['owner.avatar_80_url'] || undefined,
    uploadedDate: i.created_time ? new Date(i.created_time * 1000).toISOString() : '',
    duration: Number(i.duration || 0),
    views: Number(i.views_total || 0),
    uploaded: i.created_time ? i.created_time * 1000 : 0,
    language: i?.language ? String(i.language).toLowerCase().split('-')[0] : undefined,
    raw: { allowEmbed: i?.allow_embed !== false },
  });

  // PeerTube mapper (robust handling for thumbnail/avatar fields across instances)
  private mapPeerTubeItemToVideo = (i: any, instance: string): Video => {
    const abs = (p?: string) => {
      if (!p) return '';
      const s = String(p);
      return s.startsWith('http') ? s : `https://${instance}${s.startsWith('/') ? s : '/' + s}`;
    };
    const thumbnail = abs(i.thumbnailUrl) || abs(i.thumbnailPath) || abs(i.previewPath) || '';
    const uploaderAvatar = abs(i.account?.avatar?.path) || abs(i.account?.avatars?.[0]?.path) || abs(i.channel?.avatar?.path) || '';
    const uploaderName = i.account?.displayName || i.account?.name || i.channel?.displayName || '';
    const uploaderUrl = i.account?.url || i.channel?.url || '';

    return {
      url: `https://${instance}/w/${i.uuid}`,
      videoId: i.uuid || '',
      type: 'video',
      provider: 'peertube',
      title: i.name || '',
      thumbnail,
      uploaderName,
      uploaderUrl,
      uploaderAvatar: uploaderAvatar || thumbnail,
      channelId: i.account?.name || i.channel?.name || undefined,
      channelExternalId: i.account?.name || i.channel?.name || undefined,
      channelAvatarUrl: uploaderAvatar || undefined,
      uploadedDate: i.publishedAt || '',
      duration: Number(i.duration || 0),
      views: Number(i.views || 0),
      uploaded: i.publishedAt ? Date.parse(i.publishedAt) : 0,
      // PeerTube expose `language` sous forme { id, label } ou chaîne ISO.
      language: (i?.language && String(i.language.id || i.language).toLowerCase().split('-')[0]) || undefined,
    } as Video;
  };

  // Odysee mapper
  private mapOdyseeItemToVideo = (i: any): Video => {
    const val = i?.value || {};
    const channel = i?.signing_channel || {};
    const channelVal = channel?.value || {};
    const lbryUrl = i?.permanent_url || i?.canonical_url || '';
    const webUrl = this.lbryToOdyseeUrl(lbryUrl) || (i?.name ? `https://odysee.com/${i.name}` : '');
    const thumbRaw = val?.thumbnail?.url || '';
    const thumb = this.proxiedOdyseeThumb(thumbRaw);
    const publishedAt = val?.release_time ? new Date(val.release_time * 1000).toISOString() : '';
    const rawDuration = val?.video?.duration
      ?? i?.duration
      ?? val?.duration
      ?? i?.meta?.duration
      ?? (typeof i?.value?.duration !== 'undefined' ? i.value.duration : undefined);
    const duration = this.normalizeDuration(rawDuration);
    const views = (i?.meta?.view_count != null) ? Number(i.meta.view_count) : 0;
    // Odysee : `value.languages` (tableau ISO) ou `value.language` (chaîne).
    const langRaw = Array.isArray(val?.languages) ? val.languages[0] : (val?.language ?? i?.language);
    const language = langRaw ? String(langRaw).toLowerCase().split('-')[0] : undefined;
    const uploaderName = channelVal?.title || channel?.name || '';
    const channelClaimId = channel?.claim_id || channel?.claimId || '';
    const channelHandle = channel?.name || '';
    const channelExternalId = channelClaimId || channelHandle.replace(/^@/, '') || '';

    return {
      url: webUrl,
      videoId: i?.claim_id || i?.txid || i?.claimId || i?.id || '',
      type: 'video',
      provider: 'odysee',
      title: val?.title || i?.name || '',
      thumbnail: thumb,
      uploaderName,
      uploaderUrl: channel?.permanent_url ? this.lbryToOdyseeUrl(channel.permanent_url) : '',
      uploaderAvatar: this.proxiedOdyseeThumb(channelVal?.thumbnail?.url) || thumb,
      channelId: channelClaimId || undefined,
      channelHandle: channelHandle || undefined,
      channelExternalId: channelExternalId || undefined,
      channelAvatarUrl: this.proxiedOdyseeThumb(channelVal?.thumbnail?.url) || undefined,
      uploadedDate: publishedAt,
      duration,
      views: views,
      uploaded: publishedAt ? Date.parse(publishedAt) : 0,
      language,
    } as Video;
  };

  // Rumble mapper (best-effort over common fields)
  private mapRumbleItemToVideo = (i: any): Video => {
    let id = i?.id || i?.video_id || i?.videoId || i?.hash || '';
    const title = i?.title || i?.name || '';
    let thumb = i?.thumbnail || i?.thumbnail_url || i?.image || '';
    const uploaderName = i?.author || i?.uploader || i?.channel?.name || i?.uploaderName || '';
    const uploaderAvatar = i?.author_avatar || i?.uploader_avatar || i?.channel?.avatar || i?.uploaderAvatar || thumb || '';
    const channelSlug = i?.channel?.slug || i?.channel_slug || (i?.channel?.url ? i.channel.url.replace(/^https?:\/\/rumble.com\//, '').replace(/\/$/, '') : '') || '';
    const channelExternalId = channelSlug || (uploaderName ? uploaderName.replace(/\s+/g, '').toLowerCase() : '');
    const uploadedDate = i?.published_at || i?.created_at || i?.uploadedDate || '';
    const views = Number(i?.views || i?.view_count || 0);
    const duration = this.normalizeDuration(
      i?.duration ?? i?.durationSeconds ?? i?.duration_seconds ?? i?.video_duration ?? i?.length ?? i?.meta?.duration
    );
    const url = i?.url || (id ? `https://rumble.com/${id}` : '');
    if (!id && url) {
      try {
        const u = new URL(url);
        const m = u.pathname.match(/\/v[\w]+/) || u.pathname.match(/\/video\/([\w]+)/);
        if (m) id = Array.isArray(m) ? (m[1] ? `v${m[1]}` : m[0].replace(/^\//, '')) : id;
      } catch {}
    }
    if (!thumb && url) {
      // Best-effort: construct a thumbnail CDN path if present in URL pattern (fallback to uploader avatar)
      thumb = uploaderAvatar || '';
    }
    const nativeShort = (i as any)?.isShort === true;
    return {
      url,
      videoId: id,
      type: 'video',
      provider: 'rumble',
      title,
      thumbnail: thumb,
      uploaderName,
      uploaderUrl: i?.channel_url || '',
      uploaderAvatar,
      channelId: channelExternalId || undefined,
      channelExternalId: channelExternalId || undefined,
      channelAvatarUrl: uploaderAvatar || undefined,
      uploadedDate,
      duration,
      views,
      uploaded: uploadedDate ? Date.parse(uploadedDate) : 0,
      // Flag natif propagé du scraper serveur ; sinon durée courte ⇒ Short.
      isShort: nativeShort || (duration > 0 && duration <= 75),
    } as Video;
  };

  // Twitch Mappers (la langue Helix est conservée dans `raw` pour le
  // filtre langue des Shorts : l'endpoint /clips n'a pas de param langue).
  private mapTwitchItemToVideo = (i: any): Video => ({
    url: `/watch/${i.id}`,
    videoId: i.id || '',
    type: 'video',
    provider: 'twitch',
    kind: 'vod',
    title: i.title || '',
    thumbnail: i.thumbnail_url?.replace('%{width}', '640').replace('%{height}', '360') || '',
    uploaderName: i.user_name || i.broadcaster_name || '',
    uploaderUrl: i.user_login ? `https://www.twitch.tv/${i.user_login}` : '',
    uploaderAvatar: '', // Requires another API call
    channelId: i.user_id || i.broadcaster_id || undefined,
    channelHandle: i.user_login || undefined,
    channelExternalId: i.user_login || undefined,
    channelAvatarUrl: undefined,
    uploadedDate: i.created_at || '',
    duration: this.parseTwitchDurationToSeconds(i.duration || '0s'),
    views: Number(i.view_count || i.viewer_count || 0),
    uploaded: i.created_at ? Date.parse(i.created_at) : 0,
    isLive: false,
    raw: { language: i?.language || undefined },
  });

  // Twitch Streams mapper (for trending popular live streams)
  // Les streams Helix sont TOUJOURS en direct : type normalisé 'live' + isLive.
  // Le thumbnail Helix utilise le motif "{width}x{height}" (ex. ...-{width}x{height}.jpg).
  private mapTwitchStreamToVideo = (i: any): Video => {
    const rawThumb: string = String(i.thumbnail_url || '');
    const resolvedThumb = rawThumb
      .replace('{width}x{height}', '640x360')
      .replace('{width}', '640')
      .replace('{height}', '360')
      || 'https://static-cdn.jtvnw.net/ttv-static/404_preview-640x360.jpg';
    const avatar = rawThumb
      .replace('{width}x{height}', '70x70')
      .replace('{width}', '70')
      .replace('{height}', '70');
    return {
      url: `https://www.twitch.tv/${i.user_login}`,
      videoId: i.user_login || i.id || '',
      type: 'live',
      provider: 'twitch',
      title: i.title || '',
      thumbnail: resolvedThumb,
      uploaderName: i.user_name || '',
      uploaderUrl: `https://www.twitch.tv/${i.user_login}`,
      uploaderAvatar: avatar,
      channelId: i.user_id || undefined,
      channelHandle: i.user_login || undefined,
      channelExternalId: i.user_login || undefined,
      channelAvatarUrl: avatar || undefined,
      uploadedDate: i.started_at || '',
      duration: 0,
      views: Number(i.viewer_count || 0),
      uploaded: i.started_at ? Date.parse(i.started_at) : 0,
      isLive: true,
    } as Video;
  };

  private mapTwitchChannelToVideo = (i: any): Video => {
    // /search/channels : thumbnail_url = image de profil (carrée), PAS une miniature 16:9.
    // On la garde comme avatar + miniature (object-cover côté template) et on
    // distingue bien les chaînes hors-ligne (type 'channel') des directs.
    const rawThumb: string = String(i.thumbnail_url || '');
    const login: string = String(i.broadcaster_login || i.user_login || '');
    const display: string = String(i.display_name || i.broadcaster_name || i.user_name || login || '');
    const live = i?.is_live === true;
    const thumb = rawThumb || 'https://static-cdn.jtvnw.net/ttv-static/404_preview-640x360.jpg';
    return {
      url: `https://www.twitch.tv/${login}`,
      videoId: login || String(i.id || ''),
      type: live ? 'live' : 'channel',
      provider: 'twitch',
      title: (live && i.title) ? String(i.title) : display,
      thumbnail: thumb,
      uploaderName: display,
      uploaderUrl: login ? `https://www.twitch.tv/${login}` : '',
      uploaderAvatar: rawThumb || '',
      channelId: i.id || undefined,
      channelHandle: login || undefined,
      channelExternalId: login || undefined,
      channelAvatarUrl: rawThumb || undefined,
      uploadedDate: live ? (i.started_at || '') : '',
      duration: 0,
      views: 0,
      uploaded: live && i.started_at ? Date.parse(i.started_at) : 0,
      isLive: live,
    } as Video;
  };

  // Twitch Clips mapper (Shorts-equivalent)
  private mapTwitchClipToVideo = (i: any): Video => ({
    url: i.url || `https://clips.twitch.tv/${i.id}`,
    videoId: i.id || '',
    type: 'video',
    provider: 'twitch',
    kind: 'clip',
    title: i.title || '',
    // Clip thumbnails often have width/height placeholders or fixed preview sizes
    thumbnail: (i.thumbnail_url || '').replace('%{width}', '640').replace('%{height}', '360'),
    uploaderName: i.broadcaster_name || i.creator_name || '',
    uploaderUrl: i.broadcaster_name ? `https://www.twitch.tv/${i.broadcaster_name}` : '',
    uploaderAvatar: '',
    channelId: i.broadcaster_id || undefined,
    channelHandle: undefined,
    channelExternalId: undefined,
    channelAvatarUrl: undefined,
    uploadedDate: i.created_at || '',
    duration: Number(i.duration || 0),
    views: Number(i.view_count || 0),
    uploaded: i.created_at ? Date.parse(i.created_at) : 0,
    isLive: false,
    raw: { language: i?.language || undefined },
  });

  /**
   * Search Twitch Clips by first finding channels for a query (or recent popular channels when empty),
   * then fetching recent clips per broadcaster. Returns up to ~24 clips with pagination via channel search cursor.
   */
  public searchTwitchClipsPage(query: string, cursor?: string | null): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const q = String(query || '').trim();
        if (!q) return of({ items: [], nextCursor: null });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        const keywords = [q, ...this.twitchQueryKeywords(q, 3).filter(k => k !== q.toLowerCase())].slice(0, 4);
        const channelCalls = keywords.map((k, idx) =>
          this.fetchTwitchChannelsForKeyword(token, headers, k, 10, idx === 0 ? after : '').pipe(
            catchError(() => of({ data: [], pagination: {} }))
          )
        );
        // Fenêtre large (30j -> 90j) : beaucoup de petites chaînes n'ont pas de clips sur 7j.
        const since = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString();
        const fetchClipsForUsers = (ids: string[]) => {
          if (!ids.length) return of([] as any[]);
          // Fan-out réduit (voir VODs ci-dessus).
          const perUser = ids.slice(0, 6).map(uid => {
            const cPrimary = `/api/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=4&started_at=${encodeURIComponent(since)}`;
            const cFallback = `/proxy/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=4&started_at=${encodeURIComponent(since)}`;
            return this.http.get<any>(cPrimary, { headers }).pipe(
              catchError(() => this.http.get<any>(cFallback, { headers })),
              map(res => Array.isArray(res?.data) ? res.data : []),
              catchError(() => of([] as any[]))
            );
          });
          return forkJoin(perUser).pipe(map((lists: any[][]) => lists.flat()));
        };
        return forkJoin(channelCalls).pipe(
          switchMap((responses: any[]) => {
            const seen = new Set<string>();
            const channels: any[] = [];
            let next: string | null = null;
            for (const r of responses) {
              const arr = Array.isArray(r?.data) ? r.data : [];
              if (!next && r?.pagination?.cursor) next = r.pagination.cursor;
              for (const c of arr) {
                const key = String(c?.id || '');
                if (!key || seen.has(key)) continue;
                seen.add(key);
                channels.push(c);
              }
            }
            const userIds: string[] = channels.map((c: any) => c?.id).filter(Boolean).slice(0, 10);
            return fetchClipsForUsers(userIds).pipe(
              switchMap(clipsByUser => {
                if (clipsByUser.length >= 3) {
                  return of({
                    items: clipsByUser.slice(0, 24).map((i: any) => this.mapTwitchClipToVideo(i)),
                    nextCursor: next,
                  } as PagedResult<Video>);
                }
                // Repli catégorie (game_id) : clips thématiques même sans chaîne matchée.
                const cats = this.twitchQueryKeywords(q, 2);
                if (!cats.length) return of({ items: clipsByUser.slice(0, 24).map((i: any) => this.mapTwitchClipToVideo(i)), nextCursor: next } as PagedResult<Video>);
                const catCalls = cats.slice(0, 2).map(k =>
                  this.fetchTwitchCategoryForKeyword(token, headers, k).pipe(catchError(() => of({ data: [] })))
                );
                return forkJoin(catCalls).pipe(
                  switchMap((catRes: any[]) => {
                    const gameIds: string[] = [];
                    for (const cr of catRes) {
                      const list = Array.isArray(cr?.data) ? cr.data : [];
                      if (list[0]?.id) gameIds.push(String(list[0].id));
                    }
                    if (!gameIds.length) {
                      return of({ items: clipsByUser.slice(0, 24).map((i: any) => this.mapTwitchClipToVideo(i)), nextCursor: next } as PagedResult<Video>);
                    }
                    const gameCalls = gameIds.slice(0, 2).map(gid => {
                      const gPrimary = `/api/twitch-api/helix/clips?game_id=${encodeURIComponent(gid)}&first=10&started_at=${encodeURIComponent(since)}`;
                      const gFallback = `/proxy/twitch-api/helix/clips?game_id=${encodeURIComponent(gid)}&first=10&started_at=${encodeURIComponent(since)}`;
                      return this.http.get<any>(gPrimary, { headers }).pipe(
                        catchError(() => this.http.get<any>(gFallback, { headers })),
                        map(res => Array.isArray(res?.data) ? res.data : []),
                        catchError(() => of([] as any[]))
                      );
                    });
                    return forkJoin(gameCalls).pipe(
                      map((lists: any[][]) => ({
                        items: [...clipsByUser, ...lists.flat()].slice(0, 24).map((i: any) => this.mapTwitchClipToVideo(i)),
                        nextCursor: next,
                      } as PagedResult<Video>))
                    );
                  })
                );
              })
            );
          }),
          catchError((e) => { console.error('Twitch clips search error', e); return of({ items: [], nextCursor: null }); })
        );
      })
    );
  }

  /**
   * Top live streams Twitch (Helix /streams) — utilisé comme "trending" Twitch
   * et comme filet de sécurité quand une recherche thématique ne retourne rien
   * (la recherche de chaînes Helix exige des noms proches de la requête et
   * filtre souvent tout pour des thèmes génériques comme "sports" ou "tech").
   */
  public getTwitchTopStreamsPage(cursor?: string | null, limit = 24): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return this.getTwitchServerTopStreams(limit);
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        // Langue de l'utilisateur (filtre natif Helix /streams).
        const langParam = this.primaryShortsLang2() ? `&language=${encodeURIComponent(this.primaryShortsLang2() as string)}` : '';
        const primary = `/api/twitch-api/helix/streams?first=${limit}${after}${langParam}`;
        const fallback = `/proxy/twitch-api/helix/streams?first=${limit}${after}${langParam}`;
        return this.http.get<any>(primary, { headers }).pipe(
          catchError(() => this.http.get<any>(fallback, { headers })),
          map(res => ({
            items: (res.data || []).map((i: any) => this.mapTwitchStreamToVideo(i)),
            nextCursor: res.pagination?.cursor || null,
          } as PagedResult<Video>)),
          // Helix direct vide/en erreur (proxy, 429, CORS…) : repli serveur.
          switchMap(res => (res?.items?.length ? of(res) : this.getTwitchServerTopStreams(limit))),
          catchError(() => this.getTwitchServerTopStreams(limit))
        );
      }),
      catchError(() => this.getTwitchServerTopStreams(limit))
    );
  }

  /**
   * Top streams via le serveur (`GET /api/twitch/top-streams`, token +
   * retries côté back). Repli fiable pour Home/Explore quand les appels
   * Helix directs du navigateur échouent.
   */
  public getTwitchServerTopStreams(limit = 24): Observable<PagedResult<Video>> {
    const n = Math.min(50, Math.max(1, Number(limit) || 24));
    return this.http.get<any>(`/api/twitch/top-streams?first=${n}`).pipe(
      timeout(20000),
      map(res => ({
        items: ((res?.items || []) as any[]).map(i => this.mapTwitchServerItemToVideo(i)),
        nextCursor: null,
      } as PagedResult<Video>)),
      catchError((e) => { console.error('Twitch server top streams error', e); return of({ items: [], nextCursor: null }); })
    );
  }

  /**
   * Recherche Twitch via le serveur unifié (`/api/search?providers=tw`,
   * token + retries + filets côté back). Dernier repli des pages Explore.
   */
  public searchTwitchViaServer(query: string, limit = 24): Observable<PagedResult<Video>> {
    const q = String(query || '').trim();
    if (!q) return this.getTwitchServerTopStreams(limit);
    const n = Math.min(50, Math.max(1, Number(limit) || 24));
    const url = `/api/search?q=${encodeURIComponent(q)}&providers=tw&pageSize=${n}`;
    return this.http.get<any>(url).pipe(
      timeout(25000),
      map(res => {
        const list = (res?.groups?.tw || res?.items || []) as any[];
        return {
          items: list.map(i => this.mapTwitchServerItemToVideo(i)).filter(v => !!v.videoId),
          nextCursor: null,
        } as PagedResult<Video>;
      }),
      catchError((e) => { console.error('Twitch server search error', e); return of({ items: [], nextCursor: null }); })
    );
  }

  /** Mappe un item Twitch "forme serveur" (twitch.mjs) vers Video. */
  private mapTwitchServerItemToVideo = (i: any): Video => {
    const kind = String(i?.kind || '').toLowerCase();
    const type = String(i?.type || 'video');
    const login: string | undefined = i?.channelHandle || i?.channelExternalId || undefined;
    const thumb: string = String(i?.thumbnail || i?.uploaderAvatar || '') ||
      'https://static-cdn.jtvnw.net/ttv-static/404_preview-640x360.jpg';
    return {
      url: i?.url || (login ? `https://www.twitch.tv/${login}` : `/watch/${i?.id || ''}`),
      videoId: String(i?.id || ''),
      type,
      provider: 'twitch',
      kind: kind === 'clip' ? 'clip' : kind === 'vod' ? 'vod' : undefined,
      title: i?.title || '',
      thumbnail: thumb,
      uploaderName: i?.uploaderName || '',
      uploaderUrl: login ? `https://www.twitch.tv/${login}` : '',
      uploaderAvatar: i?.uploaderAvatar || '',
      channelId: i?.channelId || undefined,
      channelHandle: login,
      channelExternalId: login || undefined,
      channelAvatarUrl: i?.uploaderAvatar || undefined,
      uploadedDate: i?.publishedAt || '',
      duration: Number(i?.duration || 0),
      views: Number(i?.views || 0),
      uploaded: i?.publishedAt ? Date.parse(i.publishedAt) : 0,
      isLive: i?.isLive === true,
    } as Video;
  };

  /**
   * Recherche thématique Twitch robuste : VODs puis clips, avec fallback vers
   * les top streams live si les deux sont quasi vides (évite les blocs vides
   * sur les pages de thèmes). `minResults` = seuil sous lequel on complète.
   */
  public searchTwitchThemePage(query: string, cursor?: string | null, minResults = 4): Observable<PagedResult<Video>> {
    return this.searchTwitchVodsPage(query, cursor).pipe(
      switchMap(vods => {
        if ((vods?.items?.length || 0) >= minResults) return of(vods);
        return this.searchTwitchClipsPage(query, cursor).pipe(
          map(clips => ({
            items: [...(vods?.items || []), ...(clips?.items || [])],
            nextCursor: clips?.nextCursor || vods?.nextCursor || null,
          } as PagedResult<Video>)),
          switchMap(merged => {
            if ((merged?.items?.length || 0) >= minResults) return of(merged);
            // Filet de sécurité : top streams live (jamais vide quand Twitch est configuré)
            return this.getTwitchTopStreamsPage(cursor).pipe(
              map(top => {
                if (!top.items.length) return merged;
                const seen = new Set((merged.items || []).map(v => v.videoId));
                const extra = top.items.filter(v => !seen.has(v.videoId));
                return { items: [...(merged.items || []), ...extra], nextCursor: top.nextCursor } as PagedResult<Video>;
              }),
              catchError(() => of(merged))
            );
          }),
          // Un timeout/échec des VODs ou clips ne doit jamais vider la page :
          // repli direct sur les top streams live.
          catchError(() => this.getTwitchTopStreamsPage(cursor).pipe(
            catchError(() => of({ items: [], nextCursor: null } as PagedResult<Video>))
          ))
        );
      }),
      catchError(() => this.getTwitchTopStreamsPage(cursor).pipe(
        catchError(() => of({ items: [], nextCursor: null } as PagedResult<Video>))
      ))
    );
  }

  // ---- Twitch Shorts : clips via les jeux les plus suivis -----------------
  // L'ancienne chaîne (top streams -> broadcaster_id -> clips 7 j) rendait
  // souvent un flux vide ("Aucun Short trouvé"). L'endpoint /helix/clips
  // accepte directement game_id (trié par vues, sans broadcaster) : on
  // tourne sur les top games, ce qui donne toujours des clips récents.
  // Curseur opaque : "<gameId>::<paginationCursor>" (pagination vide = page 1).
  private twitchTopGameIds: string[] | null = null;
  private twitchGameIdx = 0;
  private twitchClipsSinceDays = 30;

  private getTwitchTopGameIds(): Observable<string[]> {
    if (this.twitchTopGameIds?.length) return of(this.twitchTopGameIds);
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of([] as string[]);
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const primary = `/api/twitch-api/helix/games/top?first=10`;
        const fallback = `/proxy/twitch-api/helix/games/top?first=10`;
        return this.http.get<any>(primary, { headers }).pipe(
          catchError(() => this.http.get<any>(fallback, { headers })),
          map(res => {
            const ids: string[] = (Array.isArray(res?.data) ? res.data : []).map((g: any) => String(g?.id || '')).filter(Boolean);
            if (ids.length) this.twitchTopGameIds = ids;
            return ids;
          }),
          catchError(() => of([] as string[]))
        );
      })
    );
  }

  private fetchTwitchGameClipsPage(gameId: string, pageCursor?: string | null): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token || !gameId) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const since = new Date(Date.now() - this.twitchClipsSinceDays * 24 * 60 * 60 * 1000).toISOString();
        const after = pageCursor ? `&after=${encodeURIComponent(pageCursor)}` : '';
        const primary = `/api/twitch-api/helix/clips?game_id=${encodeURIComponent(gameId)}&first=20&started_at=${encodeURIComponent(since)}${after}`;
        const fallback = `/proxy/twitch-api/helix/clips?game_id=${encodeURIComponent(gameId)}&first=20&started_at=${encodeURIComponent(since)}${after}`;
        return this.http.get<any>(primary, { headers }).pipe(
          catchError(() => this.http.get<any>(fallback, { headers })),
          map(res => ({
            clips: Array.isArray(res?.data) ? res.data : [],
            page: (res?.pagination?.cursor || null) as string | null,
          })),
          // Ne garde que les clips existants (les morts affichent
          // "time machine" dans le player).
          switchMap(({ clips, page }) => {
            const ids = clips.map((c: any) => String(c?.id || '')).filter(Boolean);
            if (!ids.length) {
              return of({
                items: [],
                nextCursor: page ? `${gameId}::${page}` : this.nextTwitchGameCursor(gameId),
              } as PagedResult<Video>);
            }
            return this.validateTwitchClipIds(ids).pipe(
              map(valid => ({
                items: clips.filter((c: any) => valid.has(String(c?.id || ''))).map((i: any) => this.mapTwitchClipToVideo(i)),
                // Jeu suivant quand la page est épuisée (rotation infinie).
                nextCursor: page ? `${gameId}::${page}` : this.nextTwitchGameCursor(gameId),
              } as PagedResult<Video>)),
              catchError(() => of({
                items: clips.map((i: any) => this.mapTwitchClipToVideo(i)),
                nextCursor: page ? `${gameId}::${page}` : this.nextTwitchGameCursor(gameId),
              } as PagedResult<Video>))
            );
          }),
          catchError(() => of({
            items: [],
            nextCursor: this.nextTwitchGameCursor(gameId),
          } as PagedResult<Video>))
        );
      })
    );
  }

  /**
   * Valide l'existence des clips par lot (`GET /helix/clips?id=…`, 100 max).
   * Les clips supprimés/expirés affichent "Sorry. Unless you've got a time
   * machine, that content is unavailable." dans le player : on les exclut
   * AVANT affichage. En cas d'échec de validation, le doute profite aux
   * clips (on garde tout) pour ne jamais vider le flux.
   */
  public validateTwitchClipIds(ids: string[]): Observable<Set<string>> {
    const clean = Array.from(new Set((ids || []).map(s => String(s || '').trim()).filter(Boolean))).slice(0, 100);
    if (!clean.length) return of(new Set<string>());
    return this.getTwitchAuthToken().pipe(timeout(15000),
      switchMap(token => {
        if (!token) return of(new Set<string>(clean));
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const params = clean.map(s => `id=${encodeURIComponent(s)}`).join('&');
        const primary = `/api/twitch-api/helix/clips?${params}`;
        const fallback = `/proxy/twitch-api/helix/clips?${params}`;
        return this.http.get<any>(primary, { headers }).pipe(
          catchError(() => this.http.get<any>(fallback, { headers })),
          map(res => new Set<string>((Array.isArray(res?.data) ? res.data : []).map((c: any) => String(c?.id || '')).filter(Boolean))),
          catchError(() => of(new Set<string>(clean)))
        );
      }),
      catchError(() => of(new Set<string>(clean)))
    );
  }

  /** Curseur vers le jeu suivant (boucle infinie sur les top games). */
  private nextTwitchGameCursor(currentGameId: string): string | null {
    const games = this.twitchTopGameIds || [];
    if (!games.length) return null;
    const idx = games.indexOf(currentGameId);
    const next = games[(idx + 1 + games.length) % games.length];
    return next ? `${next}::` : null;
  }

  /**
   * Clips Twitch sans requête (page Shorts) : rotation sur les top games
   * (clips triés par vues, 30 j). Repli historique broadcaster si les jeux
   * sont indisponibles.
   */
  public getTwitchClipsFeed(cursor?: string | null): Observable<PagedResult<Video>> {
    const parsed = String(cursor || '');
    const sep = parsed.indexOf('::');
    if (sep > 0) {
      const gameId = parsed.slice(0, sep);
      const pageCursor = parsed.slice(sep + 2) || null;
      return this.fetchTwitchGameClipsPage(gameId, pageCursor);
    }
    return this.getTwitchTopGameIds().pipe(
      switchMap(games => {
        if (!games.length) return this.getTwitchBroadcasterClipsFeed(null);
        const gameId = games[this.twitchGameIdx++ % games.length];
        return this.fetchTwitchGameClipsPage(gameId, null);
      })
    );
  }

  /**
   * Ancien flux broadcaster (top streams -> clips) : conservé en repli quand
   * /helix/games/top ne répond pas.
   */
  private getTwitchBroadcasterClipsFeed(cursor?: string | null): Observable<PagedResult<Video>> {
    return this.getTwitchAuthToken().pipe(timeout(30000),
      switchMap(token => {
        if (!token) return of({ items: [], nextCursor: null });
        const headers = new HttpHeaders({ 'Client-ID': this.resolveTwitchClientId()!, 'Authorization': `Bearer ${token}` });
        const after = cursor ? `&after=${encodeURIComponent(cursor)}` : '';
        const sPrimary = `/api/twitch-api/helix/streams?first=20${after}`;
        const sFallback = `/proxy/twitch-api/helix/streams?first=20${after}`;
        return this.http.get<any>(sPrimary, { headers }).pipe(
          catchError(() => this.http.get<any>(sFallback, { headers })),
          switchMap(sRes => {
            const streams = Array.isArray(sRes?.data) ? sRes.data : [];
            const userIds: string[] = streams.map((s: any) => s?.user_id).filter(Boolean).slice(0, 20);
            if (!userIds.length) return of({ items: [], nextCursor: null } as PagedResult<Video>);
            // Fenêtre large (90 j) : beaucoup de chaînes n'ont pas de clips sur 7 j,
            // ce qui vidait la page Shorts Twitch ("Aucun Short trouvé").
            const since = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString();
            const perUser = userIds.map(uid => {
              const cPrimary = `/api/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=5&started_at=${encodeURIComponent(since)}`;
              const cFallback = `/proxy/twitch-api/helix/clips?broadcaster_id=${encodeURIComponent(uid)}&first=5&started_at=${encodeURIComponent(since)}`;
              return this.http.get<any>(cPrimary, { headers }).pipe(
                catchError(() => this.http.get<any>(cFallback, { headers })),
                map(res => Array.isArray(res?.data) ? res.data : [])
              );
            });
            return forkJoin(perUser).pipe(
              map((lists: any[][]) => lists.flat().slice(0, 24)),
              // Exclut les clips morts ("time machine") avant affichage.
              switchMap((clips: any[]) => {
                const ids = clips.map((c: any) => String(c?.id || '')).filter(Boolean);
                if (!ids.length) {
                  return of({ items: [], nextCursor: sRes?.pagination?.cursor || null } as PagedResult<Video>);
                }
                return this.validateTwitchClipIds(ids).pipe(
                  map(valid => ({
                    items: clips.filter((c: any) => valid.has(String(c?.id || ''))).map((i: any) => this.mapTwitchClipToVideo(i)),
                    nextCursor: sRes?.pagination?.cursor || null,
                  } as PagedResult<Video>))
                );
              }),
              catchError(() => of({ items: [], nextCursor: null } as PagedResult<Video>))
            );
          }),
          catchError((e) => { console.error('Twitch clips feed error', e); return of({ items: [], nextCursor: null }); })
        );
      })
    );
  }

  private parseISODurationToSeconds(iso: string): number {
    // ... (rest of the code remains the same)
    const m = /^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/i.exec(iso || '');
    if (!m) return 0;
    const h = parseInt(m[1] || '0', 10);
    const mn = parseInt(m[2] || '0', 10);
    const s = parseInt(m[3] || '0', 10);
    return h * 3600 + mn * 60 + s;
  }

  private resolveYouTubeApiKey(): string | undefined {
    const g: any = globalThis as any;
    const fromGlobal = g?.YOUTUBE_API_KEY;
    const fromImportMeta = (typeof import.meta !== 'undefined' && (import.meta as any).env)
      ? ((import.meta as any).env.YOUTUBE_API_KEY || (import.meta as any).env.NG_APP_YOUTUBE_API_KEY)
      : undefined;
    const fromProcess = (g?.process?.env) ? (g.process.env.YOUTUBE_API_KEY || g.process.env.NG_APP_YOUTUBE_API_KEY) : undefined;
    return fromGlobal || fromImportMeta || fromProcess || undefined;
  }

  // ---- Multi-key helpers ----
  private loadYouTubeKeys(): string[] {
    const g: any = globalThis as any;
    const keys: string[] = [];
    try {
      // Prefer explicit array window.YOUTUBE_API_KEYS
      const arr = Array.isArray(g?.YOUTUBE_API_KEYS) ? g.YOUTUBE_API_KEYS : null;
      if (arr && arr.length) keys.push(...arr.map((s: any) => String(s).trim()).filter(Boolean));
    } catch {}
    try {
      // Comma-separated string support
      const csv = g?.YOUTUBE_API_KEYS;
      if (!Array.isArray(csv) && typeof csv === 'string' && csv.includes(',')) {
        keys.push(...csv.split(',').map((s: string) => s.trim()).filter(Boolean));
      }
    } catch {}
    try {
      // Env-based multi-keys
      const im: any = (typeof import.meta !== 'undefined' && (import.meta as any).env) ? (import.meta as any).env : undefined;
      const fromEnvCsv = im?.YOUTUBE_API_KEYS || im?.NG_APP_YOUTUBE_API_KEYS || (globalThis as any)?.process?.env?.YOUTUBE_API_KEYS || (globalThis as any)?.process?.env?.NG_APP_YOUTUBE_API_KEYS;
      if (typeof fromEnvCsv === 'string' && fromEnvCsv.includes(',')) {
        keys.push(...fromEnvCsv.split(',').map((s: string) => s.trim()).filter(Boolean));
      }
    } catch {}
    // Fallback single key
    const single = this.resolveYouTubeApiKey();
    if (single) keys.push(String(single));
    // De-duplicate and return
    const uniq = Array.from(new Set(keys.filter(Boolean)));
    return uniq;
  }

  private isKeyBanned(k: string): boolean {
    const until = this.ytKeyBans.get(k) || 0;
    return Date.now() < until;
  }

  private banYouTubeKey(k: string) {
    if (!k) return;
    const until = Date.now() + this.YT_KEY_BAN_MS;
    this.ytKeyBans.set(k, until);
  }

  private getActiveYouTubeKey(): string | undefined {
    // If no keys loaded, attempt to load once
    if (!this.ytKeys || this.ytKeys.length === 0) this.ytKeys = this.loadYouTubeKeys();
    const n = this.ytKeys.length;
    if (!n) return undefined;
    // Round-robin until we find a non-banned key
    for (let i = 0; i < n; i++) {
      const idx = (this.ytKeyIndex + i) % n;
      const candidate = this.ytKeys[idx];
      if (!this.isKeyBanned(candidate)) {
        this.ytKeyIndex = (idx + 1) % n; // advance pointer for next call
        return candidate;
      }
    }
    // All keys currently banned
    return undefined;
  }

  private resolveTwitchClientId(): string | undefined {
    const g: any = globalThis as any;
    return this.twitchServerClientId || g?.TWITCH_CLIENT_ID || (typeof import.meta !== 'undefined' && (import.meta as any).env?.TWITCH_CLIENT_ID) || g?.process?.env?.TWITCH_CLIENT_ID;
  }

  // ---- Cache client du token Twitch (single-flight + TTL) ----
  // Avant : CHAQUE appel Twitch (token + sections + fan-out) refaisait un
  // HTTP /api/twitch-token, soit ~10 requêtes token par page Explore, en
  // plus des ~40 appels Helix parallèles. Le moindre hoquet réseau vidait
  // toute la page. Maintenant : 1 seul vol partagé, réutilisé 30 min.
  private twitchTokenValue: string | null = null;
  private twitchTokenShared$: Observable<string | null> | null = null;
  private twitchTokenAt = 0;
  private readonly TWITCH_TOKEN_TTL_MS = 30 * 60 * 1000;

  private getTwitchAuthToken(): Observable<string | null> {
    // Le token applicatif est obtenu via notre serveur (/api/twitch-token) :
    // TWITCH_CLIENT_SECRET ne quitte jamais le backend.
    const now = Date.now();
    if (this.twitchTokenValue && this.twitchTokenShared$ && (now - this.twitchTokenAt) < this.TWITCH_TOKEN_TTL_MS) {
      return of(this.twitchTokenValue);
    }
    if (!this.twitchTokenShared$ || (now - this.twitchTokenAt) >= this.TWITCH_TOKEN_TTL_MS) {
      this.twitchTokenAt = now;
      this.twitchTokenShared$ = this.http.get<any>('/api/twitch-token').pipe(
        timeout(10000),
        map(res => {
          if (res?.accessToken) {
            if (res?.clientId) this.twitchServerClientId = String(res.clientId);
            this.twitchTokenValue = String(res.accessToken);
            return this.twitchTokenValue as string;
          }
          return null;
        }),
        tap(t => {
          // Échec : on invalide le partage pour que le prochain appel
          // retente un HTTP au lieu de rejouer `null` jusqu'au TTL.
          if (!t) {
            this.twitchTokenShared$ = null;
            this.twitchTokenValue = null;
          }
        }),
        shareReplay(1),
        catchError(() => {
          this.twitchTokenShared$ = null;
          this.twitchTokenValue = null;
          return of(null);
        })
      );
    }
    return this.twitchTokenShared$;
  }

  private parseTwitchDurationToSeconds(duration: string): number {
    let totalSeconds = 0;
    if (duration.includes('h')) {
      totalSeconds += parseInt(duration.split('h')[0]) * 3600;
      duration = duration.split('h')[1];
    }
    if (duration.includes('m')) {
      totalSeconds += parseInt(duration.split('m')[0]) * 60;
      duration = duration.split('m')[1];
    }
    if (duration.includes('s')) {
      totalSeconds += parseInt(duration.split('s')[0]);
    }
    return totalSeconds;
  }

  // Dev proxy helpers with fallback to direct URLs (returns Observable<any>)
  private fetchYouTube(path: string, params: URLSearchParams, _activeKey?: string) {
    const qs = params.toString();
    const cachedProd = `/api/yt${path}?${qs}`;     // server cache in prod
    const cachedDev = `/proxy/api/yt${path}?${qs}`; // dev proxy to server cache
    const direct = `https://www.googleapis.com${path}?${qs}`;
    const proxied = `/proxy/yt${path}?${qs}`;
    // Try prod server cache → dev server cache → direct → dev proxy
    return this.http.get<any>(cachedProd).pipe(
      catchError(() => this.http.get<any>(cachedDev).pipe(
        catchError((_e1) => this.http.get<any>(direct).pipe(
          catchError((err) => {
            console.warn('YouTube direct call failed, trying /proxy/yt...', err);
            return this.http.get<any>(proxied);
          })
        ))
      ))
    );
  }

  private fetchDailymotion(path: string, params: URLSearchParams) {
    const prod = `/api/dm${path}?${params.toString()}`;
    const proxied = `/proxy/dm${path}?${params.toString()}`;
    const direct = `https://api.dailymotion.com${path}?${params.toString()}`;
    return this.http.get<any>(prod).pipe(
      catchError(() => this.http.get<any>(proxied).pipe(
        catchError(() => this.http.get<any>(direct))
      ))
    );
  }

  private fetchRumble(path: string, params: URLSearchParams) {
    const url = `/api/rumble${path}?${params.toString()}`;
    return this.http.get<any>(url).pipe(
      catchError((err) => {
        console.error('Rumble API call via proxy failed', err);
        return of({ items: [], total: 0 });
      })
    );
  }

  /**
   * Fetch durations (in seconds) for a list of YouTube video IDs.
   * Non-embeddable videos (status.embeddable === false) are excluded via
   * a -1 marker so Shorts/feed callers can drop them (player error 153).
   */
  public getYouTubeDurations(ids: string[]): Observable<Record<string, number>> {
    const apiKey = this.getActiveYouTubeKey();
    if (!apiKey || !ids.length) {
      return of({});
    }

    const params = new URLSearchParams({
      key: apiKey,
      part: 'contentDetails,status',
      id: ids.join(','),
    });

    return this.fetchYouTube('/youtube/v3/videos', params, apiKey).pipe(
      map((res: any) => Array.isArray(res?.items) ? res.items : []),
      map((items: any[]) => items.reduce((acc: Record<string, number>, item: any) => {
        const duration = item?.contentDetails?.duration || 'PT0S';
        const id = String(item?.id || '');
        if (!id) return acc;
        // -1 = non-embeddable (à exclure côté Shorts pour éviter l'erreur 153)
        if (item?.status && item.status.embeddable === false) {
          acc[id] = -1;
          return acc;
        }
        acc[id] = this.parseISODurationToSeconds(duration);
        return acc;
      }, {} as Record<string, number>)),
      catchError(() => of({}))
    );
  }

  /**
   * Fetch minimal details (duration seconds + viewCount) for a list of YouTube IDs.
   * Non-embeddable entries get duration -1 so callers can drop them (error 153).
   */
  private getYouTubeContentAndStats(ids: string[]): Observable<Record<string, { duration: number; views: number }>> {
    const apiKey = this.getActiveYouTubeKey();
    if (!apiKey || !ids.length) return of({});
    const params = new URLSearchParams({
      key: apiKey,
      part: 'contentDetails,statistics,status',
      id: ids.join(','),
      maxResults: String(Math.min(50, ids.length)),
      // Add safeSearch for consistency
      safeSearch: 'moderate',
    });
    return this.fetchYouTube('/youtube/v3/videos', params, apiKey).pipe(
      map((res: any) => Array.isArray(res?.items) ? res.items : []),
      map((items: any[]) => {
        const out: Record<string, { duration: number; views: number }> = {};
        for (const it of items) {
          const id = String(it?.id || '');
          if (!id) continue;
          if (it?.status && it.status.embeddable === false) {
            out[id] = { duration: -1, views: Number(it?.statistics?.viewCount || 0) };
            continue;
          }
          const duration = this.parseISODurationToSeconds(it?.contentDetails?.duration || 'PT0S');
          const views = Number(it?.statistics?.viewCount || 0);
          out[id] = { duration, views };
        }
        return out;
      }),
      catchError(() => of({} as Record<string, { duration: number; views: number }>))
    );
  }
}