// ------------------------------------------------------------------------------
//                        PELICULAS CON SCRAPING INTEGRADO MULTI-PÁGINA                                    
// ------------------------------------------------------------------------------

// 🔹 Variables globales
let Peliculas = new Map(); // Se llenará con el scraping
let canalesPorLote = 20; // Cantidad de botones a cargar por lote inicial
let indiceActual = 0;    // Índice del último canal cargado
let categoriasAgregadas = new Set(); // Para almacenar categorías únicas
let categSeleccionada = "Todas las peliculas";
let listaCreada = false;
let canalesArray = []; // Se llenará después del scraping

// 🔹 CONFIGURACIÓN DE PÁGINAS - Cambia esto para obtener más películas
const PAGINAS_A_BUSCAR = 10; // Cambia este número para buscar más o menos páginas
const URL_BASE = "https://pelisplushd.bz/peliculas?page="; // URL base para las páginas
// const URL_BASE = "https://pelisplushd.bz/peliculas/populares?page="; // URL base para las páginas

const zonaBotones = document.getElementById('id_PeliculasDisponibles');

// 🔹 Variables para el control de carga progresiva
let cargaEnProceso = false;
let totalPeliculasEncontradas = 0;
let paginasTerminadas = 0;

// 🔹 Función para mostrar mensaje de carga con progreso
function mostrarCargando(pagina = null, total = null, encontradas = 0) {
    let mensaje = document.getElementById('id_mensaje');
    if (!mensaje) {
        mensaje = document.createElement('div');
        mensaje.id = 'id_mensaje';
        mensaje.className = 'text-center text-light p-3';
        zonaBotones.parentNode.insertBefore(mensaje, zonaBotones);
    }

    if (pagina && total) {
        mensaje.innerHTML = `Cargando películas... Página ${pagina} de ${total} | ${encontradas} películas encontradas`;
    } else {
        mensaje.innerHTML = 'Cargando películas...';
    }

    mensaje.classList.remove("d-none");
    mensaje.className = 'opacity-100 text-light text-center p-3';
}

// 🔹 Función para actualizar mensaje con progreso final
function actualizarMensajeFinal() {
    let mensaje = document.getElementById('id_mensaje');
    if (mensaje) {
        mensaje.innerHTML = `✅ Carga completa: ${totalPeliculasEncontradas} películas de ${PAGINAS_A_BUSCAR} páginas`;
        setTimeout(() => {
            mensaje.className = 'opacity-75 text-light text-center p-3';
        }, 2000);
        setTimeout(() => {
            mensaje.className = 'opacity-50 text-light text-center p-3';
        }, 3000);
        setTimeout(() => {
            mensaje.className = 'opacity-25 text-light text-center p-3';
        }, 4000);
        setTimeout(() => {
            mensaje.className = 'opacity-0 d-none text-light text-center p-3';
        }, 5000);
    }
}

// 🔹 Función para obtener películas de una página específica
async function obtenerPeliculasPagina(numeroPagina) {
    const url = `https://corsproxy.io/?${URL_BASE}${numeroPagina}`;

    try {
        const res = await fetch(url);
        const html = await res.text();

        const parser = new DOMParser();
        const doc = parser.parseFromString(html, "text/html");

        let peliculasPagina = new Map();
        let contador = 0;

        doc.querySelectorAll("#default-tab-1 a.Posters-link").forEach((a) => {
            const link = a.getAttribute("href") || "";
            const img = a.querySelector("img")?.getAttribute("src") || "";
            const titulo = a.querySelector(".listing-content p")?.innerText.trim() || "";
            const valoracionElement = a.querySelector(".stars span");
            const valoracion = valoracionElement ? valoracionElement.innerText.trim() : "⭐ N/A";

            // Solo agregar si tenemos título válido y no existe ya
            if (titulo && titulo.trim() !== "" && !peliculasPagina.has(titulo)) {
                const peliculaData = {
                    titulo: titulo,
                    imagen: img,
                    valoracion: valoracion.replace(/[^\d.,]/g, '') || "N/A",
                    categoria: "Películas Web",
                    link: link,
                    enlacesReproduccion: null,
                    servidoresCargados: false,
                    pagina: numeroPagina // 🔹 Agregamos de qué página viene
                };

                peliculasPagina.set(titulo, peliculaData);
                contador++;

                // Agregar categoría al set
                if (!categoriasAgregadas.has(peliculaData.categoria)) {
                    categoriasAgregadas.add(peliculaData.categoria);
                }
            }
        });

        console.log(`✅ Página ${numeroPagina}: ${contador} películas encontradas`);
        return peliculasPagina;

    } catch (error) {
        console.error(`❌ Error al obtener películas de la página ${numeroPagina}:`, error);
        return new Map();
    }
}

