popup.js

const episodeNumberInput = document.getElementById('episodeNumber');
const animeNameInput = document.getElementById('animeName');
const checkButton = document.getElementById('checkButton');
const buttonText = document.getElementById('buttonText');
const loader = document.getElementById('loader');
const resultDiv = document.getElementById('result');

const CACHE_TTL = 1000 * 60 * 60 * 24; // 24 hours in ms

document.addEventListener('DOMContentLoaded', async () => {
    // Attempt to load previous state
    chrome.storage.local.get(['lastAnime', 'lastEpisode'], (data) => {
        if (data.lastAnime) {
            animeNameInput.value = data.lastAnime;
        }
        if (data.lastEpisode) {
            // Auto-increment episode number for convenience
            episodeNumberInput.value = parseInt(data.lastEpisode, 10) + 1;
        }
    });

    // Auto-detect from active tab
    chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
        if (tabs && tabs.length > 0) {
            const currentTab = tabs[0];
            if (currentTab.url && (currentTab.url.includes('crunchyroll.com') || currentTab.url.includes('netflix.com'))) {
                const title = currentTab.title;
                // Basic heuristic for extracting episode numbers: "Anime Name - Episode 12 - Watch..."
                // or "Watch Anime - Ep 12"
                const epMatch = title.match(/(?:episode|ep|e)\s*0*(\d+)/i);
                if (epMatch && epMatch[1]) {
                    episodeNumberInput.value = epMatch[1];
                }

                // For Crunchyroll, title often starts with Anime Name
                if (currentTab.url.includes('crunchyroll.com')) {
                    const parts = title.split('-');
                    if (parts.length > 1) {
                        const potentialAnime = parts[0].trim().replace(/Watch\s+/i, '');
                        if (potentialAnime && !animeNameInput.value) {
                            animeNameInput.value = potentialAnime;
                        }
                    }
                }
            }
        }
    });
});

function isEpisodeInRange(episodeNumber, rangeString) {
    if (!rangeString) return false;
    if (rangeString.includes('-')) {
        const [start, end] = rangeString.split('-').map(Number);
        if (!isNaN(start) && !isNaN(end)) {
            return episodeNumber >= start && episodeNumber <= end;
        }
    } else {
        const singleEpisode = Number(rangeString);
        if (!isNaN(singleEpisode)) {
            return episodeNumber === singleEpisode;
        }
    }
    return false;
}

function getMainTypeFromClass(className) {
    if (!className) return 'unknown';
    const lowerClassName = className.toLowerCase();
    if (lowerClassName.includes('manga_canon')) return 'canon';
    if (lowerClassName.includes('filler')) return 'filler';
    if (lowerClassName.includes('mixed_canon/filler')) return 'mixed';
    if (lowerClassName.includes('anime_canon')) return 'mixed';
    if (lowerClassName.trim() !== '') return 'unknown';
    return 'unknown';
}

async function fetchAFLDataCached(animeName) {
    const slug = animeName.toLowerCase().trim().replace(/[\s_]+/g, '-').replace(/[^a-z0-9\-]/g, '');
    const cacheKey = `afl_cache_${slug}`;

    return new Promise((resolve) => {
        chrome.storage.local.get([cacheKey], async (result) => {
            const cached = result[cacheKey];
            const now = Date.now();

            if (cached && (now - cached.timestamp < CACHE_TTL)) {
                console.log('Using cached data for', slug);
                resolve(cached.episodes);
                return;
            }

            console.log('Fetching fresh data for', slug);
            const url = `https://www.animefillerlist.com/shows/${slug}`;
            try {
                const response = await fetch(url, { mode: 'cors' });
                if (!response.ok) {
                    if (response.status === 404) {
                        resolve({ error: `Anime "${animeName}" not found on Anime Filler List.` });
                        return;
                    }
                    throw new Error(`Network response was not ok! status: ${response.status}`);
                }

                const htmlText = await response.text();
                const parser = new DOMParser();
                const doc = parser.parseFromString(htmlText, 'text/html');

                const episodeRows = doc.querySelectorAll('.EpisodeList tbody tr');
                if (!episodeRows || episodeRows.length === 0) {
                    resolve({ error: `Could not find episode list for "${animeName}". AFL website layout might have changed.` });
                    return;
                }

                const episodesData = [];
                for (const row of episodeRows) {
                    const episodeCell = row.querySelector('td:nth-child(1)');
                    const typeCell = row.querySelector('td:nth-child(3)');
                    if (episodeCell) {
                        episodesData.push({
                            range: episodeCell.textContent.trim(),
                            className: row.className.trim(),
                            typeText: typeCell ? typeCell.textContent.trim() : row.className.trim()
                        });
                    }
                }

                if (episodesData.length > 0) {
                    const dataToCache = {
                        timestamp: now,
                        episodes: episodesData
                    };
                    chrome.storage.local.set({ [cacheKey]: dataToCache });
                    resolve(episodesData);
                } else {
                    resolve({ error: `No valid episodes found for "${animeName}".` });
                }

            } catch (error) {
                console.error("Error fetching or parsing filler data:", error);
                resolve({ error: `Failed to fetch data. Check console for details.` });
            }
        });
    });
}

async function fetchAndCheckFiller(animeName, episodeNumber) {
    const data = await fetchAFLDataCached(animeName);

    if (data.error) {
        return { type: "unknown", message: data.error };
    }

    for (const ep of data) {
        if (isEpisodeInRange(episodeNumber, ep.range)) {
            const mainType = getMainTypeFromClass(ep.className);
            return {
                type: mainType,
                message: `${animeName} Episode ${episodeNumber}: ${ep.typeText}`
            };
        }
    }

    return { type: "unknown", message: `Episode ${episodeNumber} not found in the list for "${animeName}".` };
}

function showLoading() {
    buttonText.textContent = 'Checking...';
    loader.classList.remove('hidden');
    checkButton.disabled = true;
    resultDiv.classList.remove('show');
}

function hideLoading() {
    buttonText.textContent = 'Check !';
    loader.classList.add('hidden');
    checkButton.disabled = false;
    resultDiv.classList.add('show');
}

checkButton.addEventListener('click', async () => {
    const animeName = animeNameInput.value.trim();
    const episodeNumberStr = episodeNumberInput.value;

    if (!animeName || !episodeNumberStr) {
        resultDiv.textContent = 'Please enter both Anime Name and Episode #.';
        resultDiv.className = 'result-unknown show';
        return;
    }

    const episodeNumber = parseInt(episodeNumberStr, 10);
    if (isNaN(episodeNumber) || episodeNumber < 1) {
        resultDiv.textContent = 'Invalid Episode Number.';
        resultDiv.className = 'result-unknown show';
        return;
    }

    showLoading();

    const result = await fetchAndCheckFiller(animeName, episodeNumber);

    resultDiv.textContent = result.message;
    resultDiv.className = `show result-${result.type || 'unknown'}`;

    // Save successful query
    chrome.storage.local.set({ lastAnime: animeName, lastEpisode: episodeNumber });

    hideLoading();
});