// ==UserScript==
// @name         Trakt.tv Universal Search (Anime and Non-Anime)
// @namespace    http://tampermonkey.net/
// @version      1.0
// @description  Search for anime on hianime.to and non-anime content on 1flix.to from Trakt.tv
// @author       konvar
// @match        https://trakt.tv/*
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_xmlhttpRequest
// @grant        GM_addStyle
// @connect      hianime.to
// @connect      1flix.to
// @license MIT
// @downloadURL none
// ==/UserScript==

(function() {
    'use strict';

    const HIANIME_BASE_URL = 'https://hianime.to';
    const FLIX_BASE_URL = 'https://1flix.to';
    const TOP_RESULTS = 10;
    const SIMILARITY_THRESHOLD = 0.4;
    const EPISODE_TITLE_SIMILARITY_THRESHOLD = 0.8;
    const MAX_SEARCH_PAGES = 1;

    GM_addStyle(`
        .trakt-universal-search-button {
            display: flex;
            align-items: center;
            justify-content: center;
            margin-bottom: 10px;
            /* Remove default button styles */
            background: none;
            border: none;
            padding: 0;
            cursor: pointer; /* Maintain pointer cursor */
        }
        .trakt-universal-search-button:hover {
            /* Prevent white glow on hover */
            box-shadow: none;
        }
        .trakt-universal-search-button img {
            max-height: 30px;
            width: auto;
        }
    `);

    class ContentInfo {
        constructor(title, year, isAnime, season, episode, episodeTitle, alternativeTitles, contentType, absoluteEpisode) {
            this.title = title;
            this.year = year;
            this.isAnime = isAnime;
            this.season = season;
            this.episode = episode;
            this.episodeTitle = episodeTitle;
            this.alternativeTitles = alternativeTitles;
            this.contentType = contentType;
            this.absoluteEpisode = absoluteEpisode;
        }

        static fromDOM() {
            let titleElement, yearElement;
            if (window.location.pathname.startsWith('/movies/')) {
                const movieTitleElement = document.querySelector('h1');
                if (movieTitleElement) {
                    titleElement = movieTitleElement.childNodes[0];
                    yearElement = movieTitleElement.querySelector('.year');
                }
            } else {
                titleElement = document.querySelector('h2 a[data-safe="true"]');
            }

            const episodeElement = document.querySelector('h1.episode .main-title-sxe');
            const episodeTitleElement = document.querySelector('h1.episode .main-title');
            const episodeAbsElement = document.querySelector('h1.episode .main-title-abs');
            const genreElements = document.querySelectorAll('.genres .btn');
            const additionalStats = document.querySelector('ul.additional-stats');
            const alternativeTitleElement = document.querySelector('.additional-stats .meta-data[data-type="alternative_titles"]');

            if (titleElement) {
                const title = titleElement.textContent.trim().replace(/[:.,!?]+$/, '');
                const episodeInfo = episodeElement ? episodeElement.textContent.trim().split('x') : null;
                const season = episodeInfo ? parseInt(episodeInfo[0]) : null;
                const episode = episodeInfo ? parseInt(episodeInfo[1]) : null;
                const episodeTitle = episodeTitleElement ? episodeTitleElement.textContent.trim() : null;
                const absoluteEpisode = episodeAbsElement ? parseInt(episodeAbsElement.textContent.trim().replace(/[\(\)]/g, '')) : null;

                const genres = Array.from(genreElements).map(el => el.textContent.trim().toLowerCase());
                const isAnime = genres.includes('anime') ||
                                (additionalStats && additionalStats.textContent.toLowerCase().includes('anime')) ||
                                document.querySelector('.poster img[src*="anime"]') !== null;

                let year;
                if (yearElement) {
                    year = yearElement.textContent.trim();
                } else if (additionalStats) {
                    const yearMatch = additionalStats.textContent.match(/(\d{4})/);
                    year = yearMatch ? yearMatch[1] : null;
                }

                const alternativeTitles = alternativeTitleElement
                    ? alternativeTitleElement.textContent.split(',').map(t => t.trim())
                    : [];

                const contentType = window.location.pathname.startsWith('/movies/') ? 'movie' : 'tv';

                return new ContentInfo(title, year, isAnime, season, episode, episodeTitle, alternativeTitles, contentType, absoluteEpisode);
            }
            return null;
        }
    }

    class SearchButton {
        constructor(contentInfo) {
            this.contentInfo = contentInfo;
            this.button = this.createButton();
        }

        createButton() {
            const button = document.createElement('button'); // Changed from <a> to <button>
            button.className = 'btn btn-block btn-summary trakt-universal-search-button'; // Updated class name
            button.style.display = 'none';

            const icon = document.createElement('img');
            icon.style.width = 'auto';
            icon.style.height = '50px';

            if (this.contentInfo.isAnime) {
                icon.src = `${HIANIME_BASE_URL}/images/logo.png`;
                icon.alt = 'Hianime Logo';
            } else {
                icon.src = 'https://img.1flix.to/xxrz/400x400/100/e4/ca/e4ca1fc10cda9cf762f7b51876dc917b/e4ca1fc10cda9cf762f7b51876dc917b.png';
                icon.alt = '1flix Logo';
            }

            button.appendChild(icon);
            return button;
        }

        addToDOM() {
            const container = document.querySelector('.col-lg-4.col-md-5.action-buttons');
            if (container && !document.querySelector('.trakt-universal-search-button')) { // Updated class name
                container.insertBefore(this.button, container.firstChild);
                return true;
            }
            return false;
        }

        updateWithContentLink(url) {
            this.button.addEventListener('click', () => {
                window.open(url, '_blank');
            });
            this.button.style.display = 'flex';
        }


        updateButtonText(text) {
            const textNode = document.createTextNode(` ${text}`);
            this.button.appendChild(textNode);
        }
    }

    class ContentSearcher {
        constructor(contentInfo) {
            this.contentInfo = contentInfo;
        }

        generateSearchUrl() {
            if (this.contentInfo.isAnime) {
                if (this.contentInfo.contentType === 'movie') {
                    return `${HIANIME_BASE_URL}/search?keyword=${encodeURIComponent(this.contentInfo.title)}&type=1`;
                } else {
                    return `${HIANIME_BASE_URL}/search?keyword=${encodeURIComponent(this.contentInfo.title)}&type=2`;
                }
            } else {
                const searchTerm = this.contentInfo.contentType === 'movie' ?
                    `${this.contentInfo.title} ${this.contentInfo.year}` :
                    this.contentInfo.title;
                return `${FLIX_BASE_URL}/search/${searchTerm.replace(/\s+/g, '-')}`;
            }
        }

        async search() {
            let page = 1;
            let allMatches = [];
            const searchUrl = this.generateSearchUrl();

            while (page <= MAX_SEARCH_PAGES) {
                const pageUrl = `${searchUrl}${this.contentInfo.isAnime ? '&' : '?'}page=${page}`;
                try {
                    const response = await this.makeRequest(pageUrl);
                    const parser = new DOMParser();
                    const doc = parser.parseFromString(response.responseText, 'text/html');
                    const pageMatches = this.findTopMatches(doc);

                    allMatches = allMatches.concat(pageMatches);

                    if (pageMatches.length === 0) break;
                    page++;
                } catch (error) {
                    break;
                }
            }

            for (const match of allMatches.slice(0, TOP_RESULTS)) {
                const contentUrl = await this.findContentUrl(match.url);
                if (contentUrl) {
                    return contentUrl;
                }
            }

            this.showMessage(`Content not found. Click the button to search manually.`);
            return searchUrl;
        }

        findTopMatches(doc) {
            const contentItems = doc.querySelectorAll('.flw-item');

            const allTitles = [this.contentInfo.title, ...this.contentInfo.alternativeTitles];
            const matches = Array.from(contentItems).map(item => {
                const titleElement = item.querySelector('.film-name a');
                const posterElement = item.querySelector('.film-poster-img');
                const infoElement = item.querySelector('.fd-infor');

                if (titleElement && infoElement) {
                    const itemTitle = titleElement.textContent.trim();
                    const normalizedItemTitle = this.normalizeTitle(itemTitle);
                    const bestScore = Math.max(...allTitles.map(title =>
                        this.calculateMatchScore(this.normalizeTitle(title), normalizedItemTitle)
                    ));
                    const href = titleElement.getAttribute('href');
                    const url = `${this.contentInfo.isAnime ? HIANIME_BASE_URL : FLIX_BASE_URL}${href}`;

                    let itemType, year, duration;

                    const itemTypeElement = infoElement.querySelector('.fdi-item');
                    const itemTypeText = itemTypeElement ? itemTypeElement.textContent.trim().toLowerCase() : '';

                    const seasonMatch = itemTypeText.match(/^ss (\d+)$/);
                    if (seasonMatch) {
                        itemType = 'tv';
                    } else {
                        const yearRegex = /^\d{4}$/;
                        if (yearRegex.test(itemTypeText)) {
                            year = itemTypeText;
                            itemType = 'movie';
                        } else {
                            itemType = itemTypeText;
                            year = null;
                        }
                    }

                    const durationElement = infoElement.querySelector('.fdi-duration');
                    duration = durationElement ? durationElement.textContent.trim() : null;

                    const posterUrl = posterElement ? posterElement.getAttribute('data-src') : null;

                    const isCorrectType = (
                        (this.contentInfo.contentType === 'movie' && itemType === 'movie') ||
                        (this.contentInfo.contentType === 'tv' && itemType === 'tv')
                    );

                    return {
                        title: itemTitle,
                        score: bestScore,
                        url: url,
                        type: itemType,
                        year: year,
                        duration: duration,
                        posterUrl: posterUrl,
                        isCorrectType: isCorrectType
                    };
                }
                return null;
            }).filter(match => match !== null && match.score >= SIMILARITY_THRESHOLD && match.isCorrectType)
              .sort((a, b) => b.score - a.score);

            return matches;
        }

        async findContentUrl(contentUrl) {
            try {
                const response = await this.makeRequest(contentUrl);
                const parser = new DOMParser();
                const doc = parser.parseFromString(response.responseText, 'text/html');

                if (this.contentInfo.isAnime && this.contentInfo.contentType === 'movie') {
                    const syncDataScript = doc.querySelector('#syncData');
                    if (syncDataScript) {
                        const syncData = JSON.parse(syncDataScript.textContent);
                        const seriesUrl = syncData.series_url;
                        if (seriesUrl) {
                            const movieId = seriesUrl.split('-').pop();
                            const watchUrl = `${HIANIME_BASE_URL}/watch/${seriesUrl.slice(seriesUrl.lastIndexOf('/') + 1)}?ep=${movieId}`;
                            return watchUrl;
                        }
                    }
                } else if (this.contentInfo.isAnime) {
                    const movieId = contentUrl.split('-').pop();
                    const apiUrl = `${HIANIME_BASE_URL}/ajax/v2/episode/list/${movieId}`;

                    const episodeDataResponse = await this.makeRequest(apiUrl);
                    const episodeData = JSON.parse(episodeDataResponse.responseText);


                    if (episodeData.status && episodeData.html) {
                        const episodeDoc = parser.parseFromString(episodeData.html, 'text/html');
                        const episodeLinks = episodeDoc.querySelectorAll('.ssl-item.ep-item');

                        const normalizedSearchTitle = this.normalizeTitle(this.contentInfo.episodeTitle);
                        let bestMatch = null;
                        let bestMatchScore = 0;

                        for (let i = 0; i < episodeLinks.length; i++) {
                            const link = episodeLinks[i];
                            const episodeNumber = parseInt(link.getAttribute('data-number'));
                            const episodeTitle = link.querySelector('.ep-name')?.textContent.trim() || '';

                            const normalizedEpisodeTitle = this.normalizeTitle(episodeTitle);
                            const titleMatchScore = this.calculateMatchScore(normalizedSearchTitle, normalizedEpisodeTitle);

                            if (episodeNumber === this.contentInfo.episode || episodeNumber === this.contentInfo.absoluteEpisode) {
                                if (titleMatchScore >= 0.3) {
                                    return `${HIANIME_BASE_URL}${link.getAttribute('href')}`;
                                }
                            }

                            if (titleMatchScore >= EPISODE_TITLE_SIMILARITY_THRESHOLD && (episodeNumber === this.contentInfo.episode || episodeNumber === this.contentInfo.absoluteEpisode)) {
                                return `${HIANIME_BASE_URL}${link.getAttribute('href')}`;
                            }

                            if (titleMatchScore > bestMatchScore) {
                                bestMatch = link;
                                bestMatchScore = titleMatchScore;
                            }
                        }

                        if (bestMatch && bestMatchScore >= EPISODE_TITLE_SIMILARITY_THRESHOLD) {
                            return `${HIANIME_BASE_URL}${bestMatch.getAttribute('href')}`;
                        }
                    }
                } else {
                    const detailPageWatch = doc.querySelector('.detail_page-watch');
                    if (!detailPageWatch) {
                        return null;
                    }

                    const movieId = detailPageWatch.getAttribute('data-id');
                    const movieType = detailPageWatch.getAttribute('data-type');

                    if (!movieId || !movieType) {
                        return null;
                    }

                    if (this.contentInfo.contentType === 'movie') {
                        const episodeListUrl = `${FLIX_BASE_URL}/ajax/episode/list/${movieId}`;
                        const episodeListResponse = await this.makeRequest(episodeListUrl);
                        const episodeListContent = episodeListResponse.responseText;

                        const episodeListDoc = parser.parseFromString(episodeListContent, 'text/html');
                        const serverItem = episodeListDoc.querySelector('.link-item');

                        if (serverItem) {
                            const serverId = serverItem.getAttribute('data-linkid');
                            const watchUrl = contentUrl.replace(/\/movie\//, '/watch-movie/') + `.${serverId}`;
                            return watchUrl;
                        }
                    } else {
                        const seasonListUrl = `${FLIX_BASE_URL}/ajax/season/list/${movieId}`;
                        const seasonListResponse = await this.makeRequest(seasonListUrl);
                        const seasonListContent = seasonListResponse.responseText;

                        const seasonListDoc = parser.parseFromString(seasonListContent, 'text/html');
                        const seasonItems = seasonListDoc.querySelectorAll('.ss-item');

                        for (let seasonItem of seasonItems) {
                            const seasonNumber = parseInt(seasonItem.textContent.trim().split(' ')[1]);
                            const seasonId = seasonItem.getAttribute('data-id');

                            if (seasonNumber === this.contentInfo.season) {
                                const episodeListUrl = `${FLIX_BASE_URL}/ajax/season/episodes/${seasonId}`;
                                const episodeListResponse = await this.makeRequest(episodeListUrl);
                                const episodeListContent = episodeListResponse.responseText;

                                const episodeListDoc = parser.parseFromString(episodeListContent, 'text/html');
                                const episodeItems = episodeListDoc.querySelectorAll('.eps-item');

                                for (let episodeItem of episodeItems) {
                                    const episodeNumber = parseInt(episodeItem.getAttribute('title').split(':')[0].replace('Eps', '').trim());
                                    const episodeTitle = episodeItem.getAttribute('title').split(':')[1].trim();

                                    if (episodeNumber === this.contentInfo.episode) {
                                        const episodeId = episodeItem.getAttribute('data-id');

                                        const serverListUrl = `${FLIX_BASE_URL}/ajax/episode/servers/${episodeId}`;
                                        const serverListResponse = await this.makeRequest(serverListUrl);
                                        const serverListContent = serverListResponse.responseText;

                                        const serverListDoc = parser.parseFromString(serverListContent, 'text/html');
                                        const serverItem = serverListDoc.querySelector('.link-item');

                                        if (serverItem) {
                                            const serverId = serverItem.getAttribute('data-id');
                                            const watchUrl = contentUrl.replace(/\/tv\//, '/watch-tv/') + `.${serverId}`;
                                            return watchUrl;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (error) {
            }
            return null;
        }

        normalizeTitle(title) {
            return title.toLowerCase()
                .replace(/[:.,!?'`]+/g, '')
                .replace(/\s+/g, ' ')
                .replace(/[^\w\s]/g, '')
                .trim();
        }

        calculateMatchScore(searchTitle, itemTitle) {
            const words1 = searchTitle.split(' ');
            const words2 = itemTitle.split(' ');
            const commonWords = words1.filter(word => words2.includes(word));
            return commonWords.length / Math.max(words1.length, words2.length);
        }

        makeRequest(url) {
            return new Promise((resolve, reject) => {
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: url,
                    headers: {
                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
                    },
                    onload: function(response) {
                        if (response.status === 200) {
                            resolve(response);
                        } else {
                            reject(new Error(`Failed to fetch content: ${response.status}`));
                        }
                    },
                    onerror: function(error) {
                        reject(error);
                    }
                });
            });
        }

        showMessage(message) {
            const messageDiv = document.createElement('div');
            messageDiv.textContent = message;
            messageDiv.style.cssText = "position: fixed; top: 10px; left: 50%; transform: translateX(-50%); background-color: #f8d7da; color: #721c24; padding: 10px; border-radius: 5px; z-index: 9999;";
            document.body.appendChild(messageDiv);
            setTimeout(() => messageDiv.remove(), 5000);
        }
    }

    class TraktTvHandler {
        constructor() {
            this.isInitialized = false;
        }

        async init() {
            if (this.isInitialized) {
                return;
            }

            const contentInfo = ContentInfo.fromDOM();
            if (contentInfo) {
                const searchButton = new SearchButton(contentInfo);
                if (searchButton.addToDOM()) {
                    this.isInitialized = true;

                    const contentSearcher = new ContentSearcher(contentInfo);
                    const result = await contentSearcher.search();
                    if (result) {
                        searchButton.updateWithContentLink(result);
                        if (result === contentSearcher.generateSearchUrl()) {
                            searchButton.updateButtonText("Search Manually");
                        }
                    }
                } else {
                    setTimeout(() => this.init(), 1000);
                }
            } else {
                setTimeout(() => this.init(), 1000);
            }
        }

        setupObserver() {
            const observer = new MutationObserver((mutations) => {
                if (!this.isInitialized) {
                    for (let mutation of mutations) {
                        if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
                            this.init();
                            break;
                        }
                    }
                }
            });
            observer.observe(document.body, { childList: true, subtree: true });
        }
    }

    if (window.location.hostname === 'trakt.tv') {
        if (window.location.pathname.startsWith('/shows/') || window.location.pathname.startsWith('/movies/')) {
            setTimeout(() => {
                const traktHandler = new TraktTvHandler();
                traktHandler.init();
                traktHandler.setupObserver();
            }, 1000);
        }
    }
})();