// 🔹 Función para agregar películas nuevas al DOM inmediatamente
function agregarPeliculasAlDOM(peliculasNuevas) {
    if (peliculasNuevas.size === 0) return;

    let htmlBotones = "";
    let botonesAgregados = 0;

    // Convertir las películas nuevas a HTML
    peliculasNuevas.forEach((datos, titulo) => {
        if (categSeleccionada === datos.categoria || categSeleccionada === "Todas las peliculas") {
            htmlBotones += CrearBoton(titulo, datos);
            botonesAgregados++;
        }
    });

    // Agregar al DOM inmediatamente
    if (htmlBotones) {
        zonaBotones.innerHTML += htmlBotones;
        console.log(`🎬 ${botonesAgregados} películas agregadas al DOM inmediatamente`);

        // Aplicar animaciones a los nuevos elementos
        mostrarScroll();
    }
}

// 🔹 Función para procesar una página y mostrar resultados inmediatamente
async function procesarPaginaInmediata(numeroPagina) {
    try {
        // Obtener películas de la página
        const peliculasPagina = await obtenerPeliculasPagina(numeroPagina);

        if (peliculasPagina.size > 0) {
            // Filtrar películas que no estén ya en el Map principal
            const peliculasNuevas = new Map();

            peliculasPagina.forEach((datos, titulo) => {
                if (!Peliculas.has(titulo)) {
                    Peliculas.set(titulo, datos);
                    peliculasNuevas.set(titulo, datos);
                    totalPeliculasEncontradas++;
                }
            });

            // Actualizar canalesArray con las nuevas películas
            const nuevosCanales = Array.from(peliculasNuevas.entries());
            canalesArray = canalesArray.concat(nuevosCanales);

            // Mostrar las películas nuevas inmediatamente en el DOM
            if (peliculasNuevas.size > 0) {
                agregarPeliculasAlDOM(peliculasNuevas);
            }

            console.log(`📄 Página ${numeroPagina}: ${peliculasNuevas.size} nuevas películas agregadas`);
        }

        return peliculasPagina.size;

    } catch (error) {
        console.error(`❌ Error procesando página ${numeroPagina}:`, error);
        return 0;
    }
}

// 🔹 Scraping progresivo de películas
async function obtenerPeliculasProgresivo() {
    try {
        cargaEnProceso = true;
        totalPeliculasEncontradas = 0;
        paginasTerminadas = 0;

        // Limpiar contenedor inicialmente
        zonaBotones.innerHTML = "";

        console.log(`🚀 Iniciando búsqueda progresiva en ${PAGINAS_A_BUSCAR} páginas...`);

        // Procesar páginas de forma secuencial pero mostrando resultados inmediatamente
        for (let pagina = 1; pagina <= PAGINAS_A_BUSCAR; pagina++) {
            // Actualizar mensaje de progreso
            mostrarCargando(pagina, PAGINAS_A_BUSCAR, totalPeliculasEncontradas);

            // Procesar la página y mostrar resultados inmediatamente
            await procesarPaginaInmediata(pagina);

            paginasTerminadas++;

            // Pequeña pausa entre páginas para evitar sobrecargar el servidor
            await new Promise(resolve => setTimeout(resolve, 300));
        }

        // Mostrar mensaje final
        console.log(`📊 CARGA COMPLETADA:`);
        console.log(`   • Total de películas únicas: ${totalPeliculasEncontradas}`);
        console.log(`   • Páginas procesadas: ${paginasTerminadas}/${PAGINAS_A_BUSCAR}`);

        actualizarMensajeFinal();
        cargaEnProceso = false;

        // Configurar scroll infinito si es necesario (aunque ya se muestran todas)
        if (canalesArray.length > 0) {
            indiceActual = canalesArray.length; // Marcar todas como mostradas
        }

        return Peliculas;

    } catch (error) {
        console.error("❌ Error general en carga progresiva:", error);
        actualizarMensajeFinal();
        cargaEnProceso = false;
        return new Map();
    }
}

