mirror of
https://github.com/tapframe/NuvioStreaming.git
synced 2026-03-11 09:35:42 +00:00
bf5f7c60de
same as for NuvioTV
also
fix: correct episode ID parsing for non-season formats (mal🆔episode)
2596 lines
111 KiB
TypeScript
2596 lines
111 KiB
TypeScript
import { useState, useEffect, useCallback, useRef } from 'react';
|
||
import { StreamingContent } from '../services/catalogService';
|
||
import { catalogService } from '../services/catalogService';
|
||
import { stremioService } from '../services/stremioService';
|
||
import { tmdbService } from '../services/tmdbService';
|
||
import { cacheService } from '../services/cacheService';
|
||
import { localScraperService, ScraperInfo } from '../services/pluginService';
|
||
import { Cast, Episode, GroupedEpisodes, GroupedStreams } from '../types/metadata';
|
||
import { TMDBService } from '../services/tmdbService';
|
||
import { logger } from '../utils/logger';
|
||
import { usePersistentSeasons } from './usePersistentSeasons';
|
||
import { mmkvStorage } from '../services/mmkvStorage';
|
||
import { Stream } from '../types/metadata';
|
||
import { storageService } from '../services/storageService';
|
||
import { useSettings } from './useSettings';
|
||
|
||
// Constants for timeouts and retries
|
||
const API_TIMEOUT = 10000; // 10 seconds
|
||
const MAX_RETRIES = 1; // Reduced since stremioService already retries
|
||
const RETRY_DELAY = 1000; // 1 second
|
||
|
||
// Utility function to add timeout to promises
|
||
const withTimeout = <T>(promise: Promise<T>, timeout: number, fallback?: T): Promise<T> => {
|
||
return Promise.race([
|
||
promise,
|
||
new Promise<T>((resolve, reject) =>
|
||
setTimeout(() => fallback ? resolve(fallback) : reject(new Error('Request timed out')), timeout)
|
||
)
|
||
]);
|
||
};
|
||
|
||
// Utility function for parallel loading with fallback
|
||
const loadWithFallback = async <T>(
|
||
loadFn: () => Promise<T>,
|
||
fallback: T,
|
||
timeout: number = API_TIMEOUT
|
||
): Promise<T> => {
|
||
try {
|
||
return await withTimeout(loadFn(), timeout, fallback);
|
||
} catch (error) {
|
||
logger.error('Loading failed, using fallback:', error);
|
||
return fallback;
|
||
}
|
||
};
|
||
|
||
// Utility function to retry failed requests
|
||
const withRetry = async <T>(
|
||
fn: () => Promise<T>,
|
||
retries = MAX_RETRIES,
|
||
delay = RETRY_DELAY
|
||
): Promise<T> => {
|
||
try {
|
||
return await fn();
|
||
} catch (error) {
|
||
if (retries === 0) throw error;
|
||
await new Promise(resolve => setTimeout(resolve, delay));
|
||
return withRetry(fn, retries - 1, delay);
|
||
}
|
||
};
|
||
|
||
interface UseMetadataProps {
|
||
id: string;
|
||
type: string;
|
||
addonId?: string;
|
||
}
|
||
|
||
interface ScraperStatus {
|
||
id: string;
|
||
name: string;
|
||
isLoading: boolean;
|
||
hasCompleted: boolean;
|
||
error: string | null;
|
||
startTime: number;
|
||
endTime: number | null;
|
||
}
|
||
|
||
interface UseMetadataReturn {
|
||
metadata: StreamingContent | null;
|
||
loading: boolean;
|
||
error: string | null;
|
||
cast: Cast[];
|
||
loadingCast: boolean;
|
||
episodes: Episode[];
|
||
groupedEpisodes: GroupedEpisodes;
|
||
selectedSeason: number;
|
||
tmdbId: number | null;
|
||
loadingSeasons: boolean;
|
||
groupedStreams: GroupedStreams;
|
||
loadingStreams: boolean;
|
||
episodeStreams: GroupedStreams;
|
||
loadingEpisodeStreams: boolean;
|
||
addonResponseOrder: string[];
|
||
preloadedStreams: GroupedStreams;
|
||
preloadedEpisodeStreams: { [episodeId: string]: GroupedStreams };
|
||
selectedEpisode: string | null;
|
||
inLibrary: boolean;
|
||
loadMetadata: () => Promise<void>;
|
||
loadStreams: () => Promise<void>;
|
||
loadEpisodeStreams: (episodeId: string) => Promise<void>;
|
||
handleSeasonChange: (seasonNumber: number) => void;
|
||
toggleLibrary: () => void;
|
||
setSelectedEpisode: (episodeId: string | null) => void;
|
||
setEpisodeStreams: (streams: GroupedStreams) => void;
|
||
recommendations: StreamingContent[];
|
||
loadingRecommendations: boolean;
|
||
setMetadata: React.Dispatch<React.SetStateAction<StreamingContent | null>>;
|
||
imdbId: string | null;
|
||
scraperStatuses: ScraperStatus[];
|
||
activeFetchingScrapers: string[];
|
||
collectionMovies: StreamingContent[];
|
||
loadingCollection: boolean;
|
||
}
|
||
|
||
export const useMetadata = ({ id, type, addonId }: UseMetadataProps): UseMetadataReturn => {
|
||
const { settings, isLoaded: settingsLoaded } = useSettings();
|
||
const [metadata, setMetadata] = useState<StreamingContent | null>(null);
|
||
const [loading, setLoading] = useState(true);
|
||
const [error, setError] = useState<string | null>(null);
|
||
const [cast, setCast] = useState<Cast[]>([]);
|
||
const [loadingCast, setLoadingCast] = useState(false);
|
||
const [episodes, setEpisodes] = useState<Episode[]>([]);
|
||
const [groupedEpisodes, setGroupedEpisodes] = useState<GroupedEpisodes>({});
|
||
const [selectedSeason, setSelectedSeason] = useState<number>(1);
|
||
const [tmdbId, setTmdbId] = useState<number | null>(null);
|
||
const [loadingSeasons, setLoadingSeasons] = useState(false);
|
||
const [groupedStreams, setGroupedStreams] = useState<GroupedStreams>({});
|
||
const [loadingStreams, setLoadingStreams] = useState(false);
|
||
const [episodeStreams, setEpisodeStreams] = useState<GroupedStreams>({});
|
||
const [loadingEpisodeStreams, setLoadingEpisodeStreams] = useState(false);
|
||
const [preloadedStreams, setPreloadedStreams] = useState<GroupedStreams>({});
|
||
const [preloadedEpisodeStreams, setPreloadedEpisodeStreams] = useState<{ [episodeId: string]: GroupedStreams }>({});
|
||
const [selectedEpisode, setSelectedEpisode] = useState<string | null>(null);
|
||
const [inLibrary, setInLibrary] = useState(false);
|
||
const [loadAttempts, setLoadAttempts] = useState(0);
|
||
const [recommendations, setRecommendations] = useState<StreamingContent[]>([]);
|
||
const [loadingRecommendations, setLoadingRecommendations] = useState(false);
|
||
const [collectionMovies, setCollectionMovies] = useState<StreamingContent[]>([]);
|
||
const [loadingCollection, setLoadingCollection] = useState(false);
|
||
const [imdbId, setImdbId] = useState<string | null>(null);
|
||
const [isLoading, setIsLoading] = useState(false);
|
||
const [availableStreams, setAvailableStreams] = useState<{ [sourceType: string]: Stream }>({});
|
||
const [scraperStatuses, setScraperStatuses] = useState<ScraperStatus[]>([]);
|
||
const [activeFetchingScrapers, setActiveFetchingScrapers] = useState<string[]>([]);
|
||
// Track response order for addons to preserve actual response order
|
||
const [addonResponseOrder, setAddonResponseOrder] = useState<string[]>([]);
|
||
// Prevent re-initializing season selection repeatedly for the same series
|
||
const initializedSeasonRef = useRef(false);
|
||
|
||
// Memory optimization: Track stream counts and implement cleanup (limits removed)
|
||
const streamCountRef = useRef(0);
|
||
const cleanupTimeoutRef = useRef<NodeJS.Timeout | null>(null);
|
||
|
||
// Add hook for persistent seasons
|
||
const { getSeason, saveSeason } = usePersistentSeasons();
|
||
|
||
// Memory optimization: Stream cleanup and garbage collection
|
||
const cleanupStreams = useCallback(() => {
|
||
if (__DEV__) console.log('[useMetadata] Running stream cleanup to free memory');
|
||
|
||
// Clear preloaded streams cache
|
||
setPreloadedStreams({});
|
||
setPreloadedEpisodeStreams({});
|
||
|
||
// Reset stream count
|
||
streamCountRef.current = 0;
|
||
|
||
// Force garbage collection if available (development only)
|
||
if (__DEV__ && global.gc) {
|
||
global.gc();
|
||
}
|
||
}, []);
|
||
|
||
// Memory optimization: Debounced stream state updates
|
||
const debouncedStreamUpdate = useCallback((updateFn: () => void) => {
|
||
// Clear existing timeout
|
||
if (cleanupTimeoutRef.current) {
|
||
clearTimeout(cleanupTimeoutRef.current);
|
||
}
|
||
|
||
// Set new timeout for cleanup
|
||
cleanupTimeoutRef.current = setTimeout(() => {
|
||
cleanupStreams();
|
||
}, 30000); // Cleanup after 30 seconds of inactivity
|
||
|
||
// Execute the update
|
||
updateFn();
|
||
}, [cleanupStreams]);
|
||
|
||
// Memory optimization: Lightly optimize stream data (no sorting or limiting)
|
||
const optimizeStreams = useCallback((streams: Stream[]): Stream[] => {
|
||
if (!streams || streams.length === 0) return streams;
|
||
return streams.map(stream => ({
|
||
...stream,
|
||
description: stream.description && stream.description.length > 200
|
||
? stream.description.substring(0, 200) + '...'
|
||
: stream.description,
|
||
behaviorHints: stream.behaviorHints ? {
|
||
cached: stream.behaviorHints.cached,
|
||
notWebReady: stream.behaviorHints.notWebReady,
|
||
bingeGroup: stream.behaviorHints.bingeGroup,
|
||
} : undefined,
|
||
}));
|
||
}, []);
|
||
|
||
const processStremioSource = async (type: string, id: string, isEpisode = false) => {
|
||
const sourceStartTime = Date.now();
|
||
const logPrefix = isEpisode ? 'loadEpisodeStreams' : 'loadStreams';
|
||
const sourceName = 'stremio';
|
||
|
||
if (__DEV__) logger.log(`🔍 [${logPrefix}:${sourceName}] Starting fetch`);
|
||
|
||
try {
|
||
await stremioService.getStreams(type, id,
|
||
(streams, addonId, addonName, error, installationId) => {
|
||
const processTime = Date.now() - sourceStartTime;
|
||
|
||
console.log('🔍 [processStremioSource] Callback received:', {
|
||
addonId,
|
||
addonName,
|
||
installationId,
|
||
streamCount: streams?.length || 0,
|
||
error: error?.message || null,
|
||
processTime
|
||
});
|
||
|
||
// ALWAYS remove from active fetching list when callback is received
|
||
// This ensures that even failed scrapers are removed from the "Fetching from:" chip
|
||
if (addonName) {
|
||
setActiveFetchingScrapers(prev => {
|
||
const updated = prev.filter(name => name !== addonName);
|
||
console.log('🔍 [processStremioSource] Removing from activeFetchingScrapers:', {
|
||
addonName,
|
||
before: prev,
|
||
after: updated
|
||
});
|
||
return updated;
|
||
});
|
||
}
|
||
|
||
// Update scraper status when we get a callback
|
||
if (addonId && addonName) {
|
||
setScraperStatuses(prevStatuses => {
|
||
const existingIndex = prevStatuses.findIndex(s => s.id === addonId);
|
||
const newStatus: ScraperStatus = {
|
||
id: addonId,
|
||
name: addonName,
|
||
isLoading: false,
|
||
hasCompleted: true,
|
||
error: error ? error.message : null,
|
||
startTime: sourceStartTime,
|
||
endTime: Date.now()
|
||
};
|
||
|
||
if (existingIndex >= 0) {
|
||
const updated = [...prevStatuses];
|
||
updated[existingIndex] = newStatus;
|
||
return updated;
|
||
} else {
|
||
return [...prevStatuses, newStatus];
|
||
}
|
||
});
|
||
}
|
||
|
||
if (error) {
|
||
logger.error(`❌ [${logPrefix}:${sourceName}] Error for addon ${addonName} (${addonId}):`, error);
|
||
} else if (streams && addonId && addonName) {
|
||
if (__DEV__) logger.log(`✅ [${logPrefix}:${sourceName}] Received ${streams.length} streams from ${addonName} (${addonId}) after ${processTime}ms`);
|
||
|
||
if (streams.length > 0) {
|
||
// Optimize streams before storing
|
||
const optimizedStreams = optimizeStreams(streams);
|
||
streamCountRef.current += optimizedStreams.length;
|
||
|
||
if (__DEV__) logger.log(`📊 [${logPrefix}:${sourceName}] Optimized ${streams.length} → ${optimizedStreams.length} streams, total: ${streamCountRef.current}`);
|
||
|
||
// Use debounced update to prevent rapid state changes
|
||
debouncedStreamUpdate(() => {
|
||
const updateState = (prevState: GroupedStreams): GroupedStreams => {
|
||
// Use installationId as key to keep multiple installations separate
|
||
const key = installationId || addonId || 'unknown';
|
||
if (__DEV__) logger.log(`🔄 [${logPrefix}:${sourceName}] Updating state for addon ${addonName} (${addonId}) [${installationId}]`);
|
||
return {
|
||
...prevState,
|
||
[key]: {
|
||
addonName: addonName,
|
||
streams: optimizedStreams // Use optimized streams
|
||
}
|
||
};
|
||
};
|
||
|
||
// Track response order for addons (use installationId to track each installation separately)
|
||
setAddonResponseOrder(prevOrder => {
|
||
const key = installationId || addonId || 'unknown';
|
||
if (!prevOrder.includes(key)) {
|
||
return [...prevOrder, key];
|
||
}
|
||
return prevOrder;
|
||
});
|
||
|
||
if (isEpisode) {
|
||
setEpisodeStreams(updateState);
|
||
setLoadingEpisodeStreams(false);
|
||
} else {
|
||
setGroupedStreams(updateState);
|
||
setLoadingStreams(false);
|
||
}
|
||
});
|
||
} else {
|
||
// Even providers with no streams should be added to the streams object
|
||
// This ensures streamsEmpty becomes false and UI shows available streams progressively
|
||
if (__DEV__) logger.log(`🤷 [${logPrefix}:${sourceName}] No streams found for addon ${addonName} (${addonId})`);
|
||
|
||
debouncedStreamUpdate(() => {
|
||
const updateState = (prevState: GroupedStreams): GroupedStreams => {
|
||
// Use installationId as key to keep multiple installations separate
|
||
const key = installationId || addonId || 'unknown';
|
||
if (__DEV__) logger.log(`🔄 [${logPrefix}:${sourceName}] Adding empty provider ${addonName} (${addonId}) [${installationId}] to state`);
|
||
return {
|
||
...prevState,
|
||
[key]: {
|
||
addonName: addonName,
|
||
streams: [] // Empty array for providers with no streams
|
||
}
|
||
};
|
||
};
|
||
|
||
// Track response order for addons (use installationId to track each installation separately)
|
||
setAddonResponseOrder(prevOrder => {
|
||
const key = installationId || addonId || 'unknown';
|
||
if (!prevOrder.includes(key)) {
|
||
return [...prevOrder, key];
|
||
}
|
||
return prevOrder;
|
||
});
|
||
|
||
if (isEpisode) {
|
||
setEpisodeStreams(updateState);
|
||
setLoadingEpisodeStreams(false);
|
||
} else {
|
||
setGroupedStreams(updateState);
|
||
setLoadingStreams(false);
|
||
}
|
||
});
|
||
}
|
||
} else {
|
||
// Handle case where callback provides null streams without error (e.g., empty results)
|
||
if (__DEV__) logger.log(`🏁 [${logPrefix}:${sourceName}] Finished fetching for addon ${addonName} (${addonId}) with no streams after ${processTime}ms`);
|
||
}
|
||
}
|
||
);
|
||
// The function now returns void, just await to let callbacks fire
|
||
if (__DEV__) logger.log(`🏁 [${logPrefix}:${sourceName}] Stremio fetching process initiated`);
|
||
} catch (error) {
|
||
// Catch errors from the initial call to getStreams (e.g., initialization errors)
|
||
logger.error(`❌ [${logPrefix}:${sourceName}] Initial call failed:`, error);
|
||
|
||
// Remove all addons and scrapers from active fetching since the entire request failed
|
||
setActiveFetchingScrapers(prev => {
|
||
// Get both Stremio addon names and local scraper names
|
||
const stremioAddons = stremioService.getInstalledAddons();
|
||
const stremioNames = stremioAddons.map(addon => addon.name);
|
||
|
||
// Get local scraper names
|
||
localScraperService.getInstalledScrapers().then(localScrapers => {
|
||
const localScraperNames = localScrapers.filter(s => s.enabled).map(s => s.name);
|
||
const allNames = [...stremioNames, ...localScraperNames];
|
||
|
||
// Remove all from active fetching
|
||
setActiveFetchingScrapers(current =>
|
||
current.filter(name => !allNames.includes(name))
|
||
);
|
||
}).catch(() => {
|
||
// If we can't get local scrapers, just remove Stremio addons
|
||
setActiveFetchingScrapers(current =>
|
||
current.filter(name => !stremioNames.includes(name))
|
||
);
|
||
});
|
||
|
||
// Immediately remove Stremio addons (local scrapers will be removed async above)
|
||
return prev.filter(name => !stremioNames.includes(name));
|
||
});
|
||
|
||
// Update scraper statuses to mark all scrapers as failed
|
||
setScraperStatuses(prevStatuses => {
|
||
const stremioAddons = stremioService.getInstalledAddons();
|
||
|
||
return prevStatuses.map(status => {
|
||
const isStremioAddon = stremioAddons.some(addon => addon.id === status.id || addon.name === status.name);
|
||
|
||
// Mark both Stremio addons and local scrapers as failed
|
||
if (isStremioAddon || !status.hasCompleted) {
|
||
return {
|
||
...status,
|
||
isLoading: false,
|
||
hasCompleted: true,
|
||
error: error instanceof Error ? error.message : 'Initial request failed',
|
||
endTime: Date.now()
|
||
};
|
||
}
|
||
return status;
|
||
});
|
||
});
|
||
}
|
||
// Note: This function completes when getStreams returns, not when all callbacks have fired.
|
||
// Loading indicators should probably be managed based on callbacks completing.
|
||
};
|
||
|
||
const loadCast = async () => {
|
||
if (__DEV__) logger.log('[loadCast] Starting cast fetch for:', id);
|
||
setLoadingCast(true);
|
||
try {
|
||
// Check both master switch AND granular cast setting
|
||
if (!settings.enrichMetadataWithTMDB || !settings.tmdbEnrichCast) {
|
||
if (__DEV__) logger.log('[loadCast] TMDB cast enrichment disabled by settings');
|
||
|
||
// Check if we have addon cast data available
|
||
if (metadata?.addonCast && metadata.addonCast.length > 0) {
|
||
if (__DEV__) logger.log(`[loadCast] Using addon cast data: ${metadata.addonCast.length} cast members`);
|
||
setCast(metadata.addonCast);
|
||
setLoadingCast(false);
|
||
return;
|
||
}
|
||
|
||
if (__DEV__) logger.log('[loadCast] No addon cast data available');
|
||
setLoadingCast(false);
|
||
return;
|
||
}
|
||
// Check cache first
|
||
const cachedCast = cacheService.getCast(id, type);
|
||
if (cachedCast) {
|
||
if (__DEV__) logger.log('[loadCast] Using cached cast data');
|
||
setCast(cachedCast);
|
||
setLoadingCast(false);
|
||
return;
|
||
}
|
||
|
||
// Handle TMDB IDs
|
||
if (id.startsWith('tmdb:')) {
|
||
const tmdbId = id.split(':')[1];
|
||
if (__DEV__) logger.log('[loadCast] Using TMDB ID directly:', tmdbId);
|
||
const castData = await tmdbService.getCredits(parseInt(tmdbId), type);
|
||
if (castData && castData.cast) {
|
||
const formattedCast = castData.cast.map((actor: any) => ({
|
||
id: actor.id,
|
||
name: actor.name,
|
||
character: actor.character,
|
||
profile_path: actor.profile_path
|
||
}));
|
||
if (__DEV__) logger.log(`[loadCast] Found ${formattedCast.length} cast members from TMDB`);
|
||
setCast(formattedCast);
|
||
cacheService.setCast(id, type, formattedCast);
|
||
setLoadingCast(false);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Handle IMDb IDs or convert to TMDB ID (only if enrichment is enabled)
|
||
let tmdbId;
|
||
if (id.startsWith('tt') && settings.enrichMetadataWithTMDB) {
|
||
if (__DEV__) logger.log('[loadCast] Converting IMDb ID to TMDB ID');
|
||
tmdbId = await tmdbService.findTMDBIdByIMDB(id);
|
||
}
|
||
|
||
if (tmdbId) {
|
||
if (__DEV__) logger.log('[loadCast] Fetching cast using TMDB ID:', tmdbId);
|
||
const castData = await tmdbService.getCredits(tmdbId, type);
|
||
if (castData && castData.cast) {
|
||
const formattedCast = castData.cast.map((actor: any) => ({
|
||
id: actor.id,
|
||
name: actor.name,
|
||
character: actor.character,
|
||
profile_path: actor.profile_path
|
||
}));
|
||
if (__DEV__) logger.log(`[loadCast] Found ${formattedCast.length} cast members`);
|
||
setCast(formattedCast);
|
||
cacheService.setCast(id, type, formattedCast);
|
||
}
|
||
} else {
|
||
if (__DEV__) logger.warn('[loadCast] Could not find TMDB ID for cast fetch');
|
||
}
|
||
} catch (error) {
|
||
logger.error('[loadCast] Failed to load cast:', error);
|
||
// Don't clear existing cast data on error
|
||
} finally {
|
||
setLoadingCast(false);
|
||
}
|
||
};
|
||
|
||
const loadMetadata = async () => {
|
||
try {
|
||
console.log('🔍 [useMetadata] loadMetadata started:', {
|
||
id,
|
||
type,
|
||
addonId,
|
||
loadAttempts,
|
||
maxRetries: MAX_RETRIES,
|
||
settingsLoaded: settingsLoaded
|
||
});
|
||
|
||
if (loadAttempts >= MAX_RETRIES) {
|
||
console.log('🔍 [useMetadata] Max retries exceeded:', { loadAttempts, maxRetries: MAX_RETRIES });
|
||
setError(`Failed to load content after ${MAX_RETRIES + 1} attempts. Please check your connection and try again.`);
|
||
setLoading(false);
|
||
return;
|
||
}
|
||
|
||
setLoading(true);
|
||
setError(null);
|
||
setLoadAttempts(prev => prev + 1);
|
||
|
||
// Check metadata screen cache
|
||
const cachedScreen = cacheService.getMetadataScreen(id, type);
|
||
if (cachedScreen) {
|
||
console.log('🔍 [useMetadata] Using cached metadata:', {
|
||
id,
|
||
type,
|
||
hasMetadata: !!cachedScreen.metadata,
|
||
hasCast: !!cachedScreen.cast,
|
||
hasEpisodes: !!cachedScreen.episodes,
|
||
tmdbId: cachedScreen.tmdbId
|
||
});
|
||
setMetadata(cachedScreen.metadata);
|
||
setCast(cachedScreen.cast);
|
||
if (type === 'series' && cachedScreen.episodes) {
|
||
setGroupedEpisodes(cachedScreen.episodes.groupedEpisodes);
|
||
setEpisodes(cachedScreen.episodes.currentEpisodes);
|
||
setSelectedSeason(cachedScreen.episodes.selectedSeason);
|
||
setTmdbId(cachedScreen.tmdbId);
|
||
}
|
||
// Check if item is in library
|
||
(async () => {
|
||
const items = await catalogService.getLibraryItems();
|
||
const isInLib = items.some(item => item.id === id);
|
||
setInLibrary(isInLib);
|
||
})();
|
||
setLoading(false);
|
||
return;
|
||
} else {
|
||
console.log('🔍 [useMetadata] No cached metadata found, proceeding with fresh fetch');
|
||
}
|
||
|
||
// Handle TMDB-specific IDs
|
||
let actualId = id;
|
||
if (id.startsWith('tmdb:')) {
|
||
// Always try the original TMDB ID first - let addons decide if they support it
|
||
console.log('🔍 [useMetadata] TMDB ID detected, trying original ID first:', { originalId: id });
|
||
|
||
// If enrichment disabled, try original ID first, then fallback to conversion if needed
|
||
if (!settings.enrichMetadataWithTMDB) {
|
||
// Keep the original TMDB ID - let the addon system handle it dynamically
|
||
actualId = id;
|
||
console.log('🔍 [useMetadata] TMDB enrichment disabled, using original TMDB ID:', { actualId });
|
||
} else {
|
||
const tmdbId = id.split(':')[1];
|
||
// For TMDB IDs, we need to handle metadata differently
|
||
if (type === 'movie') {
|
||
if (__DEV__) logger.log('Fetching movie details from TMDB for:', tmdbId);
|
||
const movieDetails = await tmdbService.getMovieDetails(
|
||
tmdbId,
|
||
settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en'
|
||
);
|
||
if (movieDetails) {
|
||
const imdbId = movieDetails.imdb_id || movieDetails.external_ids?.imdb_id;
|
||
if (imdbId) {
|
||
// Use the imdbId for compatibility with the rest of the app
|
||
actualId = imdbId;
|
||
setImdbId(imdbId);
|
||
// Also store the TMDB ID for later use
|
||
setTmdbId(parseInt(tmdbId));
|
||
} else {
|
||
// If no IMDb ID, directly call loadTMDBMovie (create this function if needed)
|
||
const formattedMovie: StreamingContent = {
|
||
id: `tmdb:${tmdbId}`,
|
||
type: 'movie',
|
||
name: movieDetails.title,
|
||
poster: tmdbService.getImageUrl(movieDetails.poster_path) || '',
|
||
banner: tmdbService.getImageUrl(movieDetails.backdrop_path) || '',
|
||
description: movieDetails.overview || '',
|
||
year: movieDetails.release_date ? parseInt(movieDetails.release_date.substring(0, 4)) : undefined,
|
||
genres: movieDetails.genres?.map((g: { name: string }) => g.name) || [],
|
||
inLibrary: false,
|
||
};
|
||
|
||
// OPTIMIZATION: Fetch credits and logo in parallel instead of sequentially
|
||
const preferredLanguage = settings.tmdbLanguagePreference || 'en';
|
||
const [creditsResult, logoResult] = await Promise.allSettled([
|
||
tmdbService.getCredits(parseInt(tmdbId), 'movie'),
|
||
tmdbService.getContentLogo('movie', tmdbId, preferredLanguage)
|
||
]);
|
||
|
||
// Process credits result
|
||
if (creditsResult.status === 'fulfilled' && creditsResult.value?.crew) {
|
||
const credits = creditsResult.value;
|
||
// Extract directors
|
||
const directors = credits.crew
|
||
.filter((person: any) => person.job === 'Director')
|
||
.map((person: any) => person.name);
|
||
|
||
// Extract creators/writers
|
||
const writers = credits.crew
|
||
.filter((person: any) => ['Writer', 'Screenplay'].includes(person.job))
|
||
.map((person: any) => person.name);
|
||
|
||
// Add to formatted movie
|
||
if (directors.length > 0) {
|
||
(formattedMovie as any).directors = directors;
|
||
(formattedMovie as StreamingContent & { director: string }).director = directors.join(', ');
|
||
}
|
||
|
||
if (writers.length > 0) {
|
||
(formattedMovie as any).creators = writers;
|
||
(formattedMovie as any).writer = writers;
|
||
}
|
||
} else if (creditsResult.status === 'rejected') {
|
||
logger.error('Failed to fetch credits for movie:', creditsResult.reason);
|
||
}
|
||
|
||
// Process logo result
|
||
if (logoResult.status === 'fulfilled') {
|
||
formattedMovie.logo = logoResult.value || undefined;
|
||
if (__DEV__) logger.log(`Successfully fetched logo for movie ${tmdbId} from TMDB`);
|
||
} else {
|
||
logger.error('Failed to fetch logo from TMDB:', logoResult.reason);
|
||
formattedMovie.logo = undefined;
|
||
}
|
||
|
||
setMetadata(formattedMovie);
|
||
cacheService.setMetadata(id, type, formattedMovie);
|
||
(async () => {
|
||
const items = await catalogService.getLibraryItems();
|
||
const isInLib = items.some(item => item.id === id);
|
||
setInLibrary(isInLib);
|
||
})();
|
||
setLoading(false);
|
||
return;
|
||
}
|
||
}
|
||
} else if (type === 'series') {
|
||
// Handle TV shows with TMDB IDs
|
||
if (__DEV__) logger.log('Fetching TV show details from TMDB for:', tmdbId);
|
||
try {
|
||
const showDetails = await tmdbService.getTVShowDetails(
|
||
parseInt(tmdbId),
|
||
settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en'
|
||
);
|
||
if (showDetails) {
|
||
// OPTIMIZATION: Fetch external IDs, credits, and logo in parallel
|
||
const preferredLanguage = settings.tmdbLanguagePreference || 'en';
|
||
const [externalIdsResult, creditsResult, logoResult] = await Promise.allSettled([
|
||
tmdbService.getShowExternalIds(parseInt(tmdbId)),
|
||
tmdbService.getCredits(parseInt(tmdbId), 'series'),
|
||
tmdbService.getContentLogo('tv', tmdbId, preferredLanguage)
|
||
]);
|
||
|
||
const externalIds = externalIdsResult.status === 'fulfilled' ? externalIdsResult.value : null;
|
||
const imdbId = externalIds?.imdb_id;
|
||
|
||
if (imdbId) {
|
||
// Use the imdbId for compatibility with the rest of the app
|
||
actualId = imdbId;
|
||
setImdbId(imdbId);
|
||
// Also store the TMDB ID for later use
|
||
setTmdbId(parseInt(tmdbId));
|
||
} else {
|
||
// If no IMDb ID, create formatted show from TMDB data
|
||
const formattedShow: StreamingContent = {
|
||
id: `tmdb:${tmdbId}`,
|
||
type: 'series',
|
||
name: showDetails.name,
|
||
poster: tmdbService.getImageUrl(showDetails.poster_path) || '',
|
||
banner: tmdbService.getImageUrl(showDetails.backdrop_path) || '',
|
||
description: showDetails.overview || '',
|
||
year: showDetails.first_air_date ? parseInt(showDetails.first_air_date.substring(0, 4)) : undefined,
|
||
genres: showDetails.genres?.map((g: { name: string }) => g.name) || [],
|
||
inLibrary: false,
|
||
};
|
||
|
||
// Process credits result (already fetched in parallel)
|
||
if (creditsResult.status === 'fulfilled' && creditsResult.value?.crew) {
|
||
const credits = creditsResult.value;
|
||
// Extract creators
|
||
const creators = credits.crew
|
||
.filter((person: any) =>
|
||
person.job === 'Creator' ||
|
||
person.job === 'Series Creator' ||
|
||
person.department === 'Production' ||
|
||
person.job === 'Executive Producer'
|
||
)
|
||
.map((person: any) => person.name);
|
||
|
||
if (creators.length > 0) {
|
||
(formattedShow as any).creators = creators.slice(0, 3);
|
||
}
|
||
} else if (creditsResult.status === 'rejected') {
|
||
logger.error('Failed to fetch credits for TV show:', creditsResult.reason);
|
||
}
|
||
|
||
// Process logo result (already fetched in parallel)
|
||
if (logoResult.status === 'fulfilled') {
|
||
formattedShow.logo = logoResult.value || undefined;
|
||
if (__DEV__) logger.log(`Successfully fetched logo for TV show ${tmdbId} from TMDB`);
|
||
} else {
|
||
logger.error('Failed to fetch logo from TMDB:', (logoResult as PromiseRejectedResult).reason);
|
||
formattedShow.logo = undefined;
|
||
}
|
||
|
||
setMetadata(formattedShow);
|
||
cacheService.setMetadata(id, type, formattedShow);
|
||
|
||
// Load series data (episodes)
|
||
setTmdbId(parseInt(tmdbId));
|
||
loadSeriesData().catch((error) => { if (__DEV__) console.error(error); });
|
||
|
||
(async () => {
|
||
const items = await catalogService.getLibraryItems();
|
||
const isInLib = items.some(item => item.id === id);
|
||
setInLibrary(isInLib);
|
||
})();
|
||
setLoading(false);
|
||
return;
|
||
}
|
||
}
|
||
} catch (error) {
|
||
logger.error('Failed to fetch TV show details from TMDB:', error);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Load all data in parallel
|
||
console.log('🔍 [useMetadata] Starting parallel data fetch:', { type, actualId, addonId, apiTimeout: API_TIMEOUT });
|
||
if (__DEV__) logger.log('[loadMetadata] fetching addon metadata', { type, actualId, addonId });
|
||
|
||
let contentResult = null;
|
||
let lastError = null;
|
||
|
||
// Check if user prefers external meta addons
|
||
const preferExternal = settings.preferExternalMetaAddonDetail;
|
||
|
||
if (preferExternal) {
|
||
// Try external meta addons first
|
||
try {
|
||
console.log('🔍 [useMetadata] Trying external meta addons first');
|
||
const [content, castData] = await Promise.allSettled([
|
||
withRetry(async () => {
|
||
// Get all installed addons
|
||
const allAddons = await stremioService.getInstalledAddonsAsync();
|
||
|
||
// Find catalog addon index
|
||
const catalogAddonIndex = allAddons.findIndex(addon => addon.id === addonId);
|
||
|
||
// Filter for meta addons that are BEFORE catalog addon in priority
|
||
const externalMetaAddons = allAddons
|
||
.slice(0, catalogAddonIndex >= 0 ? catalogAddonIndex : allAddons.length)
|
||
.filter(addon => {
|
||
if (!addon.resources || !Array.isArray(addon.resources)) return false;
|
||
|
||
return addon.resources.some(resource => {
|
||
if (typeof resource === 'string') return resource === 'meta';
|
||
return (resource as any).name === 'meta';
|
||
});
|
||
});
|
||
|
||
// Try each external meta addon in priority order
|
||
for (const addon of externalMetaAddons) {
|
||
try {
|
||
const result = await withTimeout(
|
||
stremioService.getMetaDetails(type, actualId, addon.id),
|
||
API_TIMEOUT
|
||
);
|
||
|
||
if (result) {
|
||
console.log('🔍 [useMetadata] Got metadata from external addon:', addon.name);
|
||
if (actualId.startsWith('tt')) {
|
||
setImdbId(actualId);
|
||
}
|
||
return result;
|
||
}
|
||
} catch (error) {
|
||
console.log('🔍 [useMetadata] External addon failed:', addon.name, error);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// If no external addon worked, fall back to catalog addon
|
||
console.log('🔍 [useMetadata] No external meta addon worked, falling back to catalog addon');
|
||
const result = await withTimeout(
|
||
catalogService.getEnhancedContentDetails(type, actualId, addonId),
|
||
API_TIMEOUT
|
||
);
|
||
if (actualId.startsWith('tt')) {
|
||
setImdbId(actualId);
|
||
}
|
||
return result;
|
||
}),
|
||
loadCast()
|
||
]);
|
||
|
||
contentResult = content;
|
||
if (content.status === 'fulfilled' && content.value) {
|
||
console.log('🔍 [useMetadata] Successfully got metadata with external meta addon priority');
|
||
} else {
|
||
console.log('🔍 [useMetadata] External meta addon priority failed, will try fallback');
|
||
lastError = (content as any)?.reason;
|
||
}
|
||
} catch (error) {
|
||
console.log('🔍 [useMetadata] External meta addon attempt failed:', { error: error instanceof Error ? error.message : String(error) });
|
||
lastError = error;
|
||
}
|
||
} else {
|
||
// Original behavior: try with original ID first
|
||
try {
|
||
console.log('🔍 [useMetadata] Attempting metadata fetch with original ID:', { type, actualId, addonId });
|
||
const [content, castData] = await Promise.allSettled([
|
||
// Load content with timeout and retry
|
||
withRetry(async () => {
|
||
console.log('🔍 [useMetadata] Calling catalogService.getEnhancedContentDetails:', { type, actualId, addonId });
|
||
const result = await withTimeout(
|
||
catalogService.getEnhancedContentDetails(type, actualId, addonId),
|
||
API_TIMEOUT
|
||
);
|
||
// Store the actual ID used (could be IMDB)
|
||
if (actualId.startsWith('tt')) {
|
||
setImdbId(actualId);
|
||
}
|
||
console.log('🔍 [useMetadata] catalogService.getEnhancedContentDetails result:', {
|
||
hasResult: Boolean(result),
|
||
resultId: result?.id,
|
||
resultName: result?.name,
|
||
resultType: result?.type
|
||
});
|
||
if (__DEV__) logger.log('[loadMetadata] addon metadata fetched', { hasResult: Boolean(result) });
|
||
return result;
|
||
}),
|
||
// Start loading cast immediately in parallel
|
||
loadCast()
|
||
]);
|
||
|
||
contentResult = content;
|
||
if (content.status === 'fulfilled' && content.value) {
|
||
console.log('🔍 [useMetadata] Successfully got metadata with original ID');
|
||
} else {
|
||
console.log('🔍 [useMetadata] Original ID failed, will try fallback conversion');
|
||
lastError = (content as any)?.reason;
|
||
}
|
||
} catch (error) {
|
||
console.log('🔍 [useMetadata] Original ID attempt failed:', { error: error instanceof Error ? error.message : String(error) });
|
||
lastError = error;
|
||
}
|
||
}
|
||
|
||
// If original TMDB ID failed and enrichment is disabled, try ID conversion as fallback
|
||
if (!contentResult || (contentResult.status === 'fulfilled' && !contentResult.value) || contentResult.status === 'rejected') {
|
||
if (id.startsWith('tmdb:') && !settings.enrichMetadataWithTMDB) {
|
||
console.log('🔍 [useMetadata] Original TMDB ID failed, trying ID conversion fallback');
|
||
const tmdbRaw = id.split(':')[1];
|
||
try {
|
||
const stremioId = await catalogService.getStremioId(type === 'series' ? 'tv' : 'movie', tmdbRaw);
|
||
if (stremioId && stremioId !== id) {
|
||
console.log('🔍 [useMetadata] Trying converted ID:', { originalId: id, convertedId: stremioId });
|
||
const [content, castData] = await Promise.allSettled([
|
||
withRetry(async () => {
|
||
const result = await withTimeout(
|
||
catalogService.getEnhancedContentDetails(type, stremioId, addonId),
|
||
API_TIMEOUT
|
||
);
|
||
if (stremioId.startsWith('tt')) {
|
||
setImdbId(stremioId);
|
||
}
|
||
return result;
|
||
}),
|
||
loadCast()
|
||
]);
|
||
contentResult = content;
|
||
}
|
||
} catch (e) {
|
||
console.log('🔍 [useMetadata] ID conversion fallback also failed:', { error: e instanceof Error ? e.message : String(e) });
|
||
}
|
||
}
|
||
}
|
||
|
||
const content = contentResult || { status: 'rejected' as const, reason: lastError || new Error('No content result') };
|
||
const castData = { status: 'fulfilled' as const, value: undefined };
|
||
|
||
console.log('🔍 [useMetadata] Promise.allSettled results:', {
|
||
contentStatus: content.status,
|
||
contentFulfilled: content.status === 'fulfilled',
|
||
hasContentValue: content.status === 'fulfilled' ? !!content.value : false,
|
||
castStatus: castData.status,
|
||
castFulfilled: castData.status === 'fulfilled'
|
||
});
|
||
|
||
if (content.status === 'fulfilled' && content.value) {
|
||
console.log('🔍 [useMetadata] Content fetch successful:', {
|
||
id: content.value?.id,
|
||
type: content.value?.type,
|
||
name: content.value?.name,
|
||
hasDescription: !!content.value?.description,
|
||
hasPoster: !!content.value?.poster
|
||
});
|
||
if (__DEV__) logger.log('[loadMetadata] addon metadata:success', { id: content.value?.id, type: content.value?.type, name: content.value?.name });
|
||
|
||
// Start with addon metadata
|
||
let finalMetadata = content.value as StreamingContent;
|
||
|
||
// Store addon logo before TMDB enrichment overwrites it
|
||
const addonLogo = (finalMetadata as any).logo;
|
||
|
||
|
||
try {
|
||
if (settings.enrichMetadataWithTMDB && settings.tmdbEnrichTitleDescription) {
|
||
const tmdbSvc = TMDBService.getInstance();
|
||
let finalTmdbId: number | null = tmdbId;
|
||
if (!finalTmdbId) {
|
||
finalTmdbId = await tmdbSvc.extractTMDBIdFromStremioId(actualId);
|
||
if (finalTmdbId) setTmdbId(finalTmdbId);
|
||
}
|
||
|
||
if (finalTmdbId) {
|
||
const lang = settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en';
|
||
if (type === 'movie') {
|
||
const localized = await tmdbSvc.getMovieDetails(String(finalTmdbId), lang);
|
||
if (localized) {
|
||
const movieDetailsObj = {
|
||
status: localized.status,
|
||
releaseDate: localized.release_date,
|
||
runtime: localized.runtime,
|
||
budget: localized.budget,
|
||
revenue: localized.revenue,
|
||
originalLanguage: localized.original_language,
|
||
originCountry: localized.production_countries?.map((c: any) => c.iso_3166_1),
|
||
tagline: localized.tagline,
|
||
};
|
||
const productionInfo = Array.isArray(localized.production_companies)
|
||
? localized.production_companies
|
||
.map((c: any) => ({ id: c?.id, name: c?.name, logo: tmdbSvc.getImageUrl(c?.logo_path, 'w185') }))
|
||
.filter((c: any) => c && (c.logo || c.name))
|
||
: [];
|
||
|
||
finalMetadata = {
|
||
...finalMetadata,
|
||
name: localized.title || finalMetadata.name,
|
||
description: localized.overview || finalMetadata.description,
|
||
movieDetails: movieDetailsObj,
|
||
...(productionInfo.length > 0 && { networks: productionInfo }),
|
||
};
|
||
}
|
||
} else { // 'series'
|
||
const localized = await tmdbSvc.getTVShowDetails(Number(finalTmdbId), lang);
|
||
if (localized) {
|
||
const tvDetails = {
|
||
status: localized.status,
|
||
firstAirDate: localized.first_air_date,
|
||
lastAirDate: localized.last_air_date,
|
||
numberOfSeasons: localized.number_of_seasons,
|
||
numberOfEpisodes: localized.number_of_episodes,
|
||
episodeRunTime: localized.episode_run_time,
|
||
type: localized.type,
|
||
originCountry: localized.origin_country,
|
||
originalLanguage: localized.original_language,
|
||
createdBy: localized.created_by?.map(creator => ({
|
||
id: creator.id,
|
||
name: creator.name,
|
||
profile_path: creator.profile_path || undefined
|
||
})),
|
||
};
|
||
const productionInfo = Array.isArray(localized.networks)
|
||
? localized.networks
|
||
.map((n: any) => ({
|
||
id: n?.id,
|
||
name: n?.name,
|
||
logo: tmdbSvc.getImageUrl(n?.logo_path, 'w185') || undefined
|
||
}))
|
||
.filter((n: any) => n && (n.logo || n.name))
|
||
: [];
|
||
|
||
finalMetadata = {
|
||
...finalMetadata,
|
||
name: localized.name || finalMetadata.name,
|
||
description: localized.overview || finalMetadata.description,
|
||
tvDetails,
|
||
...(productionInfo.length > 0 && { networks: productionInfo }),
|
||
};
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
if (__DEV__) console.log('[useMetadata] failed to merge TMDB title/description', e);
|
||
}
|
||
|
||
// Centralized logo fetching logic
|
||
try {
|
||
// When TMDB enrichment AND logos are enabled, prioritize TMDB logo over addon logo
|
||
if (settings.enrichMetadataWithTMDB && settings.tmdbEnrichLogos) {
|
||
const tmdbService = TMDBService.getInstance();
|
||
const preferredLanguage = settings.tmdbLanguagePreference || 'en';
|
||
const contentType = type === 'series' ? 'tv' : 'movie';
|
||
|
||
// Get TMDB ID
|
||
let tmdbIdForLogo = null;
|
||
if (tmdbId) {
|
||
tmdbIdForLogo = String(tmdbId);
|
||
} else if (finalMetadata.imdb_id) {
|
||
const foundId = await tmdbService.findTMDBIdByIMDB(finalMetadata.imdb_id);
|
||
tmdbIdForLogo = foundId ? String(foundId) : null;
|
||
}
|
||
|
||
if (tmdbIdForLogo) {
|
||
const logoUrl = await tmdbService.getContentLogo(contentType, tmdbIdForLogo, preferredLanguage);
|
||
// Use TMDB logo if found, otherwise fall back to addon logo
|
||
finalMetadata.logo = logoUrl || addonLogo || undefined;
|
||
if (__DEV__) {
|
||
console.log('[useMetadata] Logo fetch result:', {
|
||
contentType,
|
||
tmdbIdForLogo,
|
||
preferredLanguage,
|
||
tmdbLogoFound: !!logoUrl,
|
||
usingAddonFallback: !logoUrl && !!addonLogo,
|
||
enrichmentEnabled: true
|
||
});
|
||
}
|
||
} else {
|
||
// No TMDB ID, fall back to addon logo
|
||
finalMetadata.logo = addonLogo || undefined;
|
||
if (__DEV__) console.log('[useMetadata] No TMDB ID found for logo, using addon logo');
|
||
}
|
||
} else {
|
||
// When enrichment or logos is OFF, use addon logo
|
||
finalMetadata.logo = addonLogo || finalMetadata.logo || undefined;
|
||
if (__DEV__) {
|
||
console.log('[useMetadata] TMDB logo enrichment disabled, using addon logo:', {
|
||
hasAddonLogo: !!finalMetadata.logo,
|
||
enrichmentEnabled: settings.enrichMetadataWithTMDB,
|
||
logosEnabled: settings.tmdbEnrichLogos
|
||
});
|
||
}
|
||
}
|
||
} catch (error) {
|
||
// Handle error silently, keep existing logo behavior
|
||
if (__DEV__) console.error('[useMetadata] Unexpected error in logo fetch:', error);
|
||
finalMetadata.logo = undefined;
|
||
}
|
||
|
||
// Commit final metadata once and cache it
|
||
// Store addon logo as fallback if TMDB enrichment is enabled
|
||
if (settings.enrichMetadataWithTMDB && addonLogo) {
|
||
(finalMetadata as any).addonLogo = addonLogo;
|
||
}
|
||
|
||
// Clear banner field if TMDB banner enrichment is enabled to prevent flash
|
||
if (settings.enrichMetadataWithTMDB && settings.tmdbEnrichBanners && !finalMetadata.banner) {
|
||
finalMetadata = {
|
||
...finalMetadata,
|
||
banner: undefined, // Let useMetadataAssets handle banner via TMDB
|
||
};
|
||
}
|
||
|
||
// Preserve existing collection if it was set by fetchProductionInfo
|
||
setMetadata((prev) => {
|
||
const updated = { ...finalMetadata };
|
||
if (prev?.collection) {
|
||
updated.collection = prev.collection;
|
||
}
|
||
return updated;
|
||
});
|
||
cacheService.setMetadata(id, type, finalMetadata);
|
||
(async () => {
|
||
const items = await catalogService.getLibraryItems();
|
||
const isInLib = items.some(item => item.id === id);
|
||
setInLibrary(isInLib);
|
||
})();
|
||
} else {
|
||
// Extract the error from the rejected promise
|
||
const reason = (content as any)?.reason;
|
||
const reasonMessage = reason?.message || String(reason);
|
||
|
||
console.log('🔍 [useMetadata] Content fetch failed:', {
|
||
status: content.status,
|
||
reason: reasonMessage,
|
||
fullReason: reason,
|
||
isAxiosError: reason?.isAxiosError,
|
||
responseStatus: reason?.response?.status,
|
||
responseData: reason?.response?.data
|
||
});
|
||
|
||
if (__DEV__) {
|
||
console.log('[loadMetadata] addon metadata:not found or failed', {
|
||
status: content.status,
|
||
reason: reasonMessage,
|
||
fullReason: reason
|
||
});
|
||
}
|
||
|
||
// Check if this was a network/server error rather than content not found
|
||
if (reasonMessage && (
|
||
reasonMessage.includes('500') ||
|
||
reasonMessage.includes('502') ||
|
||
reasonMessage.includes('503') ||
|
||
reasonMessage.includes('Network Error') ||
|
||
reasonMessage.includes('Request failed')
|
||
)) {
|
||
console.log('🔍 [useMetadata] Detected server/network error, preserving original error');
|
||
// This was a server/network error, preserve the original error message
|
||
throw reason instanceof Error ? reason : new Error(reasonMessage);
|
||
} else {
|
||
console.log('🔍 [useMetadata] Detected content not found error, throwing generic error');
|
||
// This was likely a content not found error
|
||
throw new Error('Content not found');
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.log('🔍 [useMetadata] loadMetadata caught error:', {
|
||
errorMessage: error instanceof Error ? error.message : String(error),
|
||
errorType: typeof error,
|
||
isAxiosError: (error as any)?.isAxiosError,
|
||
responseStatus: (error as any)?.response?.status,
|
||
responseData: (error as any)?.response?.data,
|
||
stack: error instanceof Error ? error.stack : undefined
|
||
});
|
||
|
||
if (__DEV__) {
|
||
console.error('Failed to load metadata:', error);
|
||
console.log('Error message being set:', error instanceof Error ? error.message : String(error));
|
||
}
|
||
|
||
// Preserve the original error details for better error parsing
|
||
const errorMessage = error instanceof Error ? error.message : 'Failed to load content';
|
||
setError(errorMessage);
|
||
|
||
// Clear any stale data
|
||
setMetadata(null);
|
||
setCast([]);
|
||
setGroupedEpisodes({});
|
||
setEpisodes([]);
|
||
} finally {
|
||
console.log('🔍 [useMetadata] loadMetadata completed, setting loading to false');
|
||
setLoading(false);
|
||
}
|
||
};
|
||
|
||
const loadSeriesData = async () => {
|
||
setLoadingSeasons(true);
|
||
try {
|
||
// First check if we have episode data from the addon
|
||
const addonVideos = metadata?.videos;
|
||
if (addonVideos && Array.isArray(addonVideos) && addonVideos.length > 0) {
|
||
if (__DEV__) logger.log(`🎬 Found ${addonVideos.length} episodes from addon metadata for ${metadata?.name || id}`);
|
||
|
||
// Group addon episodes by season
|
||
const groupedAddonEpisodes: GroupedEpisodes = {};
|
||
|
||
addonVideos.forEach((video: any) => {
|
||
// Use season 0 for videos without season numbers (PPV-style content, specials, etc.)
|
||
const seasonNumber = video.season || 0;
|
||
const episodeNumber = video.episode || video.number || 1;
|
||
|
||
if (!groupedAddonEpisodes[seasonNumber]) {
|
||
groupedAddonEpisodes[seasonNumber] = [];
|
||
}
|
||
|
||
// Resolve image and description dynamically from arbitrary addons
|
||
const imageCandidate = (
|
||
video.thumbnail ||
|
||
video.image ||
|
||
video.thumb ||
|
||
(video.images && video.images.still) ||
|
||
null
|
||
);
|
||
const descriptionCandidate = (
|
||
video.overview ||
|
||
video.description ||
|
||
video.plot ||
|
||
video.synopsis ||
|
||
''
|
||
);
|
||
|
||
// Convert addon episode format to our Episode interface
|
||
const episode: Episode = {
|
||
id: video.id,
|
||
name: video.name || video.title || `Episode ${episodeNumber}`,
|
||
overview: descriptionCandidate,
|
||
season_number: seasonNumber,
|
||
episode_number: episodeNumber,
|
||
air_date: video.released ? video.released.split('T')[0] : video.firstAired ? video.firstAired.split('T')[0] : '',
|
||
still_path: imageCandidate,
|
||
vote_average: parseFloat(video.rating) || 0,
|
||
runtime: undefined,
|
||
episodeString: `S${seasonNumber.toString().padStart(2, '0')}E${episodeNumber.toString().padStart(2, '0')}`,
|
||
stremioId: video.id,
|
||
season_poster_path: null
|
||
};
|
||
|
||
groupedAddonEpisodes[seasonNumber].push(episode);
|
||
});
|
||
|
||
// Sort episodes within each season
|
||
Object.keys(groupedAddonEpisodes).forEach(season => {
|
||
groupedAddonEpisodes[parseInt(season)].sort((a, b) => a.episode_number - b.episode_number);
|
||
});
|
||
|
||
if (__DEV__) logger.log(`📺 Processed addon episodes into ${Object.keys(groupedAddonEpisodes).length} seasons`);
|
||
|
||
// Fetch season posters from TMDB only if enrichment AND season posters are enabled
|
||
if (settings.enrichMetadataWithTMDB && settings.tmdbEnrichSeasonPosters) {
|
||
try {
|
||
const lang = settings.useTmdbLocalizedMetadata ? `${settings.tmdbLanguagePreference || 'en'}` : 'en';
|
||
const tmdbIdToUse = tmdbId || (id.startsWith('tt') ? await tmdbService.findTMDBIdByIMDB(id) : null);
|
||
if (tmdbIdToUse) {
|
||
if (!tmdbId) setTmdbId(tmdbIdToUse);
|
||
const showDetails = await tmdbService.getTVShowDetails(tmdbIdToUse, lang);
|
||
if (showDetails?.seasons) {
|
||
Object.keys(groupedAddonEpisodes).forEach(seasonStr => {
|
||
const seasonNum = parseInt(seasonStr, 10);
|
||
const seasonInfo = showDetails.seasons.find(s => s.season_number === seasonNum);
|
||
const seasonPosterPath = seasonInfo?.poster_path;
|
||
if (seasonPosterPath) {
|
||
groupedAddonEpisodes[seasonNum] = groupedAddonEpisodes[seasonNum].map(ep => ({
|
||
...ep,
|
||
season_poster_path: seasonPosterPath,
|
||
}));
|
||
}
|
||
});
|
||
if (__DEV__) logger.log('🖼️ Successfully fetched and attached TMDB season posters to addon episodes.');
|
||
}
|
||
}
|
||
} catch (error) {
|
||
logger.error('Failed to fetch TMDB season posters for addon episodes:', error);
|
||
}
|
||
} else {
|
||
if (__DEV__) logger.log('[loadSeriesData] TMDB season poster enrichment disabled; skipping season poster fetch');
|
||
}
|
||
|
||
if (settings.enrichMetadataWithTMDB && settings.tmdbEnrichEpisodes) {
|
||
try {
|
||
const tmdbIdToUse = tmdbId || (id.startsWith('tt') ? await tmdbService.findTMDBIdByIMDB(id) : null);
|
||
if (tmdbIdToUse) {
|
||
const lang = settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en';
|
||
const seasons = Object.keys(groupedAddonEpisodes).map(Number);
|
||
|
||
// Fetch all seasons in parallel (much faster than fetching each episode individually)
|
||
const seasonPromises = seasons.map(async seasonNum => {
|
||
try {
|
||
// getSeasonDetails returns all episodes for a season in one call
|
||
const seasonData = await tmdbService.getSeasonDetails(Number(tmdbIdToUse), seasonNum, undefined, lang);
|
||
if (seasonData && seasonData.episodes) {
|
||
// Create a map of episode number -> localized data for fast lookup
|
||
const localizedMap = new Map<number, { name: string; overview: string }>();
|
||
for (const ep of seasonData.episodes) {
|
||
localizedMap.set(ep.episode_number, { name: ep.name, overview: ep.overview });
|
||
}
|
||
|
||
// Merge localized data into addon episodes
|
||
groupedAddonEpisodes[seasonNum] = groupedAddonEpisodes[seasonNum].map(ep => {
|
||
const localized = localizedMap.get(ep.episode_number);
|
||
if (localized) {
|
||
return {
|
||
...ep,
|
||
name: localized.name || ep.name,
|
||
overview: localized.overview || ep.overview,
|
||
};
|
||
}
|
||
return ep;
|
||
});
|
||
}
|
||
} catch { }
|
||
});
|
||
|
||
await Promise.all(seasonPromises);
|
||
if (__DEV__) logger.log('[useMetadata] merged episode names/overviews from TMDB (batch)');
|
||
}
|
||
} catch (e) {
|
||
if (__DEV__) console.log('[useMetadata] failed to merge episode text from TMDB', e);
|
||
}
|
||
}
|
||
|
||
setGroupedEpisodes(groupedAddonEpisodes);
|
||
|
||
// Determine initial season only once per series
|
||
const seasons = Object.keys(groupedAddonEpisodes).map(Number);
|
||
const nonZeroSeasons = seasons.filter(s => s !== 0);
|
||
const firstSeason = nonZeroSeasons.length > 0 ? Math.min(...nonZeroSeasons) : Math.min(...seasons);
|
||
if (!initializedSeasonRef.current) {
|
||
// Check for watch progress to auto-select season
|
||
let selectedSeasonNumber = firstSeason;
|
||
try {
|
||
const allProgress = await storageService.getAllWatchProgress();
|
||
let mostRecentEpisodeId = '';
|
||
let mostRecentTimestamp = 0;
|
||
Object.entries(allProgress).forEach(([key, progress]) => {
|
||
if (key.includes(`series:${id}:`)) {
|
||
const episodeId = key.split(`series:${id}:`)[1];
|
||
if (progress.lastUpdated > mostRecentTimestamp && progress.currentTime > 0) {
|
||
mostRecentTimestamp = progress.lastUpdated;
|
||
mostRecentEpisodeId = episodeId;
|
||
}
|
||
}
|
||
});
|
||
|
||
if (mostRecentEpisodeId) {
|
||
// Try to parse season from ID or find matching episode
|
||
const parts = mostRecentEpisodeId.split(':');
|
||
if (parts.length === 3) {
|
||
// Format: showId:season:episode
|
||
const watchProgressSeason = parseInt(parts[1], 10);
|
||
if (groupedAddonEpisodes[watchProgressSeason]) {
|
||
selectedSeasonNumber = watchProgressSeason;
|
||
logger.log(`[useMetadata] Auto-selected season ${selectedSeasonNumber} based on most recent watch progress for ${mostRecentEpisodeId}`);
|
||
}
|
||
} else {
|
||
// Try to find by stremioId
|
||
const allEpisodesList = Object.values(groupedAddonEpisodes).flat();
|
||
const episode = allEpisodesList.find(ep => ep.stremioId === mostRecentEpisodeId);
|
||
if (episode) {
|
||
selectedSeasonNumber = episode.season_number;
|
||
logger.log(`[useMetadata] Auto-selected season ${selectedSeasonNumber} based on most recent watch progress for episode with stremioId ${mostRecentEpisodeId}`);
|
||
}
|
||
}
|
||
} else {
|
||
// No watch progress, try persistent storage
|
||
selectedSeasonNumber = getSeason(id, firstSeason);
|
||
logger.log(`[useMetadata] No watch progress found, using persistent season ${selectedSeasonNumber}`);
|
||
}
|
||
} catch (error) {
|
||
logger.error('[useMetadata] Error checking watch progress for season selection:', error);
|
||
selectedSeasonNumber = getSeason(id, firstSeason);
|
||
}
|
||
|
||
if (selectedSeason !== selectedSeasonNumber) {
|
||
logger.log(`📺 Setting season ${selectedSeasonNumber} as selected`);
|
||
setSelectedSeason(selectedSeasonNumber);
|
||
}
|
||
setEpisodes(groupedAddonEpisodes[selectedSeasonNumber] || []);
|
||
initializedSeasonRef.current = true;
|
||
} else {
|
||
// Keep current selection; refresh episode list for selected season
|
||
setEpisodes(groupedAddonEpisodes[selectedSeason] || []);
|
||
}
|
||
|
||
// Try to get TMDB ID for additional metadata (cast, etc.) but don't override episodes
|
||
// Skip TMDB episode fallback if enrichment or episode enrichment is disabled
|
||
if (!settings.enrichMetadataWithTMDB || !settings.tmdbEnrichEpisodes) {
|
||
if (__DEV__) logger.log('[loadSeriesData] TMDB episode enrichment disabled; skipping TMDB episode fallback (preserving current episodes)');
|
||
return;
|
||
}
|
||
const tmdbIdResult = await tmdbService.findTMDBIdByIMDB(id);
|
||
if (tmdbIdResult) {
|
||
setTmdbId(tmdbIdResult);
|
||
}
|
||
|
||
return; // Use addon episodes, skip TMDB loading
|
||
}
|
||
|
||
// Fallback to TMDB if no addon episodes
|
||
logger.log('📺 No addon episodes found, falling back to TMDB');
|
||
const lang = settings.useTmdbLocalizedMetadata ? `${settings.tmdbLanguagePreference || 'en'}` : 'en';
|
||
const tmdbIdResult = await tmdbService.findTMDBIdByIMDB(id);
|
||
if (tmdbIdResult) {
|
||
setTmdbId(tmdbIdResult);
|
||
|
||
const [allEpisodes, showDetails] = await Promise.all([
|
||
tmdbService.getAllEpisodes(tmdbIdResult, lang),
|
||
tmdbService.getTVShowDetails(tmdbIdResult, lang)
|
||
]);
|
||
|
||
const transformedEpisodes: GroupedEpisodes = {};
|
||
Object.entries(allEpisodes).forEach(([seasonStr, episodes]) => {
|
||
const seasonNum = parseInt(seasonStr, 10);
|
||
if (seasonNum < 1) {
|
||
return; // Skip season 0, which often contains extras
|
||
}
|
||
|
||
const seasonInfo = showDetails?.seasons?.find(s => s.season_number === seasonNum);
|
||
const seasonPosterPath = seasonInfo?.poster_path;
|
||
|
||
transformedEpisodes[seasonNum] = episodes.map(episode => ({
|
||
...episode,
|
||
episodeString: `S${episode.season_number.toString().padStart(2, '0')}E${episode.episode_number.toString().padStart(2, '0')}`,
|
||
season_poster_path: seasonPosterPath || null
|
||
}));
|
||
});
|
||
|
||
setGroupedEpisodes(transformedEpisodes);
|
||
|
||
// Get the first available season as fallback (preferring non-zero seasons)
|
||
const availableSeasons = Object.keys(allEpisodes).map(Number);
|
||
const nonZeroSeasons = availableSeasons.filter(s => s !== 0);
|
||
const firstSeason = nonZeroSeasons.length > 0 ? Math.min(...nonZeroSeasons) : Math.min(...availableSeasons);
|
||
|
||
if (!initializedSeasonRef.current) {
|
||
// Check for watch progress to auto-select season
|
||
let selectedSeasonNumber = firstSeason;
|
||
try {
|
||
const allProgress = await storageService.getAllWatchProgress();
|
||
let mostRecentEpisodeId = '';
|
||
let mostRecentTimestamp = 0;
|
||
Object.entries(allProgress).forEach(([key, progress]) => {
|
||
if (key.includes(`series:${id}:`)) {
|
||
const episodeId = key.split(`series:${id}:`)[1];
|
||
if (progress.lastUpdated > mostRecentTimestamp && progress.currentTime > 0) {
|
||
mostRecentTimestamp = progress.lastUpdated;
|
||
mostRecentEpisodeId = episodeId;
|
||
}
|
||
}
|
||
});
|
||
if (mostRecentEpisodeId) {
|
||
const parts = mostRecentEpisodeId.split(':');
|
||
if (parts.length === 3) {
|
||
const watchProgressSeason = parseInt(parts[1], 10);
|
||
if (transformedEpisodes[watchProgressSeason]) {
|
||
selectedSeasonNumber = watchProgressSeason;
|
||
logger.log(`[useMetadata] Auto-selected season ${selectedSeasonNumber} based on most recent watch progress for ${mostRecentEpisodeId}`);
|
||
}
|
||
} else {
|
||
const allEpisodesList = Object.values(transformedEpisodes).flat();
|
||
const episode = allEpisodesList.find(ep => ep.stremioId === mostRecentEpisodeId);
|
||
if (episode) {
|
||
selectedSeasonNumber = episode.season_number;
|
||
logger.log(`[useMetadata] Auto-selected season ${selectedSeasonNumber} based on most recent watch progress for episode with stremioId ${mostRecentEpisodeId}`);
|
||
}
|
||
}
|
||
} else {
|
||
selectedSeasonNumber = getSeason(id, firstSeason);
|
||
logger.log(`[useMetadata] No watch progress found, using persistent season ${selectedSeasonNumber}`);
|
||
}
|
||
} catch (error) {
|
||
logger.error('[useMetadata] Error checking watch progress for season selection:', error);
|
||
selectedSeasonNumber = getSeason(id, firstSeason);
|
||
}
|
||
if (selectedSeason !== selectedSeasonNumber) {
|
||
setSelectedSeason(selectedSeasonNumber);
|
||
}
|
||
setEpisodes(transformedEpisodes[selectedSeasonNumber] || []);
|
||
initializedSeasonRef.current = true;
|
||
} else {
|
||
// Keep existing selection stable and only refresh episode list for it
|
||
setEpisodes(transformedEpisodes[selectedSeason] || []);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.error('Failed to load episodes:', error);
|
||
} finally {
|
||
setLoadingSeasons(false);
|
||
}
|
||
};
|
||
|
||
// Function to indicate that streams are loading without blocking UI
|
||
const updateLoadingState = () => {
|
||
// We set this to true initially, but we'll show results as they come in
|
||
setLoadingStreams(true);
|
||
// Also clear previous streams
|
||
setGroupedStreams({});
|
||
setError(null);
|
||
};
|
||
|
||
// Function to indicate that episode streams are loading without blocking UI
|
||
const updateEpisodeLoadingState = () => {
|
||
// We set this to true initially, but we'll show results as they come in
|
||
setLoadingEpisodeStreams(true);
|
||
// Also clear previous streams
|
||
setEpisodeStreams({});
|
||
setError(null);
|
||
};
|
||
|
||
// Extract embedded streams from metadata videos (used by PPV-style addons)
|
||
const extractEmbeddedStreams = useCallback((episodeIdOverride?: string) => {
|
||
if (!metadata?.videos) return;
|
||
|
||
// Check if any video has embedded streams
|
||
const videosWithStreams = (metadata.videos as any[]).filter(
|
||
(video: any) => video.streams && Array.isArray(video.streams) && video.streams.length > 0
|
||
);
|
||
|
||
if (videosWithStreams.length === 0) return;
|
||
|
||
// Get the addon info from metadata if available
|
||
const addonId = (metadata as any).addonId || 'embedded';
|
||
const addonName = (metadata as any).addonName || metadata.name || 'Embedded Streams';
|
||
|
||
// 1. Extract all streams for groupedStreams (legacy/movies behavior, or flat list)
|
||
const allEmbeddedStreams: Stream[] = [];
|
||
for (const video of videosWithStreams) {
|
||
for (const stream of video.streams) {
|
||
allEmbeddedStreams.push({
|
||
...stream,
|
||
name: stream.name || stream.title || video.title,
|
||
title: stream.title || video.title,
|
||
addonId,
|
||
addonName,
|
||
});
|
||
}
|
||
}
|
||
|
||
if (allEmbeddedStreams.length > 0) {
|
||
if (__DEV__) console.log(`✅ [extractEmbeddedStreams] Found ${allEmbeddedStreams.length} embedded streams from ${addonName}`);
|
||
|
||
// Add to grouped streams
|
||
setGroupedStreams(prevStreams => ({
|
||
...prevStreams,
|
||
[addonId]: {
|
||
addonName,
|
||
streams: allEmbeddedStreams,
|
||
},
|
||
}));
|
||
|
||
// Track addon response order
|
||
setAddonResponseOrder(prevOrder => {
|
||
if (!prevOrder.includes(addonId)) {
|
||
return [...prevOrder, addonId];
|
||
}
|
||
return prevOrder;
|
||
});
|
||
|
||
// If we are not waiting for episode streams, we can stop loading
|
||
if (!loadingEpisodeStreams) {
|
||
setLoadingStreams(false);
|
||
}
|
||
}
|
||
|
||
// 2. Extract streams specifically for the selected episode
|
||
const episodeToUse = episodeIdOverride || selectedEpisode;
|
||
if (episodeToUse) {
|
||
const episodeVideo = videosWithStreams.find(
|
||
v => v.id === episodeToUse ||
|
||
v.id === episodeToUse.split(':').pop() || // Handle cases where ID might have prefix
|
||
(v.season === 0 && v.episode === 1 && videosWithStreams.length === 1) // Single item PPV edge case
|
||
);
|
||
|
||
if (episodeVideo && episodeVideo.streams && episodeVideo.streams.length > 0) {
|
||
if (__DEV__) console.log(`✅ [extractEmbeddedStreams] Found embedded streams for episode ${episodeToUse}`);
|
||
|
||
const episodeStreamsList: Stream[] = episodeVideo.streams.map((stream: any) => ({
|
||
...stream,
|
||
name: stream.name || stream.title || episodeVideo.title,
|
||
title: stream.title || episodeVideo.title,
|
||
addonId,
|
||
addonName,
|
||
}));
|
||
|
||
setEpisodeStreams(prevStreams => ({
|
||
...prevStreams,
|
||
[addonId]: {
|
||
addonName,
|
||
streams: episodeStreamsList,
|
||
},
|
||
}));
|
||
|
||
setLoadingEpisodeStreams(false);
|
||
}
|
||
}
|
||
}, [metadata, selectedEpisode, loadingEpisodeStreams]);
|
||
|
||
const loadStreams = async () => {
|
||
const startTime = Date.now();
|
||
try {
|
||
if (__DEV__) console.log('🚀 [loadStreams] START - Loading streams for:', id);
|
||
updateLoadingState();
|
||
|
||
// Reset scraper tracking
|
||
setScraperStatuses([]);
|
||
setActiveFetchingScrapers([]);
|
||
setAddonResponseOrder([]); // Reset response order
|
||
|
||
if (__DEV__) console.log('🔍 [loadStreams] Getting TMDB ID for:', id);
|
||
let tmdbId;
|
||
let stremioId = id;
|
||
let effectiveStreamType: string = type;
|
||
|
||
if (id.startsWith('tmdb:')) {
|
||
tmdbId = id.split(':')[1];
|
||
if (__DEV__) console.log('✅ [loadStreams] Using TMDB ID from ID:', tmdbId);
|
||
|
||
// Try to get IMDb ID from metadata first, then convert if needed
|
||
if (metadata?.imdb_id) {
|
||
stremioId = metadata.imdb_id;
|
||
if (__DEV__) console.log('✅ [loadStreams] Using IMDb ID from metadata for Stremio:', stremioId);
|
||
} else if (imdbId) {
|
||
stremioId = imdbId;
|
||
if (__DEV__) console.log('✅ [loadStreams] Using stored IMDb ID for Stremio:', stremioId);
|
||
} else {
|
||
// Convert TMDB ID to IMDb ID for Stremio addons (they expect IMDb format)
|
||
try {
|
||
let externalIds = null;
|
||
if (type === 'movie') {
|
||
const movieDetails = await withTimeout(tmdbService.getMovieDetails(tmdbId), API_TIMEOUT);
|
||
externalIds = movieDetails?.external_ids;
|
||
} else if (type === 'series') {
|
||
externalIds = await withTimeout(tmdbService.getShowExternalIds(parseInt(tmdbId)), API_TIMEOUT);
|
||
}
|
||
|
||
if (externalIds?.imdb_id) {
|
||
stremioId = externalIds.imdb_id;
|
||
if (__DEV__) console.log('✅ [loadStreams] Converted TMDB to IMDb ID for Stremio:', stremioId);
|
||
} else {
|
||
if (__DEV__) console.log('⚠️ [loadStreams] No IMDb ID found for TMDB ID, using original:', stremioId);
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.log('⚠️ [loadStreams] Failed to convert TMDB to IMDb, using original ID:', error);
|
||
}
|
||
}
|
||
} else if (id.startsWith('tt')) {
|
||
// This is already an IMDB ID, perfect for Stremio
|
||
stremioId = id;
|
||
if (settings.enrichMetadataWithTMDB) {
|
||
if (__DEV__) console.log('📝 [loadStreams] Converting IMDB ID to TMDB ID...');
|
||
tmdbId = await withTimeout(tmdbService.findTMDBIdByIMDB(id), API_TIMEOUT);
|
||
if (__DEV__) console.log('✅ [loadStreams] Converted to TMDB ID:', tmdbId);
|
||
} else {
|
||
if (__DEV__) console.log('📝 [loadStreams] TMDB enrichment disabled, skipping IMDB to TMDB conversion');
|
||
}
|
||
} else {
|
||
tmdbId = id;
|
||
stremioId = id;
|
||
if (__DEV__) console.log('ℹ️ [loadStreams] Using ID as both TMDB and Stremio ID:', tmdbId);
|
||
}
|
||
|
||
// Initialize scraper tracking
|
||
try {
|
||
const allStremioAddons = await stremioService.getInstalledAddons();
|
||
const localScrapers = await localScraperService.getInstalledScrapers();
|
||
|
||
const requestedStreamType = type;
|
||
|
||
const pickEligibleStreamAddons = (requestType: string) =>
|
||
allStremioAddons.filter(addon => {
|
||
if (!addon.resources || !Array.isArray(addon.resources)) {
|
||
return false;
|
||
}
|
||
|
||
let hasStreamResource = false;
|
||
let supportsIdPrefix = false;
|
||
|
||
for (const resource of addon.resources) {
|
||
if (typeof resource === 'object' && resource !== null && 'name' in resource) {
|
||
const typedResource = resource as any;
|
||
if (typedResource.name === 'stream' &&
|
||
Array.isArray(typedResource.types) &&
|
||
typedResource.types.includes(requestType)) {
|
||
hasStreamResource = true;
|
||
|
||
if (Array.isArray(typedResource.idPrefixes) && typedResource.idPrefixes.length > 0) {
|
||
supportsIdPrefix = typedResource.idPrefixes.some((p: string) => stremioId.startsWith(p));
|
||
} else {
|
||
supportsIdPrefix = true;
|
||
}
|
||
break;
|
||
}
|
||
} else if (typeof resource === 'string' && resource === 'stream' && addon.types) {
|
||
if (Array.isArray(addon.types) && addon.types.includes(requestType)) {
|
||
hasStreamResource = true;
|
||
if (addon.idPrefixes && Array.isArray(addon.idPrefixes) && addon.idPrefixes.length > 0) {
|
||
supportsIdPrefix = addon.idPrefixes.some((p: string) => stremioId.startsWith(p));
|
||
} else {
|
||
supportsIdPrefix = true;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return hasStreamResource && supportsIdPrefix;
|
||
});
|
||
|
||
effectiveStreamType = requestedStreamType;
|
||
let eligibleStreamAddons = pickEligibleStreamAddons(requestedStreamType);
|
||
|
||
if (eligibleStreamAddons.length === 0) {
|
||
const fallbackTypes = ['series', 'movie'].filter(t => t !== requestedStreamType);
|
||
for (const fallbackType of fallbackTypes) {
|
||
const fallback = pickEligibleStreamAddons(fallbackType);
|
||
if (fallback.length > 0) {
|
||
effectiveStreamType = fallbackType;
|
||
eligibleStreamAddons = fallback;
|
||
if (__DEV__) console.log(`[useMetadata.loadStreams] No addons for '${requestedStreamType}', falling back to '${fallbackType}'`);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
const streamAddons = eligibleStreamAddons;
|
||
if (__DEV__) console.log('[useMetadata.loadStreams] Eligible stream addons:', streamAddons.map(a => a.id), { requestedStreamType, effectiveStreamType });
|
||
|
||
// Initialize scraper statuses for tracking
|
||
const initialStatuses: ScraperStatus[] = [];
|
||
const initialActiveFetching: string[] = [];
|
||
|
||
// Add stream-capable Stremio addons only
|
||
streamAddons.forEach(addon => {
|
||
initialStatuses.push({
|
||
id: addon.id,
|
||
name: addon.name,
|
||
isLoading: true,
|
||
hasCompleted: false,
|
||
error: null,
|
||
startTime: Date.now(),
|
||
endTime: null
|
||
});
|
||
initialActiveFetching.push(addon.name);
|
||
});
|
||
|
||
// Add local scrapers if enabled
|
||
const currentSettings = await mmkvStorage.getItem('app_settings');
|
||
const enableLocalScrapersNow = currentSettings ? JSON.parse(currentSettings).enableLocalScrapers !== false : true;
|
||
|
||
if (enableLocalScrapersNow) {
|
||
localScrapers.filter((scraper: ScraperInfo) => scraper.enabled).forEach((scraper: ScraperInfo) => {
|
||
initialStatuses.push({
|
||
id: scraper.id,
|
||
name: scraper.name,
|
||
isLoading: true,
|
||
hasCompleted: false,
|
||
error: null,
|
||
startTime: Date.now(),
|
||
endTime: null
|
||
});
|
||
initialActiveFetching.push(scraper.name);
|
||
});
|
||
}
|
||
|
||
setScraperStatuses(initialStatuses);
|
||
setActiveFetchingScrapers(initialActiveFetching);
|
||
|
||
// If no scrapers are available, stop loading immediately
|
||
if (initialStatuses.length === 0) {
|
||
setLoadingStreams(false);
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.error('Failed to initialize scraper tracking:', error);
|
||
}
|
||
|
||
// Start Stremio request using the converted ID format
|
||
if (__DEV__) console.log('🎬 [loadStreams] Using ID for Stremio addons:', stremioId);
|
||
// Use the effective type we selected when building the eligible addon list.
|
||
// This stays aligned with Stremio manifest filtering rules and avoids hard-mapping non-standard types.
|
||
processStremioSource(effectiveStreamType, stremioId, false);
|
||
|
||
// Also extract any embedded streams from metadata (PPV-style addons)
|
||
extractEmbeddedStreams();
|
||
|
||
// Monitor scraper completion status instead of using fixed timeout
|
||
const checkScrapersCompletion = () => {
|
||
setScraperStatuses(currentStatuses => {
|
||
const allCompleted = currentStatuses.every(status => status.hasCompleted || status.error !== null);
|
||
if (allCompleted && currentStatuses.length > 0) {
|
||
setLoadingStreams(false);
|
||
setActiveFetchingScrapers([]);
|
||
}
|
||
return currentStatuses;
|
||
});
|
||
};
|
||
|
||
// Check completion less frequently to reduce CPU load
|
||
const completionInterval = setInterval(checkScrapersCompletion, 2000);
|
||
|
||
// Fallback timeout after 1 minute
|
||
const fallbackTimeout = setTimeout(() => {
|
||
clearInterval(completionInterval);
|
||
setLoadingStreams(false);
|
||
setActiveFetchingScrapers([]);
|
||
// Mark all incomplete scrapers as failed
|
||
setScraperStatuses(prevStatuses =>
|
||
prevStatuses.map(status =>
|
||
!status.hasCompleted && !status.error
|
||
? { ...status, isLoading: false, hasCompleted: true, error: 'Request timed out', endTime: Date.now() }
|
||
: status
|
||
)
|
||
);
|
||
}, 60000);
|
||
|
||
} catch (error) {
|
||
if (__DEV__) console.error('❌ [loadStreams] Failed to load streams:', error);
|
||
// Preserve the original error details for better error parsing
|
||
const errorMessage = error instanceof Error ? error.message : 'Failed to load streams';
|
||
setError(errorMessage);
|
||
setLoadingStreams(false);
|
||
}
|
||
};
|
||
|
||
const loadEpisodeStreams = async (episodeId: string) => {
|
||
const startTime = Date.now();
|
||
try {
|
||
if (__DEV__) console.log('🚀 [loadEpisodeStreams] START - Loading episode streams for:', episodeId);
|
||
updateEpisodeLoadingState();
|
||
|
||
// Reset scraper tracking for episodes
|
||
setScraperStatuses([]);
|
||
setActiveFetchingScrapers([]);
|
||
setAddonResponseOrder([]); // Reset response order
|
||
|
||
// Initialize scraper tracking for episodes
|
||
try {
|
||
const allStremioAddons = await stremioService.getInstalledAddons();
|
||
const localScrapers = await localScraperService.getInstalledScrapers();
|
||
|
||
// We don't yet know the final episode ID format here (it can be normalized later),
|
||
// but we can still pre-filter by stream capability for the most likely types.
|
||
const pickStreamCapableAddons = (requestType: string) =>
|
||
allStremioAddons.filter(addon => {
|
||
if (!addon.resources || !Array.isArray(addon.resources)) return false;
|
||
|
||
for (const resource of addon.resources) {
|
||
if (typeof resource === 'object' && resource !== null && 'name' in resource) {
|
||
const typedResource = resource as any;
|
||
if (typedResource.name === 'stream' && Array.isArray(typedResource.types) && typedResource.types.includes(requestType)) {
|
||
return true;
|
||
}
|
||
} else if (typeof resource === 'string' && resource === 'stream' && addon.types) {
|
||
if (Array.isArray(addon.types) && addon.types.includes(requestType)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
});
|
||
|
||
const requestedEpisodeType = type;
|
||
let streamAddons = pickStreamCapableAddons(requestedEpisodeType);
|
||
|
||
if (streamAddons.length === 0) {
|
||
const fallbackTypes = ['series', 'movie'].filter(t => t !== requestedEpisodeType);
|
||
for (const fallbackType of fallbackTypes) {
|
||
const fallback = pickStreamCapableAddons(fallbackType);
|
||
if (fallback.length > 0) {
|
||
streamAddons = fallback;
|
||
if (__DEV__) console.log(`[useMetadata.loadEpisodeStreams] No addons for '${requestedEpisodeType}', falling back to '${fallbackType}'`);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Initialize scraper statuses for tracking
|
||
const initialStatuses: ScraperStatus[] = [];
|
||
const initialActiveFetching: string[] = [];
|
||
|
||
// Add stream-capable Stremio addons only
|
||
streamAddons.forEach(addon => {
|
||
initialStatuses.push({
|
||
id: addon.id,
|
||
name: addon.name,
|
||
isLoading: true,
|
||
hasCompleted: false,
|
||
error: null,
|
||
startTime: Date.now(),
|
||
endTime: null
|
||
});
|
||
initialActiveFetching.push(addon.name);
|
||
});
|
||
|
||
// Add local scrapers if enabled (read from storage to avoid stale closure)
|
||
const currentSettings = await mmkvStorage.getItem('app_settings');
|
||
const enableLocalScrapersNow = currentSettings ? JSON.parse(currentSettings).enableLocalScrapers !== false : true;
|
||
|
||
if (enableLocalScrapersNow) {
|
||
localScrapers.filter((scraper: ScraperInfo) => scraper.enabled).forEach((scraper: ScraperInfo) => {
|
||
initialStatuses.push({
|
||
id: scraper.id,
|
||
name: scraper.name,
|
||
isLoading: true,
|
||
hasCompleted: false,
|
||
error: null,
|
||
startTime: Date.now(),
|
||
endTime: null
|
||
});
|
||
initialActiveFetching.push(scraper.name);
|
||
});
|
||
}
|
||
|
||
setScraperStatuses(initialStatuses);
|
||
setActiveFetchingScrapers(initialActiveFetching);
|
||
|
||
// If no scrapers are available, stop loading immediately
|
||
if (initialStatuses.length === 0) {
|
||
setLoadingEpisodeStreams(false);
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.error('Failed to initialize episode scraper tracking:', error);
|
||
}
|
||
|
||
// Get TMDB ID for external sources and determine the correct ID for Stremio addons
|
||
if (__DEV__) console.log('🔍 [loadEpisodeStreams] Getting TMDB ID for:', id);
|
||
let tmdbId;
|
||
let stremioEpisodeId = episodeId; // Default to original episode ID
|
||
let isCollection = false;
|
||
|
||
// Dynamically detect if this is a collection by checking addon capabilities
|
||
const { isCollection: detectedCollection, addon: collectionAddon } = stremioService.isCollectionContent(id);
|
||
isCollection = detectedCollection;
|
||
|
||
|
||
// Parse season and episode numbers robustly
|
||
let showIdStr = id;
|
||
let seasonNum = '';
|
||
let episodeNum = '';
|
||
|
||
try {
|
||
// Handle various episode ID formats
|
||
// 1. Internal format: "series:showId:season:episode"
|
||
// 2. Stremio/IMDb format: "tt12345:1:1"
|
||
// 3. TMDB format: "tmdb:123:1:1"
|
||
|
||
const cleanEpisodeId = episodeId.replace(/^series:/, '');
|
||
const parts = cleanEpisodeId.split(':');
|
||
|
||
if (parts.length >= 3) {
|
||
episodeNum = parts.pop() || '';
|
||
seasonNum = parts.pop() || '';
|
||
showIdStr = parts.join(':');
|
||
} else if (parts.length === 2) {
|
||
// For IDs like mal:57658:1, this is showId:episode (no season)
|
||
showIdStr = parts[0];
|
||
episodeNum = parts[1];
|
||
seasonNum = ''; // No season for this format
|
||
}
|
||
|
||
if (__DEV__) console.log(`🔍 [loadEpisodeStreams] Parsed ID: show=${showIdStr}, s=${seasonNum}, e=${episodeNum}`);
|
||
} catch (e) {
|
||
if (__DEV__) console.warn('⚠️ [loadEpisodeStreams] Failed to parse episode ID:', episodeId);
|
||
}
|
||
|
||
if (isCollection && collectionAddon) {
|
||
if (__DEV__) console.log(`🎬 [loadEpisodeStreams] Detected collection from addon: ${collectionAddon.name}, treating episodes as individual movies`);
|
||
|
||
// For collections, extract the individual movie ID from the episodeId
|
||
// episodeId format for collections: "tt7888964" (IMDb ID of individual movie)
|
||
if (episodeId.startsWith('tt')) {
|
||
// This is an IMDb ID of an individual movie in the collection
|
||
if (settings.enrichMetadataWithTMDB) {
|
||
tmdbId = await withTimeout(tmdbService.findTMDBIdByIMDB(episodeId), API_TIMEOUT);
|
||
}
|
||
stremioEpisodeId = episodeId; // Use the IMDb ID directly for Stremio addons
|
||
if (__DEV__) console.log('✅ [loadEpisodeStreams] Collection movie - using IMDb ID:', episodeId, 'TMDB ID:', tmdbId);
|
||
} else {
|
||
// Fallback: try to verify if it's a tmdb id
|
||
const isTmdb = episodeId.startsWith('tmdb:') || !isNaN(Number(episodeId));
|
||
if (isTmdb) {
|
||
const cleanId = episodeId.replace('tmdb:', '');
|
||
tmdbId = cleanId;
|
||
stremioEpisodeId = episodeId;
|
||
} else {
|
||
stremioEpisodeId = episodeId;
|
||
}
|
||
if (__DEV__) console.log('⚠️ [loadEpisodeStreams] Collection movie - using episodeId as-is:', episodeId);
|
||
}
|
||
} else if (id.startsWith('tmdb:')) {
|
||
tmdbId = id.split(':')[1];
|
||
if (__DEV__) console.log('✅ [loadEpisodeStreams] Using TMDB ID from ID:', tmdbId);
|
||
|
||
// Try to get IMDb ID from metadata first, then convert if needed
|
||
if (metadata?.imdb_id) {
|
||
// Use format: imdb_id:season:episode
|
||
stremioEpisodeId = `${metadata.imdb_id}:${seasonNum}:${episodeNum}`;
|
||
if (__DEV__) console.log('✅ [loadEpisodeStreams] Using IMDb ID from metadata for Stremio episode:', stremioEpisodeId);
|
||
} else if (imdbId) {
|
||
stremioEpisodeId = `${imdbId}:${seasonNum}:${episodeNum}`;
|
||
if (__DEV__) console.log('✅ [loadEpisodeStreams] Using stored IMDb ID for Stremio episode:', stremioEpisodeId);
|
||
} else {
|
||
// Convert TMDB ID to IMDb ID for Stremio addons
|
||
try {
|
||
const externalIds = await withTimeout(tmdbService.getShowExternalIds(parseInt(tmdbId)), API_TIMEOUT);
|
||
|
||
if (externalIds?.imdb_id) {
|
||
stremioEpisodeId = `${externalIds.imdb_id}:${seasonNum}:${episodeNum}`;
|
||
if (__DEV__) console.log('✅ [loadEpisodeStreams] Converted TMDB to IMDb ID for Stremio episode:', stremioEpisodeId);
|
||
} else {
|
||
// Fallback to TMDB format if conversions fail
|
||
// e.g. tmdb:123:1:1
|
||
stremioEpisodeId = `${id}:${seasonNum}:${episodeNum}`;
|
||
if (__DEV__) console.log('⚠️ [loadEpisodeStreams] No IMDb ID found for TMDB ID, using TMDB episode ID:', stremioEpisodeId);
|
||
}
|
||
} catch (error) {
|
||
stremioEpisodeId = `${id}:${seasonNum}:${episodeNum}`;
|
||
if (__DEV__) console.log('⚠️ [loadEpisodeStreams] Failed to convert TMDB to IMDb, using TMDB episode ID:', error);
|
||
}
|
||
}
|
||
} else if (id.startsWith('tt')) {
|
||
// This is already an IMDB ID, perfect for Stremio
|
||
if (settings.enrichMetadataWithTMDB) {
|
||
if (__DEV__) console.log('📝 [loadEpisodeStreams] Converting IMDB ID to TMDB ID...');
|
||
tmdbId = await withTimeout(tmdbService.findTMDBIdByIMDB(id), API_TIMEOUT);
|
||
} else {
|
||
if (__DEV__) console.log('📝 [loadEpisodeStreams] TMDB enrichment disabled, skipping IMDB to TMDB conversion');
|
||
}
|
||
if (__DEV__) console.log('✅ [loadEpisodeStreams] Converted to TMDB ID:', tmdbId);
|
||
|
||
// Ensure consistent format
|
||
// Ensure consistent format or fallback to episodeId if parsing failed
|
||
// This handles cases where 'tt' is used for a unique episode ID directly
|
||
if (!seasonNum && !episodeNum) {
|
||
stremioEpisodeId = episodeId;
|
||
} else if (!seasonNum) {
|
||
// No season (e.g., mal:57658:1) - use id:episode format
|
||
stremioEpisodeId = `${id}:${episodeNum}`;
|
||
} else {
|
||
stremioEpisodeId = `${id}:${seasonNum}:${episodeNum}`;
|
||
}
|
||
if (__DEV__) console.log('🔧 [loadEpisodeStreams] Normalized episode ID for addons:', stremioEpisodeId);
|
||
} else {
|
||
tmdbId = id;
|
||
// If season/episode parsing failed (empty strings), use the raw episode ID
|
||
// This handles custom IDs like "ppv-event-name" that don't follow "id:s:e" format
|
||
if (!seasonNum && !episodeNum) {
|
||
// Remove 'series:' prefix if present to be safe, though parsing logic above usually handles it
|
||
stremioEpisodeId = episodeId.replace(/^series:/, '');
|
||
} else if (!seasonNum) {
|
||
// No season (e.g., mal:57658:1) - use id:episode format
|
||
stremioEpisodeId = `${id}:${episodeNum}`;
|
||
} else {
|
||
stremioEpisodeId = `${id}:${seasonNum}:${episodeNum}`;
|
||
}
|
||
if (__DEV__) console.log('ℹ️ [loadEpisodeStreams] Using ID as both TMDB and Stremio ID:', tmdbId);
|
||
}
|
||
|
||
// Extract episode info from the episodeId for logging
|
||
const episodeQuery = `?s=${seasonNum}&e=${episodeNum}`;
|
||
if (__DEV__) console.log(`ℹ️ [loadEpisodeStreams] Episode query: ${episodeQuery}`);
|
||
|
||
if (__DEV__) console.log('🔄 [loadEpisodeStreams] Starting stream requests');
|
||
|
||
// Start Stremio request using the converted episode ID format
|
||
if (__DEV__) console.log('🎬 [loadEpisodeStreams] Using episode ID for Stremio addons:', stremioEpisodeId);
|
||
|
||
const requestedContentType = isCollection ? 'movie' : type;
|
||
const contentType = requestedContentType;
|
||
if (__DEV__) console.log(`🎬 [loadEpisodeStreams] Using content type: ${contentType} for ${isCollection ? 'collection' : type}`);
|
||
|
||
processStremioSource(contentType, stremioEpisodeId, true);
|
||
|
||
// Also extract any embedded streams from metadata for this episode
|
||
// Also extract any embedded streams from metadata for this episode
|
||
extractEmbeddedStreams(episodeId);
|
||
|
||
// Monitor scraper completion status instead of using fixed timeout
|
||
const checkEpisodeScrapersCompletion = () => {
|
||
setScraperStatuses(currentStatuses => {
|
||
const allCompleted = currentStatuses.every(status => status.hasCompleted || status.error !== null);
|
||
if (allCompleted && currentStatuses.length > 0) {
|
||
setLoadingEpisodeStreams(false);
|
||
setActiveFetchingScrapers([]);
|
||
}
|
||
return currentStatuses;
|
||
});
|
||
};
|
||
|
||
// Check completion less frequently to reduce CPU load
|
||
const episodeCompletionInterval = setInterval(checkEpisodeScrapersCompletion, 3000);
|
||
|
||
// Fallback timeout after 1 minute
|
||
const episodeFallbackTimeout = setTimeout(() => {
|
||
clearInterval(episodeCompletionInterval);
|
||
setLoadingEpisodeStreams(false);
|
||
setActiveFetchingScrapers([]);
|
||
// Mark all incomplete scrapers as failed
|
||
setScraperStatuses(prevStatuses =>
|
||
prevStatuses.map(status =>
|
||
!status.hasCompleted && !status.error
|
||
? { ...status, isLoading: false, hasCompleted: true, error: 'Request timed out', endTime: Date.now() }
|
||
: status
|
||
)
|
||
);
|
||
}, 60000);
|
||
|
||
} catch (error) {
|
||
if (__DEV__) console.error('❌ [loadEpisodeStreams] Failed to load episode streams:', error);
|
||
// Preserve the original error details for better error parsing
|
||
const errorMessage = error instanceof Error ? error.message : 'Failed to load episode streams';
|
||
setError(errorMessage);
|
||
setLoadingEpisodeStreams(false);
|
||
}
|
||
};
|
||
|
||
const handleSeasonChange = useCallback((seasonNumber: number) => {
|
||
if (selectedSeason === seasonNumber) return;
|
||
|
||
// Update local state
|
||
setSelectedSeason(seasonNumber);
|
||
setEpisodes(groupedEpisodes[seasonNumber] || []);
|
||
|
||
// Persist the selection
|
||
saveSeason(id, seasonNumber);
|
||
}, [selectedSeason, groupedEpisodes, saveSeason, id]);
|
||
|
||
const toggleLibrary = useCallback(() => {
|
||
if (!metadata) return;
|
||
|
||
if (inLibrary) {
|
||
catalogService.removeFromLibrary(type, id);
|
||
} else {
|
||
catalogService.addToLibrary(metadata);
|
||
}
|
||
|
||
setInLibrary(!inLibrary);
|
||
}, [metadata, inLibrary, type, id]);
|
||
|
||
// Reset load attempts when id or type changes
|
||
useEffect(() => {
|
||
setLoadAttempts(0);
|
||
initializedSeasonRef.current = false;
|
||
|
||
// Memory optimization: Clean up streams when content changes
|
||
cleanupStreams();
|
||
|
||
// Clear any pending cleanup timeouts
|
||
if (cleanupTimeoutRef.current) {
|
||
clearTimeout(cleanupTimeoutRef.current);
|
||
cleanupTimeoutRef.current = null;
|
||
}
|
||
}, [id, type, cleanupStreams]);
|
||
|
||
// Auto-retry on error with delay
|
||
useEffect(() => {
|
||
if (error && loadAttempts < MAX_RETRIES) {
|
||
const timer = setTimeout(() => {
|
||
loadMetadata();
|
||
}, RETRY_DELAY * (loadAttempts + 1));
|
||
|
||
return () => clearTimeout(timer);
|
||
}
|
||
}, [error, loadAttempts]);
|
||
|
||
useEffect(() => {
|
||
if (!settingsLoaded) return;
|
||
|
||
// Check for cached streams immediately on mount
|
||
const checkAndLoadCachedStreams = async () => {
|
||
try {
|
||
// This will be handled by the StreamsScreen component
|
||
// The useMetadata hook focuses on metadata and episodes
|
||
} catch (error) {
|
||
if (__DEV__) console.log('[useMetadata] Error checking cached streams on mount:', error);
|
||
}
|
||
};
|
||
|
||
loadMetadata();
|
||
}, [id, type, settingsLoaded]);
|
||
|
||
// Re-fetch when localization settings change to guarantee selected language at open
|
||
useEffect(() => {
|
||
if (!settingsLoaded) return;
|
||
if (settings.enrichMetadataWithTMDB && settings.useTmdbLocalizedMetadata) {
|
||
loadMetadata();
|
||
}
|
||
}, [settingsLoaded, settings.enrichMetadataWithTMDB, settings.useTmdbLocalizedMetadata, settings.tmdbLanguagePreference]);
|
||
|
||
// Re-run series data loading when metadata updates with videos
|
||
useEffect(() => {
|
||
if (metadata && metadata.videos && metadata.videos.length > 0) {
|
||
logger.log(`🎬 Metadata updated with ${metadata.videos.length} episodes, reloading series data`);
|
||
loadSeriesData().catch((error) => { if (__DEV__) console.error(error); });
|
||
// Also extract embedded streams from metadata videos (PPV-style addons)
|
||
extractEmbeddedStreams();
|
||
}
|
||
}, [metadata?.videos, type, extractEmbeddedStreams]);
|
||
|
||
const loadRecommendations = useCallback(async () => {
|
||
if (!settings.enrichMetadataWithTMDB) {
|
||
if (__DEV__) console.log('[useMetadata] enrichment disabled; skip recommendations');
|
||
return;
|
||
}
|
||
if (!tmdbId) return;
|
||
|
||
setLoadingRecommendations(true);
|
||
try {
|
||
const tmdbService = TMDBService.getInstance();
|
||
const lang = settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en';
|
||
const results = await tmdbService.getRecommendations(type === 'movie' ? 'movie' : 'tv', String(tmdbId), lang);
|
||
|
||
// Convert TMDB results to StreamingContent format (simplified)
|
||
const formattedRecommendations: StreamingContent[] = results.map((item: any) => ({
|
||
id: `tmdb:${item.id}`,
|
||
type: type === 'movie' ? 'movie' : 'series',
|
||
name: item.title || item.name || 'Untitled',
|
||
poster: tmdbService.getImageUrl(item.poster_path) || 'https://via.placeholder.com/300x450', // Provide fallback
|
||
year: (item.release_date || item.first_air_date)?.substring(0, 4) || 'N/A', // Ensure string and provide fallback
|
||
}));
|
||
|
||
setRecommendations(formattedRecommendations);
|
||
} catch (error) {
|
||
if (__DEV__) console.error('Failed to load recommendations:', error);
|
||
setRecommendations([]);
|
||
} finally {
|
||
setLoadingRecommendations(false);
|
||
}
|
||
}, [tmdbId, type, settings.useTmdbLocalizedMetadata, settings.tmdbLanguagePreference]);
|
||
|
||
// Fetch TMDB ID if needed and then recommendations
|
||
useEffect(() => {
|
||
const fetchTmdbIdAndRecommendations = async () => {
|
||
if (!settings.enrichMetadataWithTMDB) {
|
||
if (__DEV__) console.log('[useMetadata] enrichment disabled; skip TMDB id extraction (extract path)');
|
||
return;
|
||
}
|
||
if (metadata && !tmdbId) {
|
||
try {
|
||
const tmdbService = TMDBService.getInstance();
|
||
const fetchedTmdbId = await tmdbService.extractTMDBIdFromStremioId(id);
|
||
if (fetchedTmdbId) {
|
||
if (__DEV__) console.log('[useMetadata] extracted TMDB id from content id', { id, fetchedTmdbId });
|
||
setTmdbId(fetchedTmdbId);
|
||
// Fetch certification only if granular setting is enabled
|
||
if (settings.tmdbEnrichCertification) {
|
||
const certification = await tmdbService.getCertification(type, fetchedTmdbId);
|
||
if (certification) {
|
||
if (__DEV__) console.log('[useMetadata] fetched certification via TMDB id (extract path)', { type, fetchedTmdbId, certification });
|
||
setMetadata(prev => prev ? {
|
||
...prev,
|
||
tmdbId: fetchedTmdbId,
|
||
certification
|
||
} : null);
|
||
} else {
|
||
if (__DEV__) console.warn('[useMetadata] certification not returned from TMDB (extract path)', { type, fetchedTmdbId });
|
||
}
|
||
} else {
|
||
// Just set the TMDB ID without certification
|
||
setMetadata(prev => prev ? { ...prev, tmdbId: fetchedTmdbId } : null);
|
||
}
|
||
} else {
|
||
if (__DEV__) console.warn('[useMetadata] Could not determine TMDB ID for recommendations / certification', { id });
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.error('[useMetadata] Error fetching TMDB ID (extract path):', error);
|
||
}
|
||
}
|
||
};
|
||
|
||
fetchTmdbIdAndRecommendations();
|
||
}, [metadata, id, settings.enrichMetadataWithTMDB]);
|
||
|
||
useEffect(() => {
|
||
if (tmdbId) {
|
||
// Check both master switch AND granular recommendations setting
|
||
if (settings.enrichMetadataWithTMDB && settings.tmdbEnrichRecommendations) {
|
||
if (__DEV__) console.log('[useMetadata] tmdbId available; loading recommendations', { tmdbId });
|
||
loadRecommendations();
|
||
}
|
||
// Reset recommendations when tmdbId changes
|
||
return () => {
|
||
setRecommendations([]);
|
||
setLoadingRecommendations(true);
|
||
};
|
||
}
|
||
}, [tmdbId, loadRecommendations, settings.enrichMetadataWithTMDB, settings.tmdbEnrichRecommendations]);
|
||
|
||
// Load addon cast data when metadata is available and TMDB cast enrichment is disabled
|
||
useEffect(() => {
|
||
// Load addon cast if master switch is off OR if cast enrichment specifically is off
|
||
if ((!settings.enrichMetadataWithTMDB || !settings.tmdbEnrichCast) && metadata?.addonCast && metadata.addonCast.length > 0) {
|
||
if (__DEV__) logger.log('[useMetadata] Loading addon cast data after metadata loaded');
|
||
loadCast();
|
||
}
|
||
}, [metadata, settings.enrichMetadataWithTMDB, settings.tmdbEnrichCast]);
|
||
|
||
// Ensure certification is attached whenever a TMDB id is known and metadata lacks it
|
||
useEffect(() => {
|
||
const maybeAttachCertification = async () => {
|
||
// Check both master switch AND granular certification setting
|
||
if (!settings.enrichMetadataWithTMDB || !settings.tmdbEnrichCertification) {
|
||
if (__DEV__) console.log('[useMetadata] certification enrichment disabled; skip (attach path)');
|
||
return;
|
||
}
|
||
try {
|
||
if (!metadata) {
|
||
if (__DEV__) console.warn('[useMetadata] skip certification attach: metadata not ready');
|
||
return;
|
||
}
|
||
if (!tmdbId) {
|
||
if (__DEV__) console.warn('[useMetadata] skip certification attach: tmdbId not available yet');
|
||
return;
|
||
}
|
||
if ((metadata as any).certification) {
|
||
if (__DEV__) console.log('[useMetadata] certification already present on metadata; skipping fetch');
|
||
return;
|
||
}
|
||
const tmdbSvc = TMDBService.getInstance();
|
||
const cert = await tmdbSvc.getCertification(type, tmdbId);
|
||
if (cert) {
|
||
if (__DEV__) console.log('[useMetadata] fetched certification (attach path)', { type, tmdbId, cert });
|
||
setMetadata(prev => prev ? { ...prev, tmdbId, certification: cert } : prev);
|
||
} else {
|
||
if (__DEV__) console.warn('[useMetadata] TMDB returned no certification (attach path)', { type, tmdbId });
|
||
}
|
||
} catch (err) {
|
||
if (__DEV__) console.error('[useMetadata] error attaching certification', err);
|
||
}
|
||
};
|
||
maybeAttachCertification();
|
||
}, [tmdbId, metadata, type, settings.enrichMetadataWithTMDB, settings.tmdbEnrichCertification]);
|
||
|
||
// Fetch TMDB networks/production companies when TMDB ID is available and enrichment is enabled
|
||
const productionInfoFetchedRef = useRef<string | null>(null);
|
||
useEffect(() => {
|
||
// Check if any of the relevant granular settings are enabled
|
||
const anyProductionEnrichmentEnabled = settings.tmdbEnrichProductionInfo ||
|
||
settings.tmdbEnrichTvDetails ||
|
||
settings.tmdbEnrichMovieDetails ||
|
||
settings.tmdbEnrichCollections;
|
||
|
||
if (!tmdbId || !settings.enrichMetadataWithTMDB || !metadata || !anyProductionEnrichmentEnabled) {
|
||
return;
|
||
}
|
||
|
||
const contentKey = `${type}-${tmdbId}`;
|
||
if (productionInfoFetchedRef.current === contentKey) {
|
||
return;
|
||
}
|
||
|
||
// Only skip if networks are set AND collection is already set (for movies)
|
||
const hasNetworks = !!(metadata as any).networks;
|
||
const hasCollection = !!(metadata as any).collection;
|
||
if (hasNetworks && (type !== 'movie' || hasCollection)) {
|
||
return;
|
||
}
|
||
|
||
const fetchProductionInfo = async () => {
|
||
try {
|
||
productionInfoFetchedRef.current = contentKey;
|
||
const tmdbService = TMDBService.getInstance();
|
||
let productionInfo: any[] = [];
|
||
|
||
if (__DEV__) console.log('[useMetadata] fetchProductionInfo starting', {
|
||
contentKey,
|
||
type,
|
||
tmdbId,
|
||
useLocalized: settings.useTmdbLocalizedMetadata,
|
||
lang: settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en',
|
||
hasExistingNetworks: !!(metadata as any).networks,
|
||
productionInfoEnabled: settings.tmdbEnrichProductionInfo,
|
||
tvDetailsEnabled: settings.tmdbEnrichTvDetails,
|
||
movieDetailsEnabled: settings.tmdbEnrichMovieDetails,
|
||
collectionsEnabled: settings.tmdbEnrichCollections
|
||
});
|
||
|
||
if (type === 'series') {
|
||
// Fetch networks and additional details for TV shows
|
||
const lang = settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en';
|
||
const showDetails = await tmdbService.getTVShowDetails(tmdbId, lang);
|
||
if (showDetails) {
|
||
if (__DEV__) console.log('[useMetadata] fetchProductionInfo got showDetails', {
|
||
hasNetworks: !!showDetails.networks,
|
||
networksCount: showDetails.networks?.length || 0
|
||
});
|
||
// Fetch networks only if production info is enabled
|
||
if (settings.tmdbEnrichProductionInfo && showDetails.networks) {
|
||
productionInfo = Array.isArray(showDetails.networks)
|
||
? showDetails.networks
|
||
.map((n: any) => ({
|
||
id: n?.id,
|
||
name: n?.name,
|
||
logo: tmdbService.getImageUrl(n?.logo_path, 'w185') || undefined,
|
||
}))
|
||
.filter((n: any) => n && (n.logo || n.name))
|
||
: [];
|
||
}
|
||
|
||
// Fetch additional TV details only if TV details is enabled
|
||
if (settings.tmdbEnrichTvDetails) {
|
||
const tvDetails = {
|
||
status: showDetails.status,
|
||
firstAirDate: showDetails.first_air_date,
|
||
lastAirDate: showDetails.last_air_date,
|
||
numberOfSeasons: showDetails.number_of_seasons,
|
||
numberOfEpisodes: showDetails.number_of_episodes,
|
||
episodeRunTime: showDetails.episode_run_time,
|
||
type: showDetails.type,
|
||
originCountry: showDetails.origin_country,
|
||
originalLanguage: showDetails.original_language,
|
||
createdBy: showDetails.created_by?.map(creator => ({
|
||
id: creator.id,
|
||
name: creator.name,
|
||
profile_path: creator.profile_path || undefined
|
||
})),
|
||
};
|
||
|
||
// Update metadata with TV details
|
||
setMetadata((prev: any) => ({
|
||
...prev,
|
||
tmdbId,
|
||
tvDetails
|
||
}));
|
||
}
|
||
}
|
||
} else if (type === 'movie') {
|
||
// Fetch production companies and additional details for movies
|
||
const lang = settings.useTmdbLocalizedMetadata ? (settings.tmdbLanguagePreference || 'en') : 'en';
|
||
const movieDetails = await tmdbService.getMovieDetails(String(tmdbId), lang);
|
||
if (movieDetails) {
|
||
if (__DEV__) console.log('[useMetadata] fetchProductionInfo got movieDetails', {
|
||
hasProductionCompanies: !!movieDetails.production_companies,
|
||
productionCompaniesCount: movieDetails.production_companies?.length || 0
|
||
});
|
||
// Fetch production companies only if production info is enabled
|
||
if (settings.tmdbEnrichProductionInfo && movieDetails.production_companies) {
|
||
productionInfo = Array.isArray(movieDetails.production_companies)
|
||
? movieDetails.production_companies
|
||
.map((c: any) => ({
|
||
id: c?.id,
|
||
name: c?.name,
|
||
logo: tmdbService.getImageUrl(c?.logo_path, 'w185'),
|
||
}))
|
||
.filter((c: any) => c && (c.logo || c.name))
|
||
: [];
|
||
}
|
||
|
||
// Fetch additional movie details only if movie details is enabled
|
||
if (settings.tmdbEnrichMovieDetails) {
|
||
const movieDetailsObj = {
|
||
status: movieDetails.status,
|
||
releaseDate: movieDetails.release_date,
|
||
runtime: movieDetails.runtime,
|
||
budget: movieDetails.budget,
|
||
revenue: movieDetails.revenue,
|
||
originalLanguage: movieDetails.original_language,
|
||
originCountry: movieDetails.production_countries?.map((c: any) => c.iso_3166_1),
|
||
tagline: movieDetails.tagline,
|
||
};
|
||
|
||
// Update metadata with movie details
|
||
setMetadata((prev: any) => ({
|
||
...prev,
|
||
tmdbId,
|
||
movieDetails: movieDetailsObj
|
||
}));
|
||
}
|
||
|
||
// Fetch collection data if movie belongs to a collection AND collections is enabled
|
||
if (settings.tmdbEnrichCollections && movieDetails.belongs_to_collection) {
|
||
setLoadingCollection(true);
|
||
try {
|
||
const collectionDetails = await tmdbService.getCollectionDetails(
|
||
movieDetails.belongs_to_collection.id,
|
||
lang
|
||
);
|
||
|
||
if (collectionDetails && collectionDetails.parts) {
|
||
// Fetch individual movie images to get backdrops with embedded titles/logos
|
||
const collectionMoviesData = await Promise.all(
|
||
collectionDetails.parts.map(async (part: any, index: number) => {
|
||
let movieBackdropUrl = undefined;
|
||
|
||
// Try to fetch movie images with language parameter
|
||
try {
|
||
const movieImages = await tmdbService.getMovieImagesFull(part.id, lang);
|
||
if (movieImages && movieImages.backdrops && movieImages.backdrops.length > 0) {
|
||
// Filter and sort backdrops by language and quality
|
||
const languageBackdrops = movieImages.backdrops
|
||
.filter((backdrop: any) => backdrop.aspect_ratio > 1.0) // Landscape orientation
|
||
.sort((a: any, b: any) => {
|
||
// Prioritize backdrops with the requested language
|
||
const aHasLang = a.iso_639_1 === lang;
|
||
const bHasLang = b.iso_639_1 === lang;
|
||
if (aHasLang && !bHasLang) return -1;
|
||
if (!aHasLang && bHasLang) return 1;
|
||
|
||
// Then prioritize English if requested language not available
|
||
const aIsEn = a.iso_639_1 === 'en';
|
||
const bIsEn = b.iso_639_1 === 'en';
|
||
if (aIsEn && !bIsEn) return -1;
|
||
if (!aIsEn && bIsEn) return 1;
|
||
|
||
// Then sort by vote average (quality), then by resolution
|
||
if (a.vote_average !== b.vote_average) {
|
||
return b.vote_average - a.vote_average;
|
||
}
|
||
return (b.width * b.height) - (a.width * a.height);
|
||
});
|
||
|
||
if (languageBackdrops.length > 0) {
|
||
movieBackdropUrl = tmdbService.getImageUrl(languageBackdrops[0].file_path, 'original');
|
||
}
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.warn('[useMetadata] Failed to fetch movie images for:', part.id, error);
|
||
}
|
||
|
||
return {
|
||
id: `tmdb:${part.id}`,
|
||
type: 'movie',
|
||
name: part.title,
|
||
poster: part.poster_path ? tmdbService.getImageUrl(part.poster_path, 'w500') : 'https://via.placeholder.com/300x450/cccccc/666666?text=No+Image',
|
||
banner: movieBackdropUrl || (part.backdrop_path ? tmdbService.getImageUrl(part.backdrop_path, 'original') : undefined),
|
||
year: part.release_date ? new Date(part.release_date).getFullYear() : undefined,
|
||
description: part.overview,
|
||
collection: {
|
||
id: collectionDetails.id,
|
||
name: collectionDetails.name,
|
||
poster_path: collectionDetails.poster_path,
|
||
backdrop_path: collectionDetails.backdrop_path
|
||
}
|
||
};
|
||
})
|
||
) as StreamingContent[];
|
||
|
||
setCollectionMovies(collectionMoviesData);
|
||
|
||
// Update metadata with collection info
|
||
setMetadata((prev: any) => ({
|
||
...prev,
|
||
collection: {
|
||
id: collectionDetails.id,
|
||
name: collectionDetails.name,
|
||
poster_path: collectionDetails.poster_path,
|
||
backdrop_path: collectionDetails.backdrop_path
|
||
}
|
||
}));
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.error('[useMetadata] Error fetching collection:', error);
|
||
} finally {
|
||
setLoadingCollection(false);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (productionInfo.length > 0) {
|
||
setMetadata((prev: any) => ({ ...prev, networks: productionInfo }));
|
||
}
|
||
} catch (error) {
|
||
if (__DEV__) console.error('[useMetadata] Failed to fetch production info:', error);
|
||
}
|
||
};
|
||
|
||
fetchProductionInfo();
|
||
}, [tmdbId, settings.enrichMetadataWithTMDB, metadata, type, settings.tmdbEnrichProductionInfo, settings.tmdbEnrichTvDetails, settings.tmdbEnrichMovieDetails, settings.tmdbEnrichCollections]);
|
||
|
||
// Reset tmdbId when id changes
|
||
useEffect(() => {
|
||
setTmdbId(null);
|
||
}, [id]);
|
||
|
||
// Subscribe to library updates
|
||
useEffect(() => {
|
||
const unsubscribe = catalogService.subscribeToLibraryUpdates((libraryItems) => {
|
||
const isInLib = libraryItems.some(item => item.id === id);
|
||
// Only update state if the value actually changed to prevent unnecessary re-renders
|
||
setInLibrary(prev => prev !== isInLib ? isInLib : prev);
|
||
});
|
||
|
||
return () => unsubscribe();
|
||
}, [id]);
|
||
|
||
// Memory optimization: Cleanup on unmount
|
||
useEffect(() => {
|
||
return () => {
|
||
// Clear cleanup timeout
|
||
if (cleanupTimeoutRef.current) {
|
||
clearTimeout(cleanupTimeoutRef.current);
|
||
}
|
||
|
||
// Force cleanup
|
||
cleanupStreams();
|
||
|
||
// Reset production info fetch tracking
|
||
productionInfoFetchedRef.current = null;
|
||
|
||
if (__DEV__) console.log('[useMetadata] Component unmounted, memory cleaned up');
|
||
};
|
||
}, [cleanupStreams]);
|
||
|
||
|
||
return {
|
||
metadata,
|
||
loading,
|
||
error,
|
||
cast,
|
||
loadingCast,
|
||
episodes,
|
||
groupedEpisodes,
|
||
selectedSeason,
|
||
tmdbId,
|
||
loadingSeasons,
|
||
groupedStreams,
|
||
loadingStreams,
|
||
episodeStreams,
|
||
loadingEpisodeStreams,
|
||
addonResponseOrder,
|
||
preloadedStreams,
|
||
preloadedEpisodeStreams,
|
||
selectedEpisode,
|
||
inLibrary,
|
||
loadMetadata,
|
||
loadStreams,
|
||
loadEpisodeStreams,
|
||
handleSeasonChange,
|
||
toggleLibrary,
|
||
setSelectedEpisode,
|
||
setEpisodeStreams,
|
||
recommendations,
|
||
loadingRecommendations,
|
||
setMetadata,
|
||
imdbId,
|
||
scraperStatuses,
|
||
activeFetchingScrapers,
|
||
collectionMovies,
|
||
loadingCollection,
|
||
};
|
||
};
|