Loading coming soon movies...
Loading top rated movies...
`;
showMoviesUpcomingSubtabs(subTabsHtml);
// Attach subtab listeners
const comingSoonBtn = upcomingContainer.querySelector('[data-view="comingsoon"]');
const topRatedBtn = upcomingContainer.querySelector('[data-view="toprated"]');
const switchSubTab = (btn, view) => {
// Update tab buttons
[comingSoonBtn, topRatedBtn].forEach(b =>
b.classList.remove('emby-tab-button-active')
);
btn.classList.add('emby-tab-button-active');
// Update content visibility using is-active
const comingSoonContent = upcomingContainer.querySelector('#jfcComingSoonContent');
const topRatedContent = upcomingContainer.querySelector('#jfcTopRatedContent');
if (view === "comingsoon") {
comingSoonContent.classList.add('is-active');
topRatedContent.classList.remove('is-active');
} else {
comingSoonContent.classList.remove('is-active');
topRatedContent.classList.add('is-active');
}
JFC_MOVIES.currentTabView = view;
};
comingSoonBtn.addEventListener('click', () => {
switchSubTab(comingSoonBtn, "comingsoon");
});
topRatedBtn.addEventListener('click', () => {
switchSubTab(topRatedBtn, "toprated");
});
upcomingContainer.querySelector(`#jfcMoviesUpcomingSubTabs [data-view="${JFC_MOVIES.currentTabView}"]`)?.classList.add('emby-tab-button-active');
consoleLog("✓ Movies upcoming subtabs injected");
}
function showMoviesUpcomingSubtabs(subTabsHtml) {
const upcomingTabContainer = document.querySelector('#jfcMoviesUpcomingTabContent');
if (subTabsHtml) {
if (!upcomingTabContainer || upcomingTabContainer?.querySelector('#jfcMoviesUpcomingSubTabs')) return;
upcomingTabContainer.innerHTML = subTabsHtml;
upcomingTabContainer.querySelector('#jfcMoviesUpcomingSubTabs .btnFilter')?.addEventListener('click', () => {
openUpcomingFilterDialog('movies'); // ← Pass 'movies'
});
}
else{
upcomingTabContainer?.querySelector('#jfcMoviesUpcomingSubTabs')?.classList.remove('hide');
}
updateUpcomingFilterIndicator('movies'); // ← Pass 'movies'
}
// ========================================
// LOAD ALL UPCOMING MOVIES DATA
// ========================================
async function loadAllUpcomingMovies() {
if (JFC_MOVIES.isLoading) return;
// Display message "no api key found"
if (!hasTMDB) {
showApiKeyWarning(document.querySelector('#jfcMoviesUpcomingTabContent'), 'movies');
return;
}
JFC_MOVIES.isLoading = true;
showSpinner();
try {
// Fetch both datasets in parallel
const [comingSoon, topRated] = await Promise.all([
fetchComingSoonMovies(COMINGSOON_MAX),
fetchTopRatedMovies(TOPRATED_MAX)
]);
comingSoonMoviesAll = comingSoon;
topRatedMoviesAll = topRated;
consoleLog(`✅ Loaded ${comingSoon.length} coming soon + ${topRated.length} top rated movies`);
// Render current view
renderCurrentMoviesView();
} catch (error) {
console.error("❌ Error loading upcoming movies:", error);
} finally {
JFC_MOVIES.isLoading = false;
showSpinner(false);
}
}
// ========================================
// RENDER CURRENT VIEW
// ========================================
function renderCurrentMoviesView() {
const comingSoonContent = document.querySelector('#jfcComingSoonContent');
const topRatedContent = document.querySelector('#jfcTopRatedContent');
consoleLog("🎬 Rendering current view:", JFC_MOVIES.currentTabView);
consoleLog("📊 Coming Soon:", comingSoonMoviesAll.length, "Top Rated:", topRatedMoviesAll.length);
// Always render both views when data is loaded
if (comingSoonContent && comingSoonMoviesAll.length > 0) {
renderComingSoonMovies(comingSoonContent);
}
if (topRatedContent && topRatedMoviesAll.length > 0) {
renderTopRatedMovies(topRatedContent);
}
}
async function batchCheckLibrary(tmdbIds, type = 'movie') {
const { userId } = getCredentials();
if (!userId || !tmdbIds.length) return new Map();
try {
const itemType = type === 'movie' ? 'Movie' : 'Series';
// Check cache first
const cacheKey = type === 'movie' ? CONFIG.moviesCollectionsCache : CONFIG.seriesCollectionsCache;
const cached = localStorage.getItem(cacheKey);
let libraryItems = [];
if (cached) {
try {
const { items, timestamp } = JSON.parse(cached);
// Validate cache has proper data
if (items && Array.isArray(items) && items.length > 0 &&
Date.now() - timestamp < CONFIG.showsCollectionsCacheDuration) {
consoleLog(`📦 Using cached ${type} library data (${items.length} items)`);
libraryItems = items;
}
} catch (e) {}
}
// Fetch using ApiClient if no cache
if (!libraryItems.length) {
const data = await ApiClient.getItems(userId, {
IncludeItemTypes: itemType,
Recursive: true,
Fields: "ProviderIds"
});
libraryItems = data.Items || [];
// Cache it
localStorage.setItem(cacheKey, JSON.stringify({
items: libraryItems,
timestamp: Date.now()
}));
}
// Build TMDb ID -> Jellyfin ID map
const libraryMap = new Map();
libraryItems.forEach(item => {
const tmdbId = item.ProviderIds?.Tmdb;
if (tmdbId) {
libraryMap.set(String(tmdbId), item.Id);
}
});
consoleLog(`📚 Library indexed: ${libraryMap.size} ${type}s`, libraryMap);
return libraryMap;
} catch (error) {
console.error("Error batch checking library:", error);
return new Map();
}
}
function dedupeById(items, idKey = 'id') {
return Array.from(
new Map(items.map(i => [i[idKey], i])).values()
);
}
// ========================================
// FETCH COMING SOON MOVIES
// ========================================
async function fetchComingSoonMovies(limit = 100) {
consoleLog("🎬 Fetching coming soon movies...");
try {
const today = new Date();
const futureDate = new Date();
futureDate.setMonth(futureDate.getMonth() + 12); // Next 6 months
const todayStr = today.toISOString().split('T')[0];
const futureStr = futureDate.toISOString().split('T')[0];
consoleLog(`📅 Fetching movies between ${todayStr} and ${futureStr}`);
// Fetch upcoming movies
// Calculate pages needed (TMDB returns 20 per page)
const pagesNeeded = Math.ceil(limit / 20);
// TMDB allows max 500 pages, but let's cap at 10 for safety (200 results)
const pagesToFetch = Math.min(pagesNeeded, 20);
const pages = Array.from({ length: pagesToFetch }, (_, i) => i + 1);
const allPromises = pages.map(page =>
secureTMDBFetch('discover/movie', {
'language': 'en-US',
'sort_by': 'popularity.desc',
'primary_release_date.gte': todayStr,
'primary_release_date.lte': futureStr,
'include_adult': 'false',
'region': 'US',
'page': page.toString()
})
);
const results = await Promise.all(allPromises);
const flat = results.flatMap(r => r.results || []);
const allMovies = dedupeById(flat, 'id'); // ✅ Dedupe/Deduplication by TMDB id
consoleLog(
`🎯 TMDB dedupe: ${flat.length} → ${allMovies.length}`
);
consoleLog("🎬 Raw coming soon movies fetched:", allMovies.length, "pagesNeeded:", pagesNeeded, allMovies);
// Format movies
const formatted = allMovies.map(movie => ({
tmdbId: movie.id,
title: movie.title,
summary: movie.overview,
image: movie.backdrop_path ? `https://image.tmdb.org/t/p/w500${movie.backdrop_path}` : null,
posterImage: movie.poster_path ? `https://image.tmdb.org/t/p/w500${movie.poster_path}` : null,
popularity: movie.popularity || 0,
voteCount: movie.vote_count || 0,
rating: movie.vote_average || 0,
releaseDate: movie.release_date,
releaseDateObj: movie.release_date ? new Date(movie.release_date) : null,
genres: (movie.genre_ids || []).map(id => TMDB_GENRES[id]).filter(Boolean),
inLibrary: false,
isComingSoon: true
}));
const now = new Date();
const scored = formatted.map(m => {
const daysUntilRelease = Math.max(
1,
Math.ceil((m.releaseDateObj - now) / (1000 * 60 * 60 * 24))
);
const languagePenalty =
m.originalLanguage && m.originalLanguage !== 'en' ? 80 : 0;
const contentScore =
(Math.log10(m.popularity + 1) * 60) +
(Math.log10(m.voteCount + 1) * 20) +
(m.rating * 5) -
Math.log(daysUntilRelease + 1) -
languagePenalty;
return {
...m,
contentScore
};
});
// Filter future releases only and sort by release date (soonest first)
// const sorted = formatted
// // .filter(m => m.popularity > 15) // buzz filter
// .filter(m => m.releaseDateObj) // filter out movies without release date
// .filter(m => m.releaseDateObj > now)
// .sort((a, b) => b.popularity - a.popularity)
// .slice(0, limit);
const sorted = scored
.filter(m => m.image) // 🧹 marketing-quality filter
.filter(m => m.releaseDateObj > now)
.sort((a, b) => b.contentScore - a.contentScore)
.slice(0, limit);
consoleLog(`✅ Returning ${sorted.length} coming soon movies`, formatted);
return sorted;
} catch (error) {
console.error("❌ Error fetching coming soon movies:", error);
return [];
}
}
// ========================================
// FETCH TOP RATED MOVIES
// ========================================
async function fetchTopRatedMovies(limit = 100) {
consoleLog("⭐ Fetching top rated movies...");
try {
const currentYear = new Date().getFullYear();
const minYear = currentYear - 30;
// Calculate pages needed (TMDB returns 20 per page)
const pagesNeeded = Math.ceil(limit / 20);
// TMDB allows max 500 pages, but let's cap at 10 for safety (200 results)
const pagesToFetch = Math.min(pagesNeeded, 10);
const pages = Array.from({ length: pagesToFetch }, (_, i) => i + 1);
const allPromises = pages.map(page =>
secureTMDBFetch('discover/movie', {
'language': 'en-US',
'sort_by': 'revenue.desc',
'vote_count.gte': '200',
'primary_release_date': `.gte=${minYear}-01-01`,
'include_adult': 'false',
'region': 'US',
'page': page.toString()
})
);
const results = await Promise.all(allPromises);
const flat = results.flatMap(r => r.results || []);
const allMovies = dedupeById(flat, 'id'); // ✅ Dedupe/Deduplication by TMDB id
consoleLog(
`🎯 TMDB dedupe: ${flat.length} → ${allMovies.length}`
);
consoleLog("⭐ Raw top rated movies fetched:", allMovies.length);
const formatted = allMovies.map(movie => ({
tmdbId: movie.id,
title: movie.title,
summary: movie.overview,
image: movie.backdrop_path ? `https://image.tmdb.org/t/p/w500${movie.backdrop_path}` : null,
posterImage: movie.poster_path ? `https://image.tmdb.org/t/p/w500${movie.poster_path}` : null,
rating: movie.vote_average,
voteCount: movie.vote_count,
popularity: movie.popularity,
releaseDate: movie.release_date,
releaseDateObj: movie.release_date ? new Date(movie.release_date) : null,
genres: (movie.genre_ids || []).map(id => TMDB_GENRES[id]).filter(Boolean),
weightedRating: getWeightedRating(movie, 300, 7),
inLibrary: false,
isTopRated: true
}));
const topRated = formatted
.filter(m => m.rating > 0 && m.voteCount >= 200)
.sort((a, b) => b.weightedRating - a.weightedRating)
.slice(0, limit);
// Batch check library (single request)
const tmdbIds = topRated.map(m => m.tmdbId);
const libraryMap = await batchCheckLibrary(tmdbIds, 'movie');
topRated.forEach((movie, i) => {
movie.topIndex = i + 1;
movie.inLibrary = libraryMap.has(String(movie.tmdbId));
if (movie.inLibrary) {
movie.itemId = libraryMap.get(String(movie.tmdbId)); // For linking
}
});
// Add topIndex to each movie
topRated.forEach((movie, i) => {
movie.topIndex = i + 1; // 1..100
});
consoleLog(`✅ Returning ${topRated.length} top rated movies, Limit: ${limit}`, topRated);
return topRated;
} catch (error) {
console.error("❌ Error fetching top rated movies:", error);
return [];
}
}
// ========================================
// RENDER COMING SOON
// ========================================
function renderComingSoonMovies(container) {
const filtered = applyUpcomingGenreFilter(comingSoonMoviesAll, 'movies');
const visible = filtered.slice(0, JFC_MOVIES.comingSoonVisible);
renderMoviesGrid(visible, container, "comingsoon");
renderMoviesLoadMoreButton(container, visible.length, filtered.length, "comingsoon");
}
// ========================================
// RENDER TOP RATED
// ========================================
function renderTopRatedMovies(container) {
const filtered = applyUpcomingGenreFilter(topRatedMoviesAll, 'movies');
const visible = filtered.slice(0, JFC_MOVIES.topRatedVisible);
renderMoviesGrid(visible, container, "toprated");
renderMoviesLoadMoreButton(container, visible.length, filtered.length, "toprated");
}
// ========================================
// RENDER MOVIES GRID (Shared)
// ========================================
function renderMoviesGrid(movies, container, type) {
if (!hasTMDB) return;
if (!movies || movies.length === 0) {
container.innerHTML = `