// 🔹 Función para crear cada botón de película (adaptada)
function CrearBoton(pelicula, datos) {
    return `<button type="button" title="${datos.titulo}" 
                        class="card btn border m-2 p-2 bg-dark bg-gradient col-5 col-md-3 col-lg-2 class_CanalBoton encontrado" 
                        onclick="Cambiar_Canal(this)"> 
                    <section class="card-body text-light col-12 text-center">
                        <h4 class="card-title">${datos.titulo}</h4> 
                    </section>
                    <figure class="h-100 d-flex align-items-center">
                        <img class="card-img-top w-100 h-100" src="${datos.imagen}" loading="lazy" alt="${datos.titulo}" 
                             onerror="this.src='https://via.placeholder.com/300x450/333/fff?text=Sin+Imagen'"> 
                    </figure>
                    <div class="d-flex flex-column text-center">
                        <h6 class="card-title text-light opacity-75 mb-1">⭐${datos.valoracion}</h6>
                        <small class="text-muted opacity-50">Pág.${datos.pagina}</small>
                    </div>
                </button>`;
}



// 🔹 Función para cargar un lote de películas (simplificada ya que se cargan progresivamente)
function CrearCanalesLote() {
    // Ya no es necesaria esta función compleja porque las películas se muestran inmediatamente
    // Pero la mantenemos por compatibilidad
    console.log('📦 Todas las películas ya están cargadas progresivamente');
}

// 🔹 Función para detectar scroll (simplificada)
function detectarScroll() {
    // Ya no necesitamos scroll infinito complejo porque las películas se cargan progresivamente
    // Pero mantenemos mostrarScroll para las animaciones
    mostrarScroll();
}

// 🔹 Inicializar la carga progresiva de películas
async function IniciarCargaCanales() {
    try {
        console.log(`🎬 Configuración actual: Buscando progresivamente en ${PAGINAS_A_BUSCAR} páginas`);

        // Inicializar variables
        Peliculas = new Map();
        canalesArray = [];
        indiceActual = 0;
        totalPeliculasEncontradas = 0;
        paginasTerminadas = 0;

        // Obtener películas de forma progresiva (se muestran inmediatamente)
        await obtenerPeliculasProgresivo();

        if (Peliculas.size === 0) {
            zonaBotones.innerHTML = '<div class="text-center text-warning p-3">No se pudieron cargar las películas.</div>';
            return;
        }

        // Agregar listener para animaciones de scroll
        window.addEventListener('scroll', detectarScroll);

        console.log(`✅ Carga progresiva completada: ${Peliculas.size} películas mostradas en tiempo real`);

    } catch (error) {
        console.error("Error al inicializar la carga progresiva:", error);
        zonaBotones.innerHTML = '<div class="text-center text-danger p-3">Error al inicializar la aplicación.</div>';
    }
}

// 🔹 Función mostrarScroll (mantener original)
function mostrarScroll() {
    let animado = document.querySelectorAll(".class_CanalBoton");
    let scrollTop = document.documentElement.scrollTop;
    for (let i = 0; i < animado.length; i++) {
        if (animado[i].offsetTop - 700 < scrollTop) {
            animado[i].style.opacity = 1;
            animado[i].classList.add("mostrarHaciaArriba");
        } else {
            animado[i].style.opacity = 0;
            animado[i].classList.remove("mostrarHaciaArriba");
        }
    }
}

// 🔹 Variables para el reproductor (mantener originales)
let tele = document.getElementById("id_PantallaTV");
let canal = "";
let opt = 1;

// 🔹 Cargar CryptoJS library si no está disponible
function loadCryptoJS() {
    return new Promise((resolve, reject) => {
        if (window.CryptoJS) {
            resolve();
            return;
        }

        const script = document.createElement('script');
        script.src = 'https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js';
        script.onload = () => resolve();
        script.onerror = () => reject(new Error('Error cargando CryptoJS'));
        document.head.appendChild(script);
    });
}

// 🔹 Función de desencriptación usando CryptoJS (versión correcta)
function decryptLink(encryptedLinkBase64, secretKey) {
    try {
        console.log(`🔐 Desencriptando con CryptoJS: ${encryptedLinkBase64.substring(0, 50)}...`);

        if (!window.CryptoJS) {
            console.error('❌ CryptoJS no está cargado');
            return null;
        }

        // Parsear los datos encriptados desde Base64
        const encryptedData = CryptoJS.enc.Base64.parse(encryptedLinkBase64);

        // Los primeros 4 words (16 bytes) son el IV
        const iv = CryptoJS.lib.WordArray.create(encryptedData.words.slice(0, 4));

        // El resto son los datos encriptados
        const encryptedBytes = CryptoJS.lib.WordArray.create(encryptedData.words.slice(4));

        console.log('📊 IV extraído:', iv.toString());
        console.log('📊 Datos encriptados extraídos');

        // Desencriptar usando AES-CBC
        const decrypted = CryptoJS.AES.decrypt(
            { ciphertext: encryptedBytes },
            CryptoJS.enc.Utf8.parse(secretKey),
            {
                iv: iv,
                mode: CryptoJS.mode.CBC,
                padding: CryptoJS.pad.Pkcs7
            }
        );

        // Convertir a string UTF-8
        const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);

        console.log(`✅ Desencriptado exitosamente: ${decryptedStr}`);
        return decryptedStr;

    } catch (error) {
        console.error('❌ Error al descifrar:', error);
        return null;
    }
}

