<!DOCTYPE html>
<html lang="es">

<head>
    <meta charset="UTF-8">
    <title>Eventos Deportivos Movistar Plus</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }

        table {
            width: 100%;
            border-collapse: collapse;
            margin-bottom: 20px;
        }

        th,
        td {
            border: 1px solid #ddd;
            padding: 8px;
            text-align: left;
        }

        th {
            background-color: #f2f2f2;
            font-weight: bold;
        }

        .table-title {
            font-size: 1.2em;
            font-weight: bold;
            margin-top: 20px;
        }

        #loading,
        #error {
            text-align: center;
            padding: 20px;
        }

        #loading {
            color: #888;
        }

        #error {
            color: red;
        }

        .button-container {
            margin-bottom: 20px;
            display: flex;
            flex-wrap: wrap;
            gap: 10px;
        }

        button {
            padding: 5px 10px;
        }
    </style>
</head>

<body>
    <h1>Eventos Deportivos Movistar Plus</h1>
    <h2>by TokyoGhoull</h2>
    <div class="button-container" id="sorting-buttons"></div>
    <div id="loading">Cargando eventos...</div>
    <div id="error"></div>
    <div id="events-container"></div>

    <script>
        let globalEvents = {};
        let availableCategories = new Set();
        let validLinks = [];
        const acestreamUrls = [
            "https://api.codetabs.com/v1/proxy/?quest=http://ipfs.io/ipns/elcano.top",
            "https://ipfs.io/ipns/k51qzi5uqu5dgg9al11vomikugim0o1i3l3fxp3ym3jwaswmy9uz8pq4brg1u9",
        ];
        //             "https://s3.us.archive.org/abcd_20240416/Index.html"
        const equivalenciasCanales = {
            "Teledeporte (Dial 75)": ["tdp 1080"],
            "Eurosport 1 (Dial 72)": ["EuroSport 1 1080"],
            "Eurosport 2 (Dial 73)": ["EuroSport 2 1080"],

            "M+ Ellas V (Dial 66)": ["#Ellas 1080"],

            "M+ Deportes (Dial 63)": ["M. Deportes 1080", "M. Deportes 720"],
            "M+ Deportes 2 (Dial 64)": ["M. Deportes 2 1080", "M. Deportes 2 720"],
            "M+ Deportes 3 (Dial 65)": ["M. Deportes 3 1080", "M. Deportes 3 720"],
            "M+ Deportes 4 (Dial 191)": ["M. Deportes 4 1080", "M. Deportes 4 720"],
            "M+ Deportes 5 (Dial 192)": ["M. Deportes 5 1080", "M. Deportes 5 720"],
            "M+ Deportes 6 (Dial 193)": ["M. Deportes 6 1080", "M. Deportes 6 720"],
            "M+ Deportes 7 (Dial 194)": ["M. Deportes 7 1080", "M. Deportes 7 720"],

            "M+ Liga de Campeones (Dial 60)": ["M.L. Campeones 1080", "M.L. Campeones 720", "M.L. Campeones 1080 MultiAudio"],
            "M+ Liga de Campeones 2 (Dial 61)": ["M.L. Campeones 2 SD", "M.L. Campeones 2 1080", "M.L. Campeones 2 720"],
            "M+ Liga de Campeones 3 (Dial 62)": ["M.L. Campeones 3 1080"],
            "M+ Liga de Campeones 4 (Dial 180)": ["M.L. Campeones 4 SD", "M.L. Campeones 4 1080", "M.L. Campeones 4 720"],
            "M+ Liga de Campeones 5 (Dial 181)": ["M.L. Campeones 5 SD", "M.L. Campeones 5 1080", "M.L. Campeones 5 720"],
            "M+ Liga de Campeones 6 (Dial 182)": ["M.L. Campeones 6 SD", "M.L. Campeones 6 1080", "M.L. Campeones 6 720"],
            "M+ Liga de Campeones 7 (Dial 183)": ["M.L. Campeones 7 SD", "M.L. Campeones 7 1080", "M.L. Campeones 7 720"],
            "M+ Liga de Campeones 8 (Dial 184)": ["M.L. Campeones 8 SD", "M.L. Campeones 8 1080", "M.L. Campeones 8 720"],
            "M+ Liga de Campeones 9 (Dial 185)": ["M.L. Campeones 9 SD", "M.L. Campeones 9 1080", "M.L. Campeones 9 720"],
            "M+ Liga de Campeones 10 (Dial 186)": ["M.L. Campeones 10 SD", "M.L. Campeones 10 1080", "M.L. Campeones 10 720"],
            "M+ Liga de Campeones 11 (Dial 187)": ["M.L. Campeones 11 SD", "M.L. Campeones 11 1080", "M.L. Campeones 11 720"],
            "M+ Liga de Campeones 12 (Dial 188)": ["M.L. Campeones 12 SD", "M.L. Campeones 12 1080", "M.L. Campeones 12 720"],
            "M+ Liga de Campeones 13 (Dial 189)": ["M.L. Campeones 13 SD", "M.L. Campeones 13 1080", "M.L. Campeones 13 720"],
            "M+ Liga de Campeones 14 (Dial 169)": ["M.L. Campeones 14 SD", "M.L. Campeones 14 1080", "M.L. Campeones 14 720"],
            "M+ Liga de Campeones 15 (Dial 170)": ["M.L. Campeones 15 SD", "M.L. Campeones 15 1080", "M.L. Campeones 15 720"],
            "M+ Liga de Campeones 16 (Dial 171)": ["M.L. Campeones 16 SD", "M.L. Campeones 16 1080", "M.L. Campeones 16 720"],
            "M+ Liga de Campeones 17 (Dial 172)": ["M.L. Campeones 17 SD", "M.L. Campeones 17 1080", "M.L. Campeones 17 720"],
            "M+ Liga de Campeones 18 (Dial 173)": ["M.L. Campeones 18 SD", "M.L. Campeones 18 1080", "M.L. Campeones 18 720"],
            "M+ Liga de Campeones 19 (Dial 174)": ["M.L. Campeones 19 SD", "M.L. Campeones 19 1080", "M.L. Campeones 19 720"],

            "M+ Golf (Dial 67)": ["M. Golf 1080", "M. Golf 720"],
            "M+ Golf 2 (Dial 68)": ["M. Golf2 1080", "M. Golf2 720"]


        };

        async function fetchAceStreamLinks() {
            const fetchPromises = acestreamUrls.map(async (url) => {
                try {
                    const response = await fetch(url);
                    const htmlText = await response.text();

                    // Extract links from the HTML using the linksData object
                    const parser = new DOMParser();
                    const doc = parser.parseFromString(htmlText, 'text/html');

                    // If the page contains linksData directly in the script
                    const scriptTags = doc.getElementsByTagName('script');
                    for (let script of scriptTags) {
                        const match = script.textContent.match(/const\s+linksData\s*=\s*(\{.*?\});/s);
                        if (match) {
                            try {
                                const parsedData = JSON.parse(match[1]);
                                return parsedData.links.filter(link =>
                                    link.url &&
                                    link.url.includes('acestream://') &&
                                    link.url.replace('acestream://', '').trim() !== ''
                                );
                            } catch (parseError) {
                                console.error('Error parsing links:', parseError);
                            }
                        }
                    }

                    return [];
                } catch (error) {
                    console.error(`Error fetching from ${url}:`, error);
                    return [];
                }
            });

            const allLinks = (await Promise.all(fetchPromises)).flat();
            validLinks = Array.from(new Set(allLinks.map(JSON.stringify))).map(JSON.parse);
        }

        function getAceStreamLink(channelName) {
            // Primero buscar si el canal está en las equivalencias
            for (const [mainChannel, aliases] of Object.entries(equivalenciasCanales)) {
                if (mainChannel === channelName) {
                    // Buscar el primer enlace válido para cualquiera de los alias
                    for (const alias of aliases) {
                        const normalizedAlias = alias.toLowerCase().trim();
                        const matchingLink = validLinks.find(link =>
                            link.name.toLowerCase().trim() === normalizedAlias
                        );
                        if (matchingLink) {
                            return {
                                displayName: mainChannel,
                                streamLink: matchingLink.url
                            };
                        }
                    }

                }
            }

            // Si no se encontró en equivalencias, buscar en validLinks directamente
            const directMatch = validLinks.find(link =>
                link.name.toLowerCase().trim() === channelName.toLowerCase().trim()
            );

            return directMatch
                ? { displayName: directMatch.name, streamLink: directMatch.url }
                : { displayName: channelName, streamLink: null };
        }

        // Diccionario de iconos en base64 (SVG)
        const CATEGORY_ICONS = {
            'Deportes': 'data:file/octet-stream;base64,UklGRkoCAABXRUJQVlA4WAoAAAAQAAAAHwAAHwAAQUxQSMIAAAABgLtt2/HlzrZte/v92u3aO9rs2uzJ3Gz3P9iTbWOzn/QprhExAfiH2kbnRYuUeVOLGrojItoqseXFMGODmC+L5Tmp5J0S+wkrDuFLxHnHno3+APG5rs3gGT9J/PZCQgJwansh3r0Ao/IbErBRJv2UBB1UOSNh61ApzJYVvAQ5MgVkpoXoAIBIIcQfFNb5S8WniWxGx/YeGF5mI/C50hxTFqBiIw6MTE+LDXKVALPvJzf1IvDeRXRR6wABPWYKjfBXB1ZQOCBiAQAAcAcAnQEqIAAgAD6RQpxKJaOioagIALASCWwAtvdengbJ45XUJuAAPoDk5VLjP23RrOZ0MLDjmAtAYw/LrxeizHf5AAAA/vsIaBgeOkUIOgZF7gvj3YG/vgNBLSvoVtZGNm//LgB2lOwV3FrmdSx0c2cvnt7sv/9f64sS7Qch1PeaKDx5SaMf3E/VlCqbe1Pv+GWu5hy0wQD3om9O+X55BLS7KstRCooFJdZpBGgNByHveZXVApo25/mvOj9rb65QcZ6PS2rghNhgh2xFGrzOfEijqF/apUVHgKNh+Z0u90x59oXXgdw5b1TSDRerumXUrVA9ue7OM9ojeX0Q0MCfsFEuwbSS/sZrbHJVheas/+Rc9mJRgAi+6gibr38/Hx3RVx8WC+uqbQRX+FvyS61Uix6f66jC4iIp/Kz6F/20lJiiTX+OZgS10jiz/f9MhkBPCmBhppJg7csrQVRPnx8CAAAA',
            'Motor': 'https://static.futbolenlatv.com/img/32/20130624110336-automovilismo.webp',
            'Boxeo': 'https://static.futbolenlatv.com/img/32/20130624110538-boxeo.webp',
            'Balonmano': 'https://static.futbolenlatv.com/img/32/20130724090914-balonmano.webp',
            'Pádel': 'https://static.futbolenlatv.com/img/32/20141020014848-padel.webp',
            'Rugby': 'https://static.futbolenlatv.com/img/32/20200729125932-rugby.webp',
            'Tenis': 'https://static.futbolenlatv.com/img/32/20130618113307-tenis.webp',
            'Futbol (F)': 'https://static.futbolenlatv.com/img/32/20130618113222-futbol.webp',
            'Futbol': 'https://static.futbolenlatv.com/img/32/20130618113222-futbol.webp',
            'Baloncesto (F)': 'https://static.futbolenlatv.com/img/32/20130618113234-baloncesto.webp',
            'Baloncesto': 'https://static.futbolenlatv.com/img/32/20130618113234-baloncesto.webp',
            'Fórmula 1': 'https://static.futbolenlatv.com/img/32/20130624110336-automovilismo.webp',
            'Golf': 'https://static.futbolenlatv.com/img/32/20130724083030-bola-golf.webp',
            'MotoGP': 'https://static.futbolenlatv.com/img/32/20130629041459-motociclismo.webp',
            'Ciclismo': 'https://static.futbolenlatv.com/img/32/20130627010504-ciclismo.webp',
            'Esquí alpino': 'https://img.icons8.com/?size=50&id=920&format=png',
            'Saltos de esquí': 'https://img.icons8.com/?size=50&id=920&format=png',
            'Fútbol americano': 'https://static.futbolenlatv.com/img/32/20200804171715-futbol-americano.webp',
            'Fútbol español': 'https://static.futbolenlatv.com/img/32/20130618113222-futbol.webp',
            'Fútbol internacional': 'https://static.futbolenlatv.com/img/32/20130618113222-futbol.webp',
            'Hockey patines': 'https://static.futbolenlatv.com/img/32/20130627053939-hockey.webp',
            'Hípica': 'https://img.icons8.com/?size=80&id=y0EggFIvINd8&format=png',
            'Deportes de Invierno': 'https://img.icons8.com/?size=24&id=Jov6eidVetmo&format=png',
            'Snooker': 'https://img.icons8.com/?size=80&id=dnqVn3gVjD00&format=png',
            // Mantener el default en base64 ya que es el icono de respaldo
            'default': 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCI+PHBhdGggZmlsbD0iI2ZmZiIgZD0iTTEyIDJDNi40OCAyIDIgNi40OCAyIDEyczQuNDggMTAgMTAgMTAgMTAtNC40OCAxMC0xMFMxNy41MiAyIDEyIDJ6bTEgMTVoLTJ2LTZoMnY2em0wLThoLTJWN2gydjJ6Ii8+PC9zdmc+'
        };

        function getCurrentSystemDate() {
            const days = ['domingo', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado'];
            const months = ['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre'];

            const today = new Date();
            const dayName = days[today.getDay()];
            const monthName = months[today.getMonth()];

            return `${dayName} ${today.getDate()} de ${monthName} de ${today.getFullYear()}`;
        }

        // Primero, añadimos una variable global para almacenar el orden original de las fechas
        let originalDateOrder = [];

        function parseEvents(htmlContent) {
            const parser = new DOMParser();
            const doc = parser.parseFromString(htmlContent, 'text/html');
            const eventsByDate = {};
            originalDateOrder = []; // Reiniciamos el array

            console.log('Starting to parse HTML content');

            const dateSections = doc.querySelectorAll('.fecha-bar');
            console.log(`Found ${dateSections.length} date sections`);

            dateSections.forEach((dateSection, dateIndex) => {
                const currentDate = dateSection.textContent.trim();
                console.log(`\nProcessing date section ${dateIndex + 1}:`, currentDate);

                // Guardamos el orden original de las fechas
                originalDateOrder.push(currentDate);
                eventsByDate[currentDate] = [];

                const parentSection = dateSection.closest('.brick.info-bares');
                const categorySections = parentSection.querySelectorAll('.content-bares > li');
                console.log(`Found ${categorySections.length} category sections for ${currentDate}`);

                categorySections.forEach((section, categoryIndex) => {
                    if (section.querySelector('.fecha-bar')) {
                        console.log('Skipping nested date section');
                        return;
                    }

                    const categoryElement = section.querySelector('.box-medium');
                    const category = categoryElement?.textContent?.trim() || 'Categoría Desconocida';
                    console.log(`\nProcessing category ${categoryIndex + 1}:`, category);

                    availableCategories.add(category);

                    const eventListItems = section.querySelectorAll('li');
                    console.log(`Found ${eventListItems.length} events in category ${category}`);

                    eventListItems.forEach((eventItem, eventIndex) => {
                        const eventLink = eventItem.querySelector('a');
                        const timeBar = eventItem.querySelector('.time-bar');

                        if (eventLink && timeBar) {
                            const canal = timeBar.childNodes[0].textContent.trim();
                            const evento = eventLink.textContent.trim();
                            const hora = timeBar.querySelector('span')?.textContent?.trim() || 'Hora no especificada';

                            console.log(`\nEvent ${eventIndex + 1}:`);
                            console.log('- Evento:', evento);
                            console.log('- Canal:', canal);
                            console.log('- Canal length:', canal.length);
                            console.log('- Canal hex:', [...canal].map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join(' '));
                            console.log('- Hora:', hora);

                            // Verificar si el canal está en las equivalencias
                            const canalEnEquivalencias = Object.keys(equivalenciasCanales).includes(canal);
                            console.log('- ¿Canal en equivalencias?:', canalEnEquivalencias);

                            if (canalEnEquivalencias) {
                                console.log('- Alias disponibles:', equivalenciasCanales[canal]);
                                const tieneEnlaces = equivalenciasCanales[canal].some(alias => {
                                    return validLinks.some(link =>
                                        link.name.toLowerCase().trim() === alias.toLowerCase().trim()
                                    );
                                });
                                console.log('- ¿Tiene enlaces acestream?:', tieneEnlaces);
                            }

                            eventsByDate[currentDate].push({
                                fecha: currentDate,
                                categoria: category,
                                evento: evento,
                                canal: canal,
                                hora: hora
                            });

                            console.log('Event successfully added to eventsByDate');
                        } else {
                            if (!eventLink) console.log('Warning: No event link found');
                            if (!timeBar) console.log('Warning: No time bar found');
                        }
                    });
                });
            });

            console.log('\nFinal parsing results:');
            console.log('- Total dates:', originalDateOrder.length);
            console.log('- Total categories:', availableCategories.size);
            console.log('- Events by date:', Object.entries(eventsByDate).map(([date, events]) =>
                `${date}: ${events.length} events`
            ).join(', '));

            return eventsByDate;
        }

        function getCategoryIcon(category) {
            return CATEGORY_ICONS[category] || CATEGORY_ICONS['default'];
        }

        function createSortingButtons(categories) {
            const buttonContainer = document.getElementById('sorting-buttons');
            buttonContainer.innerHTML = '';

            const originalButton = document.createElement('button');
            originalButton.textContent = 'Original';
            originalButton.onclick = () => renderEventsByDate();
            buttonContainer.appendChild(originalButton);

            const timeButton = document.createElement('button');
            timeButton.textContent = 'Hora';
            timeButton.onclick = () => renderEventsByTime();
            buttonContainer.appendChild(timeButton);

            const eventButton = document.createElement('button');
            eventButton.textContent = 'Evento';
            eventButton.onclick = () => renderEventsByEvent();
            buttonContainer.appendChild(eventButton);

            const channelButton = document.createElement('button');
            channelButton.textContent = 'Canal';
            channelButton.onclick = () => renderEventsByChannel();
            buttonContainer.appendChild(channelButton);

            categories.forEach(category => {
                const categoryButton = document.createElement('button');
                categoryButton.textContent = `${category}`;
                categoryButton.onclick = () => renderEventsBySpecificCategory(category);
                buttonContainer.appendChild(categoryButton);
            });
        }

        // Modificamos las funciones de renderizado para usar originalDateOrder
        // Ejemplo con renderEventsByTime:
        function renderEventsByTime() {
            const container = document.getElementById('events-container');
            container.innerHTML = '';

            // Usamos originalDateOrder en lugar de Object.keys(globalEvents).sort()
            originalDateOrder.forEach(date => {
                if (!globalEvents[date] || globalEvents[date].length === 0) return;

                const dateTitle = document.createElement('div');
                dateTitle.className = 'table-title';
                dateTitle.textContent = date;
                container.appendChild(dateTitle);

                const table = document.createElement('table');
                const thead = document.createElement('thead');
                thead.innerHTML = `
                <tr>
                        <th>Hora</th>
                        <th>Categoría</th>
                        <th>Evento</th>
                        <th>Canal</th>
                    </tr>
                `;
                table.appendChild(thead);

                const tbody = document.createElement('tbody');
                const sortedEvents = [...globalEvents[date]].sort((a, b) => {
                    const parseTime = (timeStr) => {
                        // Maneja casos donde timeStr es undefined o null
                        if (!timeStr) return 0;

                        // Normaliza el formato de la hora
                        let formattedTime = timeStr
                            .toLowerCase()
                            .replace('h', ':')
                            .replace('.', ':')
                            .trim();

                        // Si solo hay horas sin minutos, añade ":00"
                        if (!formattedTime.includes(':')) {
                            formattedTime += ':00';
                        }

                        // Extrae horas y minutos, con valor por defecto 0
                        const [hours = 0, minutes = 0] = formattedTime.split(':').map(num => {
                            const parsed = parseInt(num, 10);
                            return isNaN(parsed) ? 0 : parsed;
                        });

                        return hours * 60 + minutes;
                    };

                    return parseTime(a.hora) - parseTime(b.hora);
                });

                sortedEvents.forEach(event => {
                    const row = document.createElement('tr');
                    const iconUrl = getCategoryIcon(event.categoria);
                    row.innerHTML = `
                        <td>${event.hora}</td>
                        <td>
                            <div style="display: flex; align-items: center;">
                                <img src="${iconUrl}" alt="${event.categoria}" style="width: 24px; height: 24px; margin-right: 8px;">
                                ${event.categoria}
                            </div>
                        </td>
                        <td>${event.evento}</td>
                        <td>${getChannelDisplayWithLinks(event.canal)}</td>
                    `;
                    tbody.appendChild(row);
                });

                table.appendChild(tbody);
                container.appendChild(table);
            });
        }

        // De manera similar, debes modificar las otras funciones de renderizado 
        // (renderEventsByEvent, renderEventsByChannel, etc.) 
        // para usar originalDateOrder en lugar de Object.keys(globalEvents).sort()


        function getChannelDisplayWithLinks(channelName) {
            // Normalizar el nombre del canal eliminando espacios múltiples
            const normalizedChannelName = channelName.replace(/\s+/g, ' ').trim();

            // Añadir al debug info
            const debugInfo = document.getElementById('debug-info');
            if (debugInfo) {
                debugInfo.textContent += `\nProcessing channel: "${channelName}"\n`;
                debugInfo.textContent += `Normalized channel: "${normalizedChannelName}"\n`;
                debugInfo.textContent += `Channel name length: ${channelName.length}\n`;
                debugInfo.textContent += `Channel name hex: ${[...channelName].map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join(' ')}\n`;
            }

            // Buscar en las equivalencias usando el nombre normalizado
            for (const [mainChannel, aliases] of Object.entries(equivalenciasCanales)) {
                const normalizedMainChannel = mainChannel.replace(/\s+/g, ' ').trim();
                if (normalizedMainChannel === normalizedChannelName) {
                    if (debugInfo) {
                        debugInfo.textContent += `Match found in equivalencias: "${mainChannel}"\n`;
                        debugInfo.textContent += `Aliases: ${JSON.stringify(aliases)}\n`;
                    }

                    const validStreamLinks = aliases.map(alias => {
                        const normalizedAlias = alias.toLowerCase().trim();
                        const matchingLink = validLinks.find(link =>
                            link.name.toLowerCase().trim() === normalizedAlias
                        );

                        if (matchingLink) {
                            return `<a href="${matchingLink.url}" target="_blank">${alias}</a>`;
                        }
                        return null;
                    }).filter(link => link !== null);

                    if (validStreamLinks.length > 0) {
                        return validStreamLinks.join(' | ');
                    }
                }
            }

            // Búsqueda directa con nombre normalizado
            const directMatch = validLinks.find(link =>
                link.name.toLowerCase().trim() === normalizedChannelName.toLowerCase().trim()
            );

            if (debugInfo) {
                debugInfo.textContent += `Direct match result: ${directMatch ? directMatch.url : 'not found'}\n`;
            }

            return directMatch ?
                `<a href="${directMatch.url}" target="_blank">${directMatch.name}</a>` :
                channelName;
        }

        // Función principal que inicia el proceso
        async function fetchSportsEvents() {
            const debug = createDebugIframe();

            const proxyUrl = 'https://api.codetabs.com/v1/proxy/?quest=';
            const targetUrl = 'https://www.movistarplus.es/deportesendirectobar';

            try {
                debug.debugInfo.textContent += 'Fetching AceStream Links...\n';
                await fetchAceStreamLinks();
                debug.debugInfo.textContent += `Fetched ${validLinks.length} valid links\n`;

                // Actualizar información de canales
                debug.updateChannelsInfo();

                debug.debugInfo.textContent += '\nFetching Sports Events...\n';
                const response = await fetch(proxyUrl + targetUrl);
                const htmlContent = await response.text();

                globalEvents = parseEvents(htmlContent);
                debug.debugInfo.textContent += `Parsed ${Object.values(globalEvents).flat().length} events\n`;
                debug.debugInfo.textContent += 'Categories Found:\n';
                Array.from(availableCategories).forEach(category => {
                    debug.debugInfo.textContent += `- ${category}\n`;
                });

                createSortingButtons(Array.from(availableCategories));
                renderEventsByDate();

                document.getElementById('loading').style.display = 'none';
            } catch (error) {
                const errorDiv = document.getElementById('error');
                errorDiv.textContent = `Error: ${error.message}`;
                debug.debugInfo.textContent += `Full Error: ${error.stack}\n`;
                document.getElementById('loading').style.display = 'none';
            }
        }

        // Modificar todas las funciones de renderizado para usar getChannelDisplayWithLinks

        function renderEventsByDate() {
            const container = document.getElementById('events-container');
            container.innerHTML = '';

            originalDateOrder.forEach(date => {
                const events = globalEvents[date];
                if (!events || events.length === 0) return;

                const dateTitle = document.createElement('div');
                dateTitle.className = 'table-title';
                dateTitle.textContent = date;
                container.appendChild(dateTitle);

                const table = document.createElement('table');
                const thead = document.createElement('thead');
                thead.innerHTML = `
                    <tr>
                        <th>Hora</th>
                        <th>Categoría</th>
                        <th>Evento</th>
                        <th>Canal</th>
                    </tr>
                `;
                table.appendChild(thead);

                const tbody = document.createElement('tbody');
                events.forEach(event => {
                    const row = document.createElement('tr');
                    const iconUrl = getCategoryIcon(event.categoria);
                    row.innerHTML = `
                        <td>${event.hora}</td>
                        <td>
                            <div style="display: flex; align-items: center;">
                                <img src="${iconUrl}" alt="${event.categoria}" style="width: 24px; height: 24px; margin-right: 8px;">
                                ${event.categoria}
                            </div>
                        </td>
                        <td>${event.evento}</td>
                        <td>${getChannelDisplayWithLinks(event.canal)}</td>
                    `;
                    tbody.appendChild(row);
                });

                table.appendChild(tbody);
                container.appendChild(table);
            });
        }

        function renderEventsByGeneralCategory() {
            const container = document.getElementById('events-container');
            container.innerHTML = '';

            // Use originalDateOrder instead of sorting
            originalDateOrder.forEach(date => {
                const eventsOnDate = globalEvents[date];
                if (!eventsOnDate || eventsOnDate.length === 0) return;

                const dateTitle = document.createElement('div');
                dateTitle.className = 'table-title';
                dateTitle.textContent = date;
                container.appendChild(dateTitle);

                const table = document.createElement('table');
                const thead = document.createElement('thead');
                thead.innerHTML = `
                    <tr>
                        <th>Hora</th>
                        <th>Categoría</th>
                        <th>Evento</th>
                        <th>Canal</th>
                    </tr>
                `;
                table.appendChild(thead);

                const tbody = document.createElement('tbody');
                const sortedEvents = [...eventsOnDate].sort((a, b) => a.categoria.localeCompare(b.categoria));

                sortedEvents.forEach(event => {
                    const row = document.createElement('tr');
                    const iconUrl = getCategoryIcon(event.categoria);
                    row.innerHTML = `
                        <td>${event.hora}</td>
                        <td>
                            <div style="display: flex; align-items: center;">
                                <img src="${iconUrl}" alt="${event.categoria}" style="width: 24px; height: 24px; margin-right: 8px;">
                                ${event.categoria}
                            </div>
                        </td>
                        <td>${event.evento}</td>
                        <td>${getChannelDisplayWithLinks(event.canal)}</td>
                    `;
                    tbody.appendChild(row);
                });

                table.appendChild(tbody);
                container.appendChild(table);
            });
        }

        function renderEventsByEvent() {
            const container = document.getElementById('events-container');
            container.innerHTML = '';

            originalDateOrder.forEach(date => {
                const eventsOnDate = globalEvents[date];
                if (!eventsOnDate || eventsOnDate.length === 0) return;

                const dateTitle = document.createElement('div');
                dateTitle.className = 'table-title';
                dateTitle.textContent = date;
                container.appendChild(dateTitle);

                const table = document.createElement('table');
                const thead = document.createElement('thead');
                thead.innerHTML = `
                    <tr>
                        <th>Hora</th>
                        <th>Evento</th>
                        <th>Categoría</th>
                        <th>Canal</th>
                </tr>
                `;
                table.appendChild(thead);

                const tbody = document.createElement('tbody');
                const sortedEvents = [...Object.values(globalEvents).flat()]
                    .filter(event => event.fecha === date)
                    .sort((a, b) => a.evento.localeCompare(b.evento));

                sortedEvents.forEach(event => {
                    const row = document.createElement('tr');
                    const iconUrl = getCategoryIcon(event.categoria);
                    row.innerHTML = `
                        <td>${event.hora}</td>
                        <td>${event.evento}</td>
                        <td>
                            <div style="display: flex; align-items: center;">
                                <img src="${iconUrl}" alt="${event.categoria}" style="width: 24px; height: 24px; margin-right: 8px;">
                                ${event.categoria}
                            </div>
                        </td>
                        <td>${getChannelDisplayWithLinks(event.canal)}</td>
                    `;
                    tbody.appendChild(row);
                });

                table.appendChild(tbody);
                container.appendChild(table);
            });
        }

        function renderEventsByChannel() {
            const container = document.getElementById('events-container');
            container.innerHTML = '';

            originalDateOrder.forEach(date => {
                const eventsOnDate = globalEvents[date];
                if (!eventsOnDate || eventsOnDate.length === 0) return;

                const dateTitle = document.createElement('div');
                dateTitle.className = 'table-title';
                dateTitle.textContent = date;
                container.appendChild(dateTitle);

                const table = document.createElement('table');
                const thead = document.createElement('thead');
                thead.innerHTML = `
                    <tr>
                        <th>Hora</th>
                        <th>Canal</th>
                        <th>Evento</th>
                        <th>Categoría</th>
                    </tr>
                `;
                table.appendChild(thead);

                const tbody = document.createElement('tbody');
                const sortedEvents = [...eventsOnDate].sort((a, b) => a.canal.localeCompare(b.canal));

                sortedEvents.forEach(event => {
                    const row = document.createElement('tr');
                    const iconUrl = getCategoryIcon(event.categoria);
                    row.innerHTML = `
                        <td>${event.hora}</td>
                        <td>${getChannelDisplayWithLinks(event.canal)}</td>
                        <td>${event.evento}</td>
                        <td>
                            <div style="display: flex; align-items: center;">
                                <img src="${iconUrl}" alt="${event.categoria}" style="width: 24px; height: 24px; margin-right: 8px;">
                                ${event.categoria}
                            </div>
                        </td>
                    `;
                    tbody.appendChild(row);
                });

                table.appendChild(tbody);
                container.appendChild(table);
            });
        }

        function renderEventsBySpecificCategory(targetCategory) {
            const container = document.getElementById('events-container');
            container.innerHTML = '';

            originalDateOrder.forEach(date => {
                const eventsForCategory = globalEvents[date].filter(event => event.categoria === targetCategory);
                if (eventsForCategory.length === 0) return;

                const dateTitle = document.createElement('div');
                dateTitle.className = 'table-title';
                dateTitle.textContent = date;
                container.appendChild(dateTitle);

                const table = document.createElement('table');
                const thead = document.createElement('thead');
                thead.innerHTML = `
                    <tr>
                        <th>Hora</th>
                        <th>Evento</th>
                        <th>Canal</th>
                    </tr>
                `;
                table.appendChild(thead);

                const tbody = document.createElement('tbody');
                const sortedEvents = [...eventsForCategory].sort((a, b) => a.hora.localeCompare(b.hora));

                sortedEvents.forEach(event => {
                    const row = document.createElement('tr');
                    row.innerHTML = `
                        <td>${event.hora}</td>
                        <td>${event.evento}</td>
                        <td>${getChannelDisplayWithLinks(event.canal)}</td>
                    `;
                    tbody.appendChild(row);
                });

                table.appendChild(tbody);
                container.appendChild(table);
            });
        }

        // Debug container y getChannelDisplayWithLinks 
        function createDebugIframe() {
            const debugContainer = document.createElement('div');
            debugContainer.id = 'debug-container';
            debugContainer.style.marginTop = '20px';
            debugContainer.style.border = '2px solid red';
            debugContainer.style.padding = '10px';

            // Título principal
            const debugTitle = document.createElement('h3');
            debugTitle.textContent = 'Debug Information';
            debugContainer.appendChild(debugTitle);

            // Sección de información general
            const debugInfo = document.createElement('pre');
            debugInfo.id = 'debug-info';
            debugInfo.style.whiteSpace = 'pre-wrap';
            debugInfo.style.wordWrap = 'break-word';
            debugContainer.appendChild(debugInfo);

            // Sección de canales
            const channelsTitle = document.createElement('h4');
            channelsTitle.textContent = 'Canales Disponibles';
            debugContainer.appendChild(channelsTitle);

            const channelsInfo = document.createElement('pre');
            channelsInfo.id = 'channels-info';
            channelsInfo.style.whiteSpace = 'pre-wrap';
            channelsInfo.style.wordWrap = 'break-word';
            channelsInfo.style.maxHeight = '200px';
            channelsInfo.style.overflow = 'auto';
            channelsInfo.style.backgroundColor = '#f5f5f5';
            channelsInfo.style.padding = '10px';
            debugContainer.appendChild(channelsInfo);

            document.body.appendChild(debugContainer);

            // Definimos updateChannelsInfo como una constante
            const updateChannelsInfo = () => {
                const channelsInfo = document.getElementById('channels-info');
                if (channelsInfo) {
                    let content = 'Equivalencias de Canales:\n\n';
                    for (const [mainChannel, aliases] of Object.entries(equivalenciasCanales)) {
                        content += `${mainChannel} (length: ${mainChannel.length}, hex: ${[...mainChannel].map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join(' ')}):\n`;
                        aliases.forEach(alias => {
                            const matchingLinks = validLinks.filter(link => {
                                const normalizedAlias = alias.toLowerCase().trim();
                                const normalizedLinkName = link.name.toLowerCase().trim();
                                return normalizedLinkName === normalizedAlias;
                            });

                            content += `  - ${alias} (length: ${alias.length}, hex: ${[...alias].map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join(' ')})\n`;
                            if (matchingLinks.length > 0) {
                                matchingLinks.forEach(link => {
                                    content += `    → ${link.url} (link name: "${link.name}")\n`;
                                });
                            } else {
                                content += `    (sin enlace)\n`;
                            }
                        });
                        content += '\n';
                    }
                    channelsInfo.textContent = content;
                }
            };

            return {
                debugInfo: debugInfo,
                updateChannelsInfo: updateChannelsInfo
            };
        }

        // También necesitamos actualizar fetchSportsEvents para que no use el iframe
        async function fetchSportsEvents() {
            const debug = createDebugIframe();

            const proxyUrl = 'https://api.codetabs.com/v1/proxy/?quest=';
            const targetUrl = 'https://www.movistarplus.es/deportesendirectobar';

            try {
                debug.debugInfo.textContent += 'Fetching AceStream Links...\n';
                await fetchAceStreamLinks();
                debug.debugInfo.textContent += `Fetched ${validLinks.length} valid links\n`;

                // Actualizar información de canales
                debug.updateChannelsInfo();

                debug.debugInfo.textContent += '\nFetching Sports Events...\n';
                const response = await fetch(proxyUrl + targetUrl);
                const htmlContent = await response.text();

                globalEvents = parseEvents(htmlContent);
                debug.debugInfo.textContent += `Parsed ${Object.values(globalEvents).flat().length} events\n`;
                debug.debugInfo.textContent += 'Categories Found:\n';
                Array.from(availableCategories).forEach(category => {
                    debug.debugInfo.textContent += `- ${category}\n`;
                });

                createSortingButtons(Array.from(availableCategories));
                renderEventsByDate();

                document.getElementById('loading').style.display = 'none';
            } catch (error) {
                const errorDiv = document.getElementById('error');
                errorDiv.textContent = `Error: ${error.message}`;
                debug.debugInfo.textContent += `Full Error: ${error.stack}\n`;
                document.getElementById('loading').style.display = 'none';
            }
        }

        document.addEventListener('DOMContentLoaded', fetchSportsEvents);
    </script>