// 🔹 Función para obtener servidores (actualizada con CryptoJS)
async function obtenerServidoresPelicula(linkPelicula) {
    try {
        console.log(`🔍 Buscando servidores para: ${linkPelicula}`);

        // Paso 1: Obtener el HTML de la página de la película
        const urlPelicula = `https://corsproxy.io/?${linkPelicula}`;
        const resPelicula = await fetch(urlPelicula);
        const htmlPelicula = await resPelicula.text();
        const parserPelicula = new DOMParser();
        const docPelicula = parserPelicula.parseFromString(htmlPelicula, "text/html");

        // Paso 2: Extraer el iframe del div#video-content
        const videoContent = docPelicula.querySelector('#video-content iframe');
        if (!videoContent) {
            console.log("❌ No se encontró iframe en video-content");
            return { "Error": "No se encontró reproductor" };
        }

            const iframeSrc = videoContent.getAttribute('src');
        console.log(`🎬 Iframe encontrado: ${iframeSrc}`);

        // Paso 3: Obtener el contenido del iframe
        const urlIframe = `https://corsproxy.io/?${iframeSrc}`;
        const resIframe = await fetch(urlIframe);
        const htmlIframe = await resIframe.text();

        // Paso 4: Buscar el array dataLink en el HTML
        const dataLinkMatch = htmlIframe.match(/(?:let|const)\s+dataLink\s*=\s*(\[[\s\S]*?\]);/);
        if (!dataLinkMatch) {
            console.log("❌ No se encontró dataLink en el iframe");
            return { "Error": "No se encontraron servidores" };
        }

        let dataLink;
        try {
            dataLink = JSON.parse(dataLinkMatch[1]);
            console.log("✅ DataLink parseado correctamente");
        } catch (e) {
            console.error("❌ Error al parsear dataLink:", e);
            return { "Error": "Formato inválido en dataLink" };
        }

        // Paso 5: Procesar los servidores
        const servidores = {};

        dataLink.forEach(entry => {
            const idioma = entry.video_language;
            servidores[idioma] = [];

            entry.sortedEmbeds.forEach(embed => {
                try {
                    // Tomar la parte del medio del JWT
                    const token = embed.link.split(".")[1];
                    const decoded = JSON.parse(atob(token));

                    if (decoded.link) {
                        servidores[idioma].push({
                            servidor: embed.servername,
                            url: decoded.link
                        });
                    }
                } catch (err) {
                    console.warn("⚠️ No se pudo decodificar un link:", embed.link, err);
                }
            });
        });

        console.log(`✅ ${Object.keys(servidores).length} idiomas encontrados:`, servidores);
        return servidores;

    } catch (error) {
        console.error("❌ Error al obtener servidores:", error);
        return {
            "Error de conexión": linkPelicula
        };
    }
}

// 🔹 Función para obtener canal adaptada (con carga lazy de servidores)
async function getCanal() {
    let zonaEnlaces = document.getElementById("id_optPeliculas");
    zonaEnlaces.innerHTML = ""; // Limpiar opciones existentes

    const pelicula = Peliculas.get(canal); // Obtener datos de la película
    if (!pelicula) {
        alert("Película no encontrada");
        return null;
    }

    // 🔹 Si no se han cargado los servidores, buscarlos ahora
    if (!pelicula.servidoresCargados) {
        console.log(`🔄 Cargando servidores para: ${pelicula.titulo}`);

        // Mostrar mensaje de carga en el select
        zonaEnlaces.innerHTML = '<option>Buscando servidores...</option>';

        try {
            // Obtener los servidores dinámicamente
            const servidores = await obtenerServidoresPelicula(pelicula.link);

            // Actualizar la película con los servidores encontrados
            pelicula.enlacesReproduccion = servidores;
            pelicula.servidoresCargados = true;

            // Actualizar en el Map principal
            Peliculas.set(canal, pelicula);

            console.log(`✅ Servidores cargados para: ${pelicula.titulo}`);

        } catch (error) {
            console.error("❌ Error al cargar servidores:", error);
            pelicula.enlacesReproduccion = {
                "Error de carga": pelicula.link
            };
            pelicula.servidoresCargados = true;
        }

        // Limpiar el mensaje de carga
        zonaEnlaces.innerHTML = "";
    }

    const enlacesReproduccion = pelicula.enlacesReproduccion;
    if (!enlacesReproduccion || Object.keys(enlacesReproduccion).length === 0) {
        alert("No tiene servidores disponibles");
        return null;
    }

    // 🔹 Aplanar todos los servidores en un solo array
    const listaServidores = [];
    for (const idioma in enlacesReproduccion) {
        const etiqueta = idioma === "LAT" ? "(Latino)" : idioma === "SUB" ? "(Subtitulado)" : idioma === "JAP" ? "(Japones)" : `(${idioma})`;

        enlacesReproduccion[idioma].forEach(s => {
            listaServidores.push({
                nombre: `${s.servidor} ${etiqueta}`,
                url: s.url
            });
        });
    }

    // Validar la opción seleccionada (opt)
    if (opt > listaServidores.length || opt < 1) {
        opt = 1;
    }

    // Generar las opciones del <select>
    listaServidores.forEach((s, index) => {
        const selected = (index === opt - 1) ? "selected" : "";
        zonaEnlaces.innerHTML += `<option class="dropdown-item" ${selected} value="${index + 1}">${s.nombre}</option>`;
    });

    // Retornar el enlace correspondiente a la opción seleccionada
    return listaServidores[opt - 1].url;
}

// 🔹 Resto de funciones originales (mantener como están)
// 🔹 Función CambiarOpt adaptada para async
async function CambiarOpt() {
    opt = parseInt(document.getElementById("id_optPeliculas").value);
    await Cambio_Canal(); // Ahora necesitamos await
}

function actualizoLink() {
    const url = new URL(window.location.href);
    url.searchParams.set('stream', canal);
    url.searchParams.set('server', opt);
    window.history.pushState({}, '', url);
}

// 🔹 Función de cambio de canal adaptada para async
async function Cambio_Canal() {
    actualizoLink();
    document.getElementById("id_sapping-canal").innerHTML = canal;
    document.getElementById("id_sapping-canal").style.display = "flex";
    document.getElementById("id_optPeliculas").style.display = "flex";
    document.getElementById("id_BuscardorCanales").value = "";

    // 🔹 Ahora getCanal es async, necesitamos await
    try {
        const canalUrl = await getCanal();
        if (canalUrl) {
            tele.src = canalUrl;
            tele.style.display = "block";
        }
    } catch (error) {
        console.error("Error al cambiar canal:", error);
        alert("Error al cargar la película. Intente de nuevo.");
    }

    if (tele) {
        window.scrollTo({
            top: 0,
            behavior: 'smooth'
        });
    }
}

function Cambiar_Canal(boton_canal) {
    canal = boton_canal.title;
    Cambio_Canal(); // Esta función ahora es async pero no necesitamos await aquí
}

function Buscar_Canal() {
    let value = document.getElementById("id_BuscardorCanales").value.toLowerCase();
    let botonesCanales = document.querySelectorAll(".class_CanalBoton");

    for (let i = 0; i < botonesCanales.length; i++) {
        let botones = botonesCanales[i];
        let buscar = botones.title.toLowerCase();
        if (buscar.indexOf(value) > -1) {
            botones.style.display = "flex";
            botones.style.opacity = 1;
            botones.classList.add("encontrado");
        } else {
            botones.style.display = "none";
            botones.style.opacity = 0;
            botones.classList.remove("encontrado");
        }
    }

    if (window.innerWidth >= 1000) {
        const element = document.getElementById("id_PeliculasDisponibles");
        if (element) {
            window.scrollTo({
                top: element.offsetTop - 25,
                behavior: 'smooth'
            });
        }
    }
}

// 🔹 INICIALIZACIÓN
// Llamar a la función inicial cuando el DOM esté listo
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', IniciarCargaCanales);
} else {
    IniciarCargaCanales();
}

// 🔹 Event Listeners (mantener los originales)
document.getElementById("id_optPeliculas").addEventListener("change", CambiarOpt);
document.getElementById("id_BuscardorCanales").addEventListener("keyup", Buscar_Canal);
document.getElementById("id_BuscardorCanales").addEventListener("click", Buscar_Canal);
window.addEventListener("scroll", mostrarScroll);