const { app, BrowserWindow, Menu, dialog, ipcMain, desktopCapturer, Notification, ipcRenderer, protocol, session } = require('electron');
const { autoUpdater } = require('electron-updater');
const os = require('os');
const pie = require("puppeteer-in-electron");
const puppeteer = require("puppeteer-core");
const path = require('path');
const https = require('https');
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
const axios = require('axios');
const $ = require('jquery');
const fs = require('fs');
const argv = require('yargs').argv;
const { exec } = require('child_process');
const { rr } = require('./rr');
const { HttpsProxyAgent } = require('https-proxy-agent');
const { spawn } = require('child_process');


app.disableHardwareAcceleration();

const logsDir = 'C:/RpaClaro';
const app_version = app.getVersion();
let url_platform = '';
let username = '';
let password = '';
let xpath_username = '';
let xpath_password = '';
let xpath_button = '';
let data_apps;
let okanToken;
let splashWindow;
let mainWindow;
let windowNew;
let browser;
let page;
let data_apps_user = [];
let appsOkan;
let appHtml;
let userDataApps;
let from_okan = false;


const CONFIG = {
    ENDPOINT_URL_APPS: 'https://rpa.okan.tools/users/apps/byUserAdOrDocument',
    ENDPOINT_URL_APP: 'https://rpa.okan.tools/app',
    ENDPOINT_OKAN_TOKEN: 'https://io.okan.tools/api/auth/electron',
    TOKEN_OKAN_USER: 'HrZTvmBNyQaM6jPI7sHo5ywN35ht/cplIBFeE+4Ufx8=',
    PROXY: 'http://proxyop.bop.local:8080',
    ENDPOINT_GET_PROFILE: 'https://io.okan.tools/api/auth/users/electron',
    ENDPOINT_GET_APPS: 'https://adm.okan.tools/wp-json/okanapiwp/v1/aplicativos/'
};

app.disableHardwareAcceleration();

pie.initialize(app);

const setupLogging = async () => {
    console.log(">> Iniciando configuracion de logs..");
    if (!fs.existsSync(logsDir)) {
        fs.mkdirSync(logsDir, { recursive: true });
    }
    const logFilePath = path.join(logsDir, 'console-log.txt');

    // Limpia el archivo de logs al inicio
    await fs.promises.writeFile(logFilePath, '', 'utf-8');
    // Helper para escribir logs en el archivo
    const writeLogToFile = (message) => {
        const now = new Date();
        const timestamp = now.toLocaleString('en-US', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit',
            second: '2-digit',
            hour12: true
        }).replace(/(\d+)\/(\d+)\/(\d+)/, '$3-$1-$2');
        fs.appendFileSync(logFilePath, `[${timestamp}] ${message}\n`);
    };
    // Sobrescribe métodos de console
    ['log', 'info', 'warn', 'error'].forEach((method) => {
        const originalMethod = console[method];
        console[method] = (...args) => {
            const message = args
                .map((arg) => (typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg))
                .join(' ');
            writeLogToFile(message);
            originalMethod.apply(console, args); // Mantén la salida en la consola
        };
    });
};

// Función para manejar cookies en ASC069
async function handleCookiesASC069(page, data_code) {
    if (data_code === 'ASC069') {
        console.log('>> Verificando popup de cookies para ASC069...');

        try {
            // Lista de selectores comunes para popups de cookies
            const cookieSelectors = [
                // Selectores comunes para botones de aceptar cookies
                'button[id*="accept"]',
                'button[class*="accept"]',
                'button[id*="cookie"]',
                'button[class*="cookie"]',
                '[data-cy*="accept"]',
                '[data-testid*="accept"]',
                // Selectores por texto
                '//button[contains(text(), "Aceptar")]',
                '//button[contains(text(), "Accept")]',
                '//button[contains(text(), "Acepto")]',
                '//button[contains(text(), "OK")]',
                '//button[contains(text(), "Continuar")]',
                '//a[contains(text(), "Aceptar")]',
                '//a[contains(text(), "Accept")]',
                // Selectores específicos de ASCard si los conoces
                '#cookie-accept',
                '.cookie-accept',
                '[data-cookie="accept"]'
            ];

            let cookieHandled = false;

            // Intentar con selectores CSS primero
            for (const selector of cookieSelectors.filter(s => !s.startsWith('//'))) {
                try {
                    await page.waitForSelector(selector, { timeout: 2000 });
                    const element = await page.$(selector);
                    if (element) {
                        await element.click();
                        console.log(`>> Cookies aceptadas automáticamente usando selector: ${selector}`);
                        cookieHandled = true;
                        break;
                    }
                } catch (e) {
                    // Continuar con el siguiente selector
                }
            }

            // Si no funcionó con CSS, intentar con XPath
            if (!cookieHandled) {
                for (const xpath of cookieSelectors.filter(s => s.startsWith('//'))) {
                    try {
                        await page.waitForXPath(xpath, { timeout: 2000 });
                        const elements = await page.$x(xpath);
                        if (elements && elements.length > 0) {
                            await elements[0].click();
                            console.log(`>> Cookies aceptadas automáticamente usando XPath: ${xpath}`);
                            cookieHandled = true;
                            break;
                        }
                    } catch (e) {
                        // Continuar con el siguiente XPath
                    }
                }
            }

            if (cookieHandled) {
                // Esperar un momento para que se procese la aceptación
                await page.waitForTimeout(2000);
                console.log('>> Popup de cookies manejado correctamente');
                return true;
            } else {
                console.log('>> No se detectó popup de cookies o no se pudo manejar automáticamente');
                return false;
            }

        } catch (error) {
            console.log('>> Error al manejar cookies:', error.message);
            return false;
        }
    }
    return true; // Para otros códigos, continuar normalmente
}


async function getOkanToken() {
    try {
        const agent = new HttpsProxyAgent(CONFIG.PROXY);
        const responseOkan = await axios.post(CONFIG.ENDPOINT_OKAN_TOKEN, { user: process.env.USUARIO }, {
            headers: { 'Authorization': CONFIG.TOKEN_OKAN_USER },
            httpsAgent: agent
        });
        if (responseOkan.data.cod == '0') {
            console.log('>> Token de Okan obtenido.');
            return responseOkan.data.data;
        } else {
            console.log('>> Error al obtener el token de Okan.');
            return null;
        }
    } catch (error) {
        console.log('>> Error en la petición del token de Okan:', error);
        await dialog.showMessageBox({
            type: 'error',
            defaultId: 0,
            title: 'Error de acceso',
            message: 'Error al comunicarse con Okan',
        });
        app.quit();
        return null;
    }
}

const processArguments = async () => {
    console.log(argv);
    process.env.MODE = 'prod';
    let url_okan = argv['_'];
    let code_okan_str = url_okan.toString();

    console.log(code_okan_str);

    // Handle OKAN code from URL or direct argument
    if (code_okan_str != '' && !argv.dev) {
        console.log('sika desde okan');
        let code_okan = code_okan_str.split('&')[0].replace('rpaclaro:///?code=', '');
        let user_okan = code_okan_str.split('&')[1].replace('user=', '');
        process.env.OKAN = code_okan;
        process.env.USUARIO = user_okan;
        from_okan = true;
    } else if (code_okan_str == '' && argv['$0'] && argv['$0'].includes('RpaClaro.exe')) {
        console.log('sika desde exe');
        await dialog.showMessageBox({
            type: 'error',
            defaultId: 0,
            title: 'Error de acceso',
            message: 'Debes abrir RpaClaro desde Okan',
        });
        app.quit();
        return null;
    } else {
        console.log('sika desde cli');
        process.env.OKAN = argv.code;
        process.env.USUARIO = argv.user;
    }

    // Set environment mode
    if (argv.dev) {
        process.env.MODE = 'dev';
    } else {
        process.env.MODE = 'prod';
    }

    console.log('>> Iniciando RpaClaro..');
    console.log('_____________________________');
    console.log('RPA CLARO');
    console.log('Usuario: ' + process.env.USUARIO);
    console.log('Version: ' + app_version);
    console.log('Modo: ' + process.env.MODE);
    console.log('_____________________________');
};

const setupProtocolClient = async () => {
    // Get the path to the packaged executable
    const exePath = process.env.PORTABLE_EXECUTABLE_FILE || app.getPath('exe');

    try {
        // For development environment
        if (process.defaultApp) {
            if (process.argv.length >= 2) {
                app.setAsDefaultProtocolClient('RpaClaro', process.execPath, [path.resolve(process.argv[1])]);
            }
        } else {
            // For packaged executable
            // Remove any existing protocol registration first
            app.removeAsDefaultProtocolClient('RpaClaro');

            // Register the protocol with the packaged exe path
            const success = app.setAsDefaultProtocolClient('RpaClaro', exePath);

            if (!success) {
                throw new Error('Failed to register protocol handler');
            }
        }

        console.log('>> Protocol configuration established successfully');
        console.log('>> Executable path:', exePath);
    } catch (error) {
        console.error('>> Error setting up protocol client:', error);
        // Attempt to register without arguments as fallback
        app.setAsDefaultProtocolClient('RpaClaro');
    }
}

const copyFilesFromRR = () => {
    const origen = path.join(__dirname, 'rr');
    fs.readdir(origen, (err, archivos) => {
        if (err) {
            console.error('Error al leer el directorio de origen:', err);
            return;
        }
        archivos.forEach((archivo) => {
            const archivoOrigen = path.join(origen, archivo);
            const archivoDestino = path.join(logsDir, archivo);

            // Copia el archivo al directorio de destino
            fs.copyFile(archivoOrigen, archivoDestino, (err) => {
                if (err) {
                    console.error(`Error al copiar ${archivo}:`, err);
                } else {
                    // console.log(`${archivo} copiado correctamente.`);
                }
            });
        });
        console.log('>> Archivos copiados correctamente.');
    });
};

async function getOkanToken() {
    try {
        const agent = new HttpsProxyAgent(CONFIG.PROXY);

        const responseOkan = await axios.post(CONFIG.ENDPOINT_OKAN_TOKEN, { user: process.env.USUARIO }, {
            headers: { 'Authorization': CONFIG.TOKEN_OKAN_USER },
            httpsAgent: agent
        });
        if (responseOkan.data.cod == '0') {
            console.log('>> Token de Okan obtenido.');
            return responseOkan.data.data;
        } else {
            console.log('>> Error al obtener el token de Okan.');
            return null;
        }
    } catch (error) {
        console.log('>> Error en la petición del token de Okan:', error);
        await dialog.showMessageBox({
            type: 'error',
            defaultId: 0,
            title: 'Error de acceso',
            message: 'Error al comunicarse con Okan',
        });
        app.quit();
        return null;
    }
}

async function getProfile(token) {
    const token_okan = 'Bearer ' + token;

    try {
        const agent_two = new HttpsProxyAgent(CONFIG.PROXY);

        const responseGetProfile = await axios.get(CONFIG.ENDPOINT_GET_PROFILE, {
            headers: { 'Authorization': token_okan },
            httpsAgent: agent_two
        });
        if (responseGetProfile.data.cod == '0') {
            documento = responseGetProfile.data.data.document_number;
            profile = responseGetProfile.data.data.profile.id;
            console.log('>> Perfil: ' + profile);
            return profile;
        }
    } catch (e) {
        console.log('>> No se pudo obtener el perfil: ' + e);
    }
}

async function getApps(data_apps_user) {
    try {
        const agent_three = new HttpsProxyAgent(CONFIG.PROXY);

        // First attempt with proxy
        try {
            const urlAplicativos = CONFIG.ENDPOINT_GET_APPS + `${documento}/${profile}`;
            const responseAplicativos = await axios.get(urlAplicativos, {
                headers: {
                    "Accept": "*/*",
                    "Content-Type": "application/json"
                },
                httpsAgent: agent_three,
                timeout: 30000
            });

            if (responseAplicativos.data['cod'] == '0') {
                return processAppsResponse(responseAplicativos.data, data_apps_user);
            }
        } catch (proxyError) {
            console.log('>> Attempting without proxy after proxy error:', proxyError.message);

            // Second attempt without proxy
            const urlAplicativos = CONFIG.ENDPOINT_GET_APPS + `${documento}/${profile}`;
            const responseAplicativos = await axios.get(urlAplicativos, {
                headers: {
                    "Accept": "*/*",
                    "Content-Type": "application/json"
                },
                timeout: 30000
            });

            if (responseAplicativos.data['cod'] == '0') {
                return processAppsResponse(responseAplicativos.data, data_apps_user);
            }
        }
    } catch (e) {
        console.log('>> Error al obtener aplicaciones: ' + e);
    }
}

// Helper function to process the apps response
function processAppsResponse(responseData, data_apps_user) {
    var apps_okan = [];
    const new_apps = responseData['data']
        .filter(element => element['nombre_app'].startsWith('RPA'))
        .sort((a, b) => a.nombre_app.localeCompare(b.nombre_app));

    console.log('>> Aplicativos Okan: ' + new_apps.length);

    // Process each app from new_apps
    for (const app of new_apps) {
        let code = app.url.replace('rpaclaro://?code=', '');
        code = code.replace('RpaClaro://?code=', '');
        code = code.replace('&user={user}', '');
        let appExists = data_apps_user.desk?.some(deskApp => deskApp.code === code) ||
            data_apps_user.web?.some(webApp => webApp.code === code);

        apps_okan.push({
            nombre_app: app.nombre_app,
            code_app: code,
            logo: app.logo,
            status: appExists,
            status_integrado: appExists ? 'integrado' : 'no_integrado',
        });
    }

    // Generate HTML for all apps
    return apps_okan.map(app => `
        <div class="col-3 col-md-3 col-xl-3 shortcut app_click ${app.status_integrado}" 
            name_app="${app.nombre_app}" 
            integrado="${app.status}" 
            code="${app.code_app}">
            <div class="card border-none text-center">
                <div class="card-body hp-knowledge-basic-card">
                    <img src="${app.logo}" class="logo">
                    <h5>${app.nombre_app}</h5>
                </div>
            </div>
        </div>
    `).join('');
}

async function getNetworkInfo() {
    const interfaces = os.networkInterfaces();
    let ipAddress = '';
    let macAddress = '';

    // Buscar en todas las interfaces de red
    for (const name of Object.keys(interfaces)) {
        for (const net of interfaces[name]) {
            // Buscar IPv4 y no localhost
            if (net.family === 'IPv4' && !net.internal) {
                ipAddress = net.address;
                macAddress = net.mac;
                break;
            }
        }
        if (ipAddress && macAddress) break;
    }

    return { ip: ipAddress, mac: macAddress };
}

async function getUserData(token) {
    try {
        const agent_four = new HttpsProxyAgent(CONFIG.PROXY);
        const networkInfo = await getNetworkInfo();
        console.log('>> Usuario: ' + process.env.USUARIO);
        console.log('>> IP: ' + networkInfo.ip);
        console.log('>> MAC: ' + networkInfo.mac);
        console.log('>> Hostname: ' + os.hostname());

        const headersList = {
            "Accept": "*/*",
            "Content-Type": "application/json",
            "X-Client-Mac": networkInfo.mac,
            "X-Client-Host": os.hostname(),
            "X-Client-Ip": networkInfo.ip,
            "Authorization": "Bearer " + token
        };

        const bodyContent = JSON.stringify({
            "filtrar_por": "user_ad",
            "valor": process.env.USUARIO,
        });

        const response = await axios.post(CONFIG.ENDPOINT_URL_APPS, bodyContent, {
            headers: headersList,
            httpsAgent: agent_four
        });
        return response.data.apps;
    } catch (error) {
        console.error('Error en la solicitud:', error);
    }
};

async function createMainWindow(appsOkan) {
    mainWindow = new BrowserWindow({
        width: 1200,
        height: 650,
        show: true,
        // frame: false, // Remove window frame/menu
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false
        },
    });

    await mainWindow.loadFile('./views/main/index.html');
    const menuTemplate = [
        {
            label: 'Archivo',
            submenu: [
                {
                    label: 'Recargar',
                    accelerator: 'Ctrl+Shift+R',
                    icon: __dirname + '/views/assets/icons/reload.png', // Ruta al icono
                    click: () => {
                        mainWindow.webContents.reloadIgnoringCache();
                    }
                },
                { type: 'separator' }, // Separador en el menú
                {
                    label: 'Salir',
                    accelerator: 'Ctrl+Q',
                    icon: __dirname + '/views/assets/icons/exit.png', // Ruta al icono
                    click: () => {
                        app.quit();
                    }
                }
            ]
        },
        {
            label: 'Ayuda',
            submenu: [
                // {
                //     label: 'Mostrar DevTools',
                //     accelerator: 'Ctrl+Shift+L',
                //     icon: __dirname + '/views/assets/icons/screenshot.png', // Ruta al icono
                //     click: () => {

                //         mainWindow.openDevTools();
                //     }
                // },
                // { type: 'separator' },
                {
                    label: 'Acerca de',
                    accelerator: 'Ctrl+Shift+A',
                    icon: __dirname + '/views/assets/icons/reload.png', // Ruta al icono
                    click: () => {
                        const { version } = require('./package.json'); // Obtener la versión desde package.json
                        dialog.showMessageBox({
                            type: 'info',
                            title: 'Acerca de Mi Aplicación',
                            message: `Versión ${version}`,
                        });
                    }
                }
            ]
        }
    ];
    const menu = Menu.buildFromTemplate(menuTemplate);
    mainWindow.setMenu(menu);
    mainWindow.maximize();

    if (process.env.MODE == 'dev') {
        mainWindow.show();
        mainWindow.openDevTools();
        // mainWindow.setKiosk(true);
    }
    // const webContents = mainWindow.webContents;
    // webContents.setMaxListeners(50);

    mainWindow.webContents.send('set-version', app_version);
    mainWindow.webContents.send('set-userpc', process.env.USUARIO);
    try {
        mainWindow.webContents.send('data-apps', appsOkan);
    } catch (e) {
        console.log('>> Error al enviar datos:' + e);
    }


    // webContents.on('did-stop-loading', () => {
    //     console.log('>> Vista main cargada');
    // });



    mainWindow.on('ready-to-show', () => {


        // mainWindow.show();
        // mainWindow.setMenu(menu);
        // mainWindow.maximize();
    });

    mainWindow.on('closed', function () {
        mainWindow = null;
        app.quit();
    });

    mainWindow.show();

    return mainWindow;
}

async function createNewWindow() {
    browser = await pie.connect(app, puppeteer, {
        defaultViewport: null,
        ignoreHTTPSErrors: true,
    });
    // const page = await browser.newPage();

    windowNew = new BrowserWindow({
        args: ['--no-sandbox', '--disable-setuid-sandbox', '--ignore-certificate-errors'],
        ignoreHTTPSErrors: true,
        width: 1200,
        height: 650,
        show: false,
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false,
            partition: 'nopersist'
        },
    });

    windowNew.setMenu(null);

    windowNew.loadURL('https://apps.okan.tools');

    return 'test';

}

const mainIni = async () => {
    await setupProtocolClient();
    await setupLogging();
    await processArguments();
    copyFilesFromRR();
    let getOkanTokenVal = await getOkanToken();
    console.log('Okan token: ' + getOkanTokenVal);
    await getProfile(getOkanTokenVal);
    userDataApps = await getUserData(getOkanTokenVal);
    console.log('>> Aplicaciones:' + userDataApps);
    appsOkan = await getApps(userDataApps);
    console.log('>> Html generado');

    let mainWindowInstance = await createMainWindow(appsOkan);
    console.log(mainWindowInstance);
    await createNewWindow();
    // mainWindow.webContents.on('did-finish-load', async () => {
    console.log('termino de cargar');
    // try {
    await rpa(process.env.OKAN);
    // } catch(e) {
    //     console.log('oka error: '+e);
    // }
    // });


};

async function openExternalBrowserForTYD075(webApp) {
    console.log('>> Iniciando TYD075 en navegador externo');

    try {
        const puppeteer = require('puppeteer');

        const browser = await puppeteer.launch({
            headless: false,
            defaultViewport: null,
            args: [
                `--app=${webApp.url}`,
                '--start-maximized',
                '--no-sandbox',
                '--disable-setuid-sandbox'
            ],
            executablePath: process.platform === 'win32'
                ? 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
                : undefined
        });

        const pages = await browser.pages();
        const page = pages[0]; 

        await new Promise(resolve => setTimeout(resolve, 5000));

        console.log('>> Rellenando credenciales para TYD075');

        await page.waitForSelector('#username', { timeout: 10000 });
        const usernameField = await page.$('#username');
        if (usernameField) {
            await usernameField.click({ clickCount: 3 }); 
            await usernameField.type(webApp.username, { delay: 5 });
            console.log('>> Campo usuario rellenado');
        }

        await page.waitForSelector('#password', { timeout: 5000 });
        const passwordField = await page.$('#password');
        if (passwordField) {
            await passwordField.click({ clickCount: 3 });
            await passwordField.type(webApp.password, { delay: 5 });
            console.log('>> Campo contraseña rellenado');
        }

        await page.waitForSelector('#loginform fieldset button', { timeout: 5000 });
        const loginButton = await page.$('#loginform fieldset button');
        if (loginButton) {
            await loginButton.click();
            console.log('>> Click en botón de login realizado');

            try {
                await page.waitForNavigation({ 
                    waitUntil: 'networkidle0', 
                    timeout: 1500 
                });
                console.log('>> Navegación después del login completada');

                await page.evaluate(() => {
                    document.addEventListener('contextmenu', event => event.preventDefault());

                    document.addEventListener('keydown', (e) => {
                        if (
                            e.key === 'F12' ||
                            (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                            (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                            (e.ctrlKey && e.key === 'U')
                        ) {
                            e.preventDefault();
                            e.stopPropagation();
                            return false;
                        }
                    });
                });

                console.log('>> Medidas de seguridad aplicadas correctamente');

            } catch (navError) {
                console.log('>> No hubo navegación o ya estamos en la página correcta');
                
                try {
                    await page.evaluate(() => {
                        document.addEventListener('contextmenu', event => event.preventDefault());

                        document.addEventListener('keydown', (e) => {
                            if (
                                e.key === 'F12' ||
                                (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                                (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                                (e.ctrlKey && e.key === 'U')
                            ) {
                                e.preventDefault();
                                e.stopPropagation();
                                return false;
                            }
                        });

                        const userField = document.querySelector('#username');
                        const passField = document.querySelector('#password');
                        const loginBtn = document.querySelector('#loginform fieldset button');

                        if (userField) {
                            userField.setAttribute('readonly', 'true');
                            userField.style.pointerEvents = 'none';
                        }
                        if (passField) {
                            passField.setAttribute('readonly', 'true');
                            passField.style.pointerEvents = 'none';
                        }
                        if (loginBtn) {
                            loginBtn.style.pointerEvents = 'none';
                        }
                    });
                } catch (evalError) {
                    console.log('>> Error al aplicar medidas de seguridad:', evalError.message);
                }
            }
        }

        await new Promise(resolve => setTimeout(resolve, 5000));

        try {
            const errorElements = await page.$x('//*[contains(text(), "incorrect") or contains(text(), "error") or contains(text(), "invalid")]');
            if (errorElements.length > 0) {
                console.log('>> Error de credenciales detectado');
                dialog.showErrorBox('Error', 'Credenciales incorrectas para TYD075. Por favor, repórtalo al Coordinador');
                await browser.close();
                return false;
            }
        } catch (e) {
            console.log('>> No se detectaron errores de login');
        }

        console.log('>> TYD075 iniciado exitosamente en navegador externo');

        return true;

    } catch (error) {
        console.error('>> Error al abrir TYD075 en navegador externo:', error);
        dialog.showErrorBox('Error', `No se pudo abrir TYD075: ${error.message}`);
        return false;
    }
}

async function openExternalBrowserForDIM072(webApp) {
    console.log('>> Iniciando DIM072 en navegador externo');

    try {
        const puppeteer = require('puppeteer');

        const browser = await puppeteer.launch({
            headless: false,
            defaultViewport: null,
            args: [
                `--app=${webApp.url}`,
                '--start-maximized',
                '--no-sandbox',
                '--disable-setuid-sandbox'
            ],
            executablePath: process.platform === 'win32'
                ? 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
                : undefined
        });

        const pages = await browser.pages();
        const page = pages[0]; 

        await new Promise(resolve => setTimeout(resolve, 1000));

        console.log('>> Rellenando credenciales para DIM072');

        await page.waitForSelector('#Usuario', { timeout: 5000 });
        const usernameField = await page.$('#Usuario');
        if (usernameField) {
            await usernameField.click({ clickCount: 3 });
            await usernameField.type(webApp.username, { delay: 5 });
            console.log('>> Campo usuario rellenado');
        }
        
        await page.waitForSelector('#Contrase_a', { timeout: 5000 });
        const passwordField = await page.$('#Contrase_a');
        if (passwordField) {
            await passwordField.click({ clickCount: 3 });
            await passwordField.type(webApp.password, { delay: 5 });
            console.log('>> Campo contraseña rellenado');
        }
        
        await new Promise(resolve => setTimeout(resolve, 250));
       
        await page.waitForSelector('button[class="btn btn-lg red"]', { timeout: 5000 });
        const loginButton = await page.$('button[class="btn btn-lg red"]');        
        if (loginButton) {
            await loginButton.click();
            console.log('>> Click en botón de login realizado');

            try {
                await page.waitForNavigation({ 
                    waitUntil: 'networkidle0', 
                    timeout: 1500 
                });
                console.log('>> Navegación después del login completada');

                await page.evaluate(() => {
                    document.addEventListener('contextmenu', event => event.preventDefault());
                    document.addEventListener('keydown', (e) => {
                        if (
                            e.key === 'F12' ||
                            (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                            (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                            (e.ctrlKey && e.key === 'U')
                        ) {
                            e.preventDefault();
                            e.stopPropagation();
                            return false;
                        }
                    });
                });

                console.log('>> Medidas de seguridad aplicadas correctamente');

            } catch (navError) {
                console.log('>> No hubo navegación o ya estamos en la página correcta');
                
                try {
                    await page.evaluate(() => {
                        document.addEventListener('contextmenu', event => event.preventDefault());

                        document.addEventListener('keydown', (e) => {
                            if (
                                e.key === 'F12' ||
                                (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                                (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                                (e.ctrlKey && e.key === 'U')
                            ) {
                                e.preventDefault();
                                e.stopPropagation();
                                return false;
                            }
                        });

                        const userField = document.querySelector('#Usuario');
                        const passField = document.querySelector('#Contrase_a');
                        const loginBtn = document.querySelector('button[class="btn btn-lg red"]');

                        if (userField) {
                            userField.setAttribute('readonly', 'true');
                            userField.style.pointerEvents = 'none';
                        }
                        if (passField) {
                            passField.setAttribute('readonly', 'true');
                            passField.style.pointerEvents = 'none';
                        }
                        if (loginBtn) {
                            loginBtn.style.pointerEvents = 'none';
                        }
                    });
                } catch (evalError) {
                    console.log('>> Error al aplicar medidas de seguridad:', evalError.message);
                }
            }
        }

        await new Promise(resolve => setTimeout(resolve, 5000));

        try {
            const errorElements = await page.$x('//*[contains(text(), "incorrect") or contains(text(), "error") or contains(text(), "invalid")]');
            if (errorElements.length > 0) {
                console.log('>> Error de credenciales detectado');
                dialog.showErrorBox('Error', 'Credenciales incorrectas para DIM072. Por favor, repórtalo al Coordinador');
                await browser.close();
                return false;
            }
        } catch (e) {
            console.log('>> No se detectaron errores de login');
        }

        console.log('>> DIM072 iniciado exitosamente en navegador externo');

        return true;

    } catch (error) {
        console.error('>> Error al abrir DIM072 en navegador externo:', error);
        dialog.showErrorBox('Error', `No se pudo abrir DIM072: ${error.message}`);
        return false;
    }
}

async function openExternalBrowserForTUN065(webApp) {
    console.log('>> Iniciando TUN065 en navegador externo');

    try {
        const puppeteer = require('puppeteer');

        const browser = await puppeteer.launch({
            headless: false,
            defaultViewport: null,
            args: [
                `--app=${webApp.url}`,
                '--start-maximized',
                '--no-sandbox',
                '--disable-setuid-sandbox'
            ],
            executablePath: process.platform === 'win32'
                ? 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
                : undefined
        });

        const pages = await browser.pages();
        const page = pages[0]; 

        await new Promise(resolve => setTimeout(resolve, 1000));

        console.log('>> Rellenando credenciales para TUN065');

        await page.waitForSelector('input[name="ctl00$cpC$dcLogin$txtUserId"]', { timeout: 5000 });
        const usernameField = await page.$('input[name="ctl00$cpC$dcLogin$txtUserId"]');
        if (usernameField) {
            await usernameField.click({ clickCount: 3 });
            await usernameField.type(webApp.username, { delay: 5 });
            console.log('>> Campo usuario rellenado');
        }
        
        await page.waitForSelector('input[name="ctl00$cpC$dcLogin$txtPassword"]', { timeout: 5000 });
        const passwordField = await page.$('input[name="ctl00$cpC$dcLogin$txtPassword"]');
        if (passwordField) {
            await passwordField.click({ clickCount: 3 });
            await passwordField.type(webApp.password, { delay: 5 });
            console.log('>> Campo contraseña rellenado');
        }
        
        await new Promise(resolve => setTimeout(resolve, 50));
       
        await page.waitForSelector('div[class="button fs-bold text-center"]', { timeout: 5000 });
        const loginButton = await page.$('div[class="button fs-bold text-center"]');        
        if (loginButton) {
            await loginButton.click();
            console.log('>> Click en botón de login realizado');

            try {
                await page.waitForNavigation({ 
                    waitUntil: 'networkidle0', 
                    timeout: 1000 
                });
                console.log('>> Navegación después del login completada');

                await page.evaluate(() => {
                    document.addEventListener('contextmenu', event => event.preventDefault());
                    document.addEventListener('keydown', (e) => {
                        if (
                            e.key === 'F12' ||
                            (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                            (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                            (e.ctrlKey && e.key === 'U')
                        ) {
                            e.preventDefault();
                            e.stopPropagation();
                            return false;
                        }
                    });
                });

                console.log('>> Medidas de seguridad aplicadas correctamente');

            } catch (navError) {
                console.log('>> No hubo navegación o ya estamos en la página correcta');
                
                try {
                    await page.evaluate(() => {
                        document.addEventListener('contextmenu', event => event.preventDefault());

                        document.addEventListener('keydown', (e) => {
                            if (
                                e.key === 'F12' ||
                                (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                                (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                                (e.ctrlKey && e.key === 'U')
                            ) {
                                e.preventDefault();
                                e.stopPropagation();
                                return false;
                            }
                        });

                        const userField = document.querySelector('input[name="ctl00$cpC$dcLogin$txtUserId"]');
                        const passField = document.querySelector('input[name="ctl00$cpC$dcLogin$txtPassword"]');
                        const loginBtn = document.querySelector('div[class="button fs-bold text-center"]');

                        if (userField) {
                            userField.setAttribute('readonly', 'true');
                            userField.style.pointerEvents = 'none';
                        }
                        if (passField) {
                            passField.setAttribute('readonly', 'true');
                            passField.style.pointerEvents = 'none';
                        }
                        if (loginBtn) {
                            loginBtn.style.pointerEvents = 'none';
                        }
                    });
                } catch (evalError) {
                    console.log('>> Error al aplicar medidas de seguridad:', evalError.message);
                }
            }
        }

        await new Promise(resolve => setTimeout(resolve, 5000));

        try {
            const errorElements = await page.$x('//*[contains(text(), "incorrect") or contains(text(), "error") or contains(text(), "invalid")]');
            if (errorElements.length > 0) {
                console.log('>> Error de credenciales detectado');
                dialog.showErrorBox('Error', 'Credenciales incorrectas para TUN065. Por favor, repórtalo al Coordinador');
                await browser.close();
                return false;
            }
        } catch (e) {
            console.log('>> No se detectaron errores de login');
        }

        console.log('>> TUN065 iniciado exitosamente en navegador externo');

        return true;

    } catch (error) {
        console.error('>> Error al abrir TUN065 en navegador externo:', error);
        dialog.showErrorBox('Error', `No se pudo abrir IDV03: ${error.message}`);
        return false;
    }
}

async function openExternalBrowserForPOL(webApp) {
    console.log('>> Iniciando POLIEDRO en navegador externo');

    try {
        const puppeteer = require('puppeteer');

        const browser = await puppeteer.launch({
            headless: false,
            defaultViewport: null,
            args: [
                `--app=${webApp.url}`,
                '--start-maximized',
                '--no-sandbox',
                '--disable-setuid-sandbox',
                '--disable-web-security',
                '--disable-features=VizDisplayCompositor'
            ],
            executablePath: process.platform === 'win32'
                ? 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe'
                : undefined
        });

        const pages = await browser.pages();
        const page = pages[0];

        await page.waitForLoadState?.('networkidle') || await new Promise(resolve => setTimeout(resolve, 2000));

        console.log('>> Rellenando credenciales para POLIEDRO');

        async function fillFieldRobustly(selector, value, fieldName, maxRetries = 3) {
            for (let attempt = 1; attempt <= maxRetries; attempt++) {
                try {
                    console.log(`>> Intento ${attempt} para llenar ${fieldName}`);
                    
                    await page.waitForSelector(selector, { timeout: 10000 });
                    const field = await page.$(selector);
                    
                    if (!field) {
                        throw new Error(`Campo ${fieldName} no encontrado`);
                    }

                    // Limpiar el campo completamente
                    await field.click({ clickCount: 3 });
                    await page.keyboard.press('Delete');
                    await page.keyboard.press('Backspace');
                    await new Promise(resolve => setTimeout(resolve, 100));

                    // Escribir el valor caracter por caracter para mayor confiabilidad
                    for (const char of value) {
                        await page.keyboard.type(char, { delay: 20 });
                        await new Promise(resolve => setTimeout(resolve, 10));
                    }

                    // Verificar que el valor se escribió correctamente
                    await new Promise(resolve => setTimeout(resolve, 500));
                    const currentValue = await page.$eval(selector, el => el.value);
                    
                    if (currentValue === value) {
                        console.log(`>> ${fieldName} rellenado correctamente: `);
                        return true;
                    } else {
                        console.warn(`>> ${fieldName} no coincide. Esperado: , Actual:`);
                        if (attempt === maxRetries) {
                            throw new Error(`No se pudo llenar ${fieldName} después de ${maxRetries} intentos`);
                        }
                    }
                } catch (error) {
                    console.error(`>> Error en intento ${attempt} para ${fieldName}:`, error.message);
                    if (attempt === maxRetries) {
                        throw error;
                    }
                    await new Promise(resolve => setTimeout(resolve, 1000));
                }
            }
            return false;
        }

        await fillFieldRobustly('#ctl00_ContentPlaceHolder1_txtUsuario', webApp.username, 'usuario');

        await new Promise(resolve => setTimeout(resolve, 500));

        await fillFieldRobustly('#ctl00_ContentPlaceHolder1_txtContraseña', webApp.password, 'contraseña');

        console.log('>> Realizando validación final de credenciales...');
        await new Promise(resolve => setTimeout(resolve, 250));

        const finalUsernameCheck = await page.$eval('#ctl00_ContentPlaceHolder1_txtUsuario', el => el.value);
        const finalPasswordCheck = await page.$eval('#ctl00_ContentPlaceHolder1_txtContraseña', el => el.value);

        if (finalUsernameCheck !== webApp.username) {
            throw new Error(`Usuario final no coincide. Esperado: "${webApp.username}", Actual: "${finalUsernameCheck}"`);
        }

        if (finalPasswordCheck !== webApp.password) {
            throw new Error(`Contraseña final no coincide. Esperado: , Actual: "${finalPasswordCheck}"`);
        }

        console.log('>> Validación final exitosa. Procediendo con el login...');

        await page.waitForSelector('input[name="ctl00$ContentPlaceHolder1$btnIngresarUsuarioContraseña"]', { timeout: 5000 });
        const loginButton = await page.$('input[name="ctl00$ContentPlaceHolder1$btnIngresarUsuarioContraseña"]');
        
        if (loginButton) {
            const isDisabled = await page.$eval('input[name="ctl00$ContentPlaceHolder1$btnIngresarUsuarioContraseña"]', el => el.disabled);
            if (isDisabled) {
                console.warn('>> El botón de login está deshabilitado, esperando...');
                await new Promise(resolve => setTimeout(resolve, 300));
            }

            await loginButton.click();
            console.log('>> Click en botón de login realizado');

            try {
                await new Promise(resolve => setTimeout(resolve, 3000));

                try {
                    const hasTokenField = await page.$('td[colspan="2"].auto-style1');

                    if (!hasTokenField) {
                        const errorElements = await page.evaluate(() => {
                            const elements = document.querySelectorAll('*');
                            for (let element of elements) {
                                const text = element.textContent.toLowerCase();
                                if (text.includes('incorrect') || text.includes('error') || text.includes('invalid') ||
                                    text.includes('incorrecto') || text.includes('inválido') || 
                                    (text.includes('usuario') && text.includes('contraseña'))) {
                                    return true;
                                }
                            }
                            return false;
                        });

                        if (errorElements) {
                            console.log('>> Error de credenciales detectado');
                            dialog.showErrorBox('Error', 'Credenciales incorrectas para POLIEDRO. Por favor, repórtalo al Coordinador');
                            await browser.close();
                            return false;
                        }
                    } else {
                        console.log('>> Campo de token detectado. No se verifica error de login aún.');
                    }
                } catch (e) {
                    console.log('>> Error al verificar errores de credenciales:', e.message);
                }

                try {
                    await page.waitForSelector('td[colspan="2"].auto-style1', {
                        visible: true,
                        timeout: 2000
                    });

                    const element = await page.$('td[colspan="2"].auto-style1');
                    const textContent = await page.evaluate(el => el.textContent, element);
                    console.log(`>> Contenido encontrado: ${textContent.trim()}`);

                    if (textContent.includes('token') && textContent.includes('SMS')) {
                        console.log('>> Campo de token detectado - Habilitando interacción completa');

                        dialog.showMessageBox({
                            type: 'info',
                            title: 'Token SMS Requerido',
                            message: 'Se ha detectado que se requiere un token SMS. Por favor, ingrese el código que recibió por SMS en la página web y complete el proceso de autenticación.',
                            buttons: ['Entendido']
                        });

                        let authCompleted = false;
                        let attempts = 0;
                        const maxAttempts = 15;

                        while (!authCompleted && attempts < maxAttempts) {
                            await new Promise(resolve => setTimeout(resolve, 5000));
                            attempts++;

                            try {
                                const tokenFieldStillExists = await page.$('td[colspan="2"].auto-style1');
                                if (!tokenFieldStillExists) {
                                    authCompleted = true;
                                    console.log('>> Autenticación completada - Campo de token ya no presente');
                                    break;
                                }

                                const currentUrl = page.url();
                                const pageTitle = await page.title();
                                if (!currentUrl.includes('/login') && !pageTitle.toLowerCase().includes('login')) {
                                    authCompleted = true;
                                    console.log('>> Autenticación completada - Navegación detectada');
                                    break;
                                }

                                console.log(`>> Esperando autenticación... Intento ${attempts}/${maxAttempts}`);
                            } catch (e) {
                                console.log('>> Error al verificar estado de autenticación:', e.message);
                            }
                        }

                        if (!authCompleted && attempts >= maxAttempts) {
                            console.log('>> Tiempo de espera agotado para autenticación OTP');
                            dialog.showWarningBox('Tiempo Agotado', 
                                'El tiempo de espera para la autenticación OTP ha expirado. La sesión seguirá activa, pero puede que necesite completar manualmente el proceso.');
                        }
                    }
                } catch (otpError) {
                    console.log('>> No se detectó campo de token OTP, continuando...');
                }

                try {
                    await page.evaluate(() => {
                        document.addEventListener('contextmenu', event => event.preventDefault());
                        document.addEventListener('keydown', (e) => {
                            if (
                                e.key === 'F12' ||
                                (e.ctrlKey && e.shiftKey && e.key === 'I') ||
                                (e.ctrlKey && e.shiftKey && e.key === 'J') ||
                                (e.ctrlKey && e.key === 'U')
                            ) {
                                e.preventDefault();
                                e.stopPropagation();
                                return false;
                            }
                        });
                    });

                    console.log('>> Medidas de seguridad aplicadas correctamente');
                } catch (securityError) {
                    console.log('>> Error al aplicar medidas de seguridad:', securityError.message);
                }

            } catch (loginError) {
                console.log('>> Error durante el proceso de login:', loginError.message);
                dialog.showErrorBox('Error', `Error durante el proceso de login: ${loginError.message}`);
                await browser.close();
                return false;
            }
        }

        await new Promise(resolve => setTimeout(resolve, 2000));
        console.log('>> POLIEDRO iniciado exitosamente en navegador externo');
        return true;

    } catch (error) {
        console.error('>> Error al abrir POLIEDRO en navegador externo:', error);
        dialog.showErrorBox('Error', `No se pudo abrir POLIEDRO: ${error.message}`);
        return false;
    }
}

async function rpa(data_code) {

    console.log('>> Iniciando RPA');

    if (userDataApps) {
        const codeExists = userDataApps.desk.some(app => app.code === data_code) ||
            userDataApps.web.some(app => app.code === data_code);

        if (codeExists) {
            console.log(`>> Aplicativo ${data_code} esta asociado`);
            const deskApp = userDataApps.desk.find(app => app.code === data_code);
            const webApp = userDataApps.web.find(app => app.code === data_code);

            if (deskApp) {
                type = 'desktop';
                username = deskApp.username;
                password = deskApp.password;
                xpath_username = deskApp.xpath_username;
                xpath_password = deskApp.xpath_password;
                xpath_button = deskApp.btn_login;

                if (type == 'desktop') {
                    switch (data_code) {
                        case 'IRR123':
                            console.log('=== INICIANDO PROCESO IRR123 ===');
                            console.log(`Timestamp: ${new Date().toISOString()}`);
                            console.log(`Usuario: ${username}`);
                            console.log('Ejecutando función rr() para automatización AS400...');

                            rrtest = rr(username, password);
                            console.log(`Resultado de rr(): ${rrtest}`);
                            console.log('=== PROCESO IRR123 COMPLETADO ===');
                            break;

                        case 'ACC098':
                            console.log('ACC098');

                            programa = '"C:\\Program Files (x86)\\AC Administración de Clientes\\AC Administrador de Clientes.exe"';
                            exec(programa, (error, stdout, stderr) => {
                                if (error) {
                                    console.error(`Error al abrir el programa: ${error.message}`);
                                    return;
                                }
                                if (stderr) {
                                    console.error(`Error en la salida estándar: ${stderr}`);
                                    return;
                                }
                                console.log(`Salida del programa: ${stdout}`);
                            });

                            break;

                        case 'AVY003':
                            console.log('AVY003');

                            programa = '"C:\\Program Files (x86)\\Avaya\\Avaya one-X Agent\\OneXAgentUI.exe"';
                            exec(programa, (error, stdout, stderr) => {
                                // if (error) {
                                //     console.error(`Error al abrir el programa: ${error.message}`);
                                //     return;
                                // }
                                if (stderr) {
                                    console.error(`Error en la salida estándar: ${stderr}`);
                                    return;
                                }
                                console.log(`Salida del programa: ${stdout}`);
                            });

                            break;

                        case 'XLT001':
                            console.log('XLT001');

                            programa = '"C:\\Program Files (x86)\\CounterPath\\X-Lite\\x-lite.exe"';
                            exec(programa, (error, stdout, stderr) => {
                                if (error) {
                                    console.error(`Error al abrir el programa: ${error.message}`);
                                    return;
                                }
                                if (stderr) {
                                    console.error(`Error en la salida estándar: ${stderr}`);
                                    return;
                                }
                                console.log(`Salida del programa: ${stdout}`);
                            });

                            break;

                        case 'CTB002':
                            console.log('CTB002');

                            programa = '"C:\\avaya\\CTIbar\\ctibar.exe"';
                            exec(programa, (error, stdout, stderr) => {
                                if (error) {
                                    console.error(`Error al abrir el programa: ${error.message}`);
                                    return;
                                }
                                if (stderr) {
                                    console.error(`Error en la salida estándar: ${stderr}`);
                                    return;
                                }
                                console.log(`Salida del programa: ${stdout}`);
                            });

                            break;
                    }
                }
            } else if (webApp) {
                type = 'web';
                url_platform = webApp.url;
                username = webApp.username;
                password = webApp.password;
                xpath_username = webApp.xpath_user;
                xpath_password = webApp.xpath_pass;
                xpath_button = webApp.btn_login;

                if (data_code === 'TYD075') {
                    console.log('>> Detectado TYD075 - Usando navegador externo');
                    const success = await openExternalBrowserForTYD075(webApp);
                    if (!success) {
                        console.log('>> Error al procesar TYD075');
                    }
                    return; 
                }

                if (data_code === 'DIM072') {
                    console.log('>> Detectado DIM072 - Usando navegador externo');
                    const success = await openExternalBrowserForDIM072(webApp);
                    if (!success) {
                        console.log('>> Error al procesar DIM072');
                    }
                    return; 
                }

                if (data_code === 'TUN065') {
                    console.log('>> Detectado TUN065 - Usando navegador externo');
                    const success = await openExternalBrowserForTUN065(webApp);
                    if (!success) {
                        console.log('>> Error al procesar TUN065');
                    }
                    return; 
                }

                if (data_code === 'POL911' || data_code === 'POL912' || data_code === 'POL913' || data_code === 'POL914' || data_code === 'POL915' || data_code === 'POD911') {
                    console.log('>> Detectado POLIEDRO - Usando navegador externo');
                    const success = await openExternalBrowserForPOL(webApp);
                    if (!success) {
                        console.log('>> Error al procesar POLIEDRO');
                    }
                    return; 
                }

                if (!windowNew || windowNew.isDestroyed()) {
                    windowNew = new BrowserWindow({
                        args: ['--no-sandbox', '--disable-setuid-sandbox', '--ignore-certificate-errors'],
                        ignoreHTTPSErrors: true,
                        width: 1200,
                        height: 650,
                        show: false,
                        webPreferences: {
                            nodeIntegration: true,
                            contextIsolation: false,
                            partition: 'nopersist'
                        },
                    });
                }

                windowNew.on('closed', function () {
                    windowNew = null;
                    console.log('>> Ventana cerrada');
                });

                console.log('Esta es la url act: ' + webApp.url);

                if (data_code == 'POL911' || data_code == 'POL912' || data_code == 'POL913' || data_code == 'POL914' || data_code == 'POL915' || data_code == 'POD911') {
                    webApp.url = 'https://poliedro.comcel.com.co/LoginPoliedro/Login.aspx';
                }
                windowNew.loadURL(webApp.url);
                windowNew.show();
                windowNew.maximize();
                windowNew.setIgnoreMouseEvents(false);

                if (process.env.MODE != 'prod') {
                    windowNew.openDevTools();
                    windowNew.setIgnoreMouseEvents(false);
                }

                try {
                    await Promise.race([
                        new Promise(resolve => {
                            windowNew.webContents.on('did-finish-load', resolve);
                        }),
                        new Promise((_, reject) =>
                            setTimeout(() => reject(new Error('Timeout loading page')), 30000)
                        )
                    ]);

                    page = await pie.getPage(browser, windowNew);
                    if (!page) {
                        throw new Error('Failed to get page');
                    }
                    console.log('>> URL cargada: ' + page.url());
                } catch (error) {
                    console.log('>> Error al cargar la página:', error.message);
                    if (windowNew && !windowNew.isDestroyed()) {
                        windowNew.close();
                    }
                    throw error;
                }
            }

            console.log(`>> Tipo: ${type}`);
            if (type != 'desktop') {
                console.log(`>> URL: ${url_platform}`);

                console.log(`>> Username: ${username}`);
                console.log(`>> Password: **********`);
                console.log('>> Xpath username: ' + xpath_username);
                console.log('>> Xpath password: ' + xpath_password);
                console.log('>> Xpath button: ' + xpath_button);

                console.log('--------------------------');
                console.log('Abriendo aplicativo');
                console.log('--------------------------');
                try {

                    app.on('login', (event, webContents, request, authInfo, callback) => {
                        console.log('______________________login___________________');
                        event.preventDefault();
                        callback(username, password);
                    });

                    windowNew.setOpacity(1);
                    windowNew.maximize();
                    windowNew.setMenu(null);
                    windowNew.setIgnoreMouseEvents(true);

                    if (process.env.MODE != 'prod') {
                        windowNew.openDevTools();
                        windowNew.setIgnoreMouseEvents(false);
                    }

                    console.log('>> Url aplicativo: ' + url_platform);

                    let data_response_service = {
                        App: webApp.url || url_platform
                    };

                    const allowedCodes = ['SMO098', 'CTD094', 'SGC095', 'MAX096', 'CUP045'];
                    const specialCodes = ['MAP039'];
                    const loginCodes = ['ATB089', 'VTT046', 'DSC047', 'SMO098', 'CTD094', 'SGC095', 'MAX096', 'CUP045', 'BDC087'];
                    let url_mod;

                    if (allowedCodes.includes(data_code)) {
                        url_mod = `http://${username}:${password}@${data_response_service.App.replace('http://', '')}`;
                        url_mod = url_platform;
                    } else {
                        url_mod = url_platform;
                    }



                    try {
                        if (data_code == 'BDC087') {
                            url_mod = 'http://100.123.251.118:8082/componentes/ASP/consultabroadcast.aspx'
                        }
                        if (data_code == 'SRA074') {
                            url_mod = 'http://100.126.20.149:8080/sara/index.html'
                        }


                        await windowNew.loadURL(url_mod);
                        // Manejar casos especiales de tiempo de espera
                        if (data_code == 'POL911' || data_code == 'POL912' || data_code == 'POL913' || data_code == 'POL914' || data_code == 'POL915' || data_code == 'POD911') {
                            await new Promise(resolve => setTimeout(resolve, 5000));
                        }

                        // **NUEVO: Manejar cookies para ASC069**
                        if (data_code === 'ASC069') {
                            console.log('>> Procesando aplicativo ASC069 - Verificando cookies...');
                            await new Promise(resolve => setTimeout(resolve, 3000)); // Esperar a que cargue completamente

                            const cookiesHandled = await handleCookiesASC069(page, data_code);

                            if (!cookiesHandled) {
                                console.log('>> No se pudieron manejar las cookies automáticamente');
                                console.log('>> Permitiendo interacción manual del usuario');

                                // Habilitar interacción del usuario temporalmente
                                windowNew.setIgnoreMouseEvents(false);

                                // Mostrar notificación al usuario
                                const notification = new Notification({
                                    title: 'Acción requerida - ASC069',
                                    body: 'Por favor, acepta las cookies manualmente y el proceso continuará automáticamente',
                                    icon: 'logo-claro.ico'
                                });
                                notification.show();

                                // Esperar un tiempo razonable para que el usuario acepte las cookies
                                await new Promise(resolve => setTimeout(resolve, 10000));

                                // Verificar si la página cambió (indicando que se aceptaron las cookies)
                                try {
                                    // Intentar detectar si el popup de cookies ya no está presente
                                    const cookiePopupGone = await page.$eval('body', () => {
                                        // Buscar indicadores comunes de que el popup se cerró
                                        const commonCookieIndicators = [
                                            '[class*="cookie"]',
                                            '[id*="cookie"]',
                                            '[data-cookie]',
                                            '.modal[style*="display: block"]'
                                        ];

                                        for (const selector of commonCookieIndicators) {
                                            if (document.querySelector(selector)) {
                                                return false; // Aún hay popup
                                            }
                                        }
                                        return true; // Popup desapareció
                                    });

                                    if (cookiePopupGone) {
                                        console.log('>> Cookies aparentemente aceptadas por el usuario');
                                    } else {
                                        console.log('>> Continuando proceso - el usuario debe haber manejado las cookies');
                                    }

                                } catch (e) {
                                    console.log('>> Continuando con el proceso normal');
                                }

                                // Continuar con el proceso automático
                                windowNew.setIgnoreMouseEvents(true);
                            }
                        }

                        console.log('>> Cargo la pagina');
                    } catch (error) {
                        console.log('>> No se pudo cargar la pagina: ' + error);
                        dialog.showErrorBox('Error', 'No se pudo cargar la pagina. Por favor reporta al Helpdesk');
                        windowNew.setOpacity(1);
                        windowNew.close();
                    }


                    // const page = await pie.getPage(browser, windowNew);
                    try {
                        // const pages = await browser.pages().then(pages => pages).catch(err => console.error(err));
                        // console.log(pages);
                        // var page;
                        var pageUrl;

                        // for (const pages_sel of pages) {
                        //     const pageUrl = await pages_sel.url();
                        //     // console.log('la obtenida: ' + pageUrl + '_____' + 'la real: ' + url_mod);
                        //     if (pageUrl == 'http://100.126.20.149:8080/sara/login') {
                        //         url_mod = 'http://100.126.20.149:8080/sara/login';
                        //     }
                        //     if (pageUrl == 'http://dime.claro.com.co/Portal/Produccion/Sesion/Inicio/Ingresar?ReturnUrl=%2FPortal%2FProduccion%2FFidelizacion%2FRetencion%2FRegistrarSolicitud%3Fdato%3D1007227477%26Cuenta%3D89715445%26Ticket%3D1%26Internet%3D1%26TV%3D1%26Telefonia%3D0') {
                        //         url_mod = 'http://dime.claro.com.co/Portal/Produccion/Sesion/Inicio/Ingresar?ReturnUrl=%2FPortal%2FProduccion%2FFidelizacion%2FRetencion%2FRegistrarSolicitud%3Fdato%3D1007227477%26Cuenta%3D89715445%26Ticket%3D1%26Internet%3D1%26TV%3D1%26Telefonia%3D0';
                        //     }
                        //     if (pageUrl === url_mod) {
                        //         console.log(`Ok pagina`);
                        //         page = pages_sel;
                        //         break; // Detén el bucle cuando encuentras la coincidencia
                        //     }
                        // }

                        if (page) {
                            console.log(`Nombre de la pagina: ${await page.title()}`);

                            if (data_code == 'ASW049') {
                                console.log('avaya web');
                                await new Promise(resolve => setTimeout(resolve, 5000));
                                console.log('okan avaya');
                            }

                            // await page.waitForLoad();
                            if (xpath_username != 'na') {
                                // if (data_code == 'POL911' || data_code == 'POL912' || data_code == 'POL913' || data_code == 'POL914' || data_code == 'POL915' || data_code == 'POD911') {
                                //     await page.waitForXPath('//input[@id="ctl00_ContentPlaceHolder1_BtnRegresarMensaje"]');
                                //     const backBtn = await page.$x('//input[@id="ctl00_ContentPlaceHolder1_BtnRegresarMensaje"]');
                                //     await backBtn[0].click();
                                // }
                                if (!loginCodes.includes(data_code)) {

                                    if (data_code == 'CLU100') {
                                        const elementHandleClu = await page.$('.sign-in-uclaro');
                                        if (elementHandleClu) {
                                            await elementHandleClu.click();
                                        }
                                    }
                                    //empieza a llenar el campo de usuario
                                    await page.waitForXPath(xpath_username);
                                    const elementHandleUser = await page.$x(xpath_username);
                                    await elementHandleUser[0].type('', { delay: 100 });
                                    await elementHandleUser[0].type(username);
                                    console.log('>> Diligencio campo usuario');

                                    if (data_code == 'ABS099') {
                                        await page.keyboard.press("Enter");
                                    } else {
                                        await page.keyboard.press("Tab");
                                    }

                                    if (data_code == 'AGE036') {
                                        await page.waitForTimeout(4000);

                                    } else {
                                        await page.waitForTimeout(1000);
                                    }

                                    await page.waitForXPath(xpath_password);
                                    const elementHandlePass = await page.$x(xpath_password);
                                    await elementHandlePass[0].type('', { delay: 100 });
                                    await elementHandlePass[0].type(password);
                                    console.log('>> Diligencio campo password');

                                    await page.waitForTimeout(1000);

                                    // Manejo específico para MAP039
                                    if (data_code === 'MAP039') {
                                        console.log('>> Procesando botón de login para MAP039...');

                                        try {
                                            console.log('>> Intentando submit directo del formulario...');
                                            const formSubmitted = await page.evaluate(() => {
                                                const form = document.querySelector('form.vc_menu-search');
                                                if (form) {
                                                    form.submit();
                                                    return true;
                                                }
                                                return false;
                                            });

                                            if (formSubmitted) {
                                                console.log('>>  Formulario enviado con submit()');
                                            } else {
                                                console.log('>> Intentando disparar evento submit...');
                                                await page.evaluate(() => {
                                                    const form = document.querySelector('form.vc_menu-search');
                                                    if (form) {
                                                        const submitEvent = new Event('submit', {
                                                            bubbles: true,
                                                            cancelable: true
                                                        });
                                                        form.dispatchEvent(submitEvent);
                                                    }
                                                });
                                                console.log('>>  Evento submit disparado');
                                            }

                                        } catch (error) {
                                            console.log('>> Error con submit:', error.message);

                                            try {
                                                console.log('>> Intentando click forzado en div Entrar...');
                                                await page.evaluate(() => {
                                                    const enterDiv = document.querySelector('.vc_menu-send');
                                                    if (enterDiv) {
                                                        const clickEvent = new MouseEvent('click', {
                                                            bubbles: true,
                                                            cancelable: true,
                                                            view: window
                                                        });
                                                        enterDiv.dispatchEvent(clickEvent);
                                                    }
                                                });
                                                console.log('>>  Click forzado realizado');
                                            } catch (clickError) {
                                                console.log('>> Click forzado falló:', clickError.message);

                                                console.log('>> Intentando Enter en campo contraseña...');
                                                await page.focus('#contra');
                                                await page.keyboard.press('Enter');
                                            }
                                        }

                                        await page.waitForTimeout(2000);

                                    } else {
                                        const xpathMap = {
                                            'DIM072': '//button[contains(@id, "btiniciar")]',
                                            'CLU100': '//button[contains(@class, "ingresarBoton")]',
                                            'CMC093': xpath_button,
                                            'MCA030': '//input[contains(@id, "login-button")]'
                                        };

                                        const xpath = xpathMap[data_code] || null;

                                        if (xpath) {
                                            try {
                                                await page.waitForXPath(xpath, { timeout: 5000 });
                                                const elementHandle = await page.$x(xpath);
                                                if (elementHandle && elementHandle.length > 0) {
                                                    await elementHandle[0].click();
                                                    console.log('>> Se dio click en boton');
                                                } else {
                                                    console.log('>> No encontro boton');
                                                    await page.keyboard.press('Enter');
                                                }
                                            } catch (error) {
                                                console.log('>> Error esperando botón, usando Enter');
                                                await page.keyboard.press('Enter');
                                            }
                                        } else {
                                            await page.keyboard.press('Enter');
                                        }
                                    }
                                }

                                // await page.waitForTimeout(70000);


                                console.log('>> Envio formulario');

                                await page.waitForTimeout(7000);

                                if (data_code == 'POL911' || data_code == 'POL912' || data_code == 'POL913' || data_code == 'POL914' || data_code == 'POL915' || data_code == 'POD911') {
                                    console.log('>> Procesando aplicativo Poliedro');
                                    try {
                                        console.log('>> Esperando campo de token...');
                                
                                        try {
                                            await page.waitForSelector('td[colspan="2"][class="auto-style1"]', {
                                                visible: true,
                                                timeout: 10000
                                            });
                                
                                            const element = await page.$('td[colspan="2"][class="auto-style1"]');
                                            const textContent = await page.evaluate(el => el.textContent, element);
                                            console.log(`>> Contenido encontrado: ${textContent.trim()}`);
                                
                                            if (textContent.includes('token') && textContent.includes('SMS')) {
                                                console.log('>> Campo de token detectado - Habilitando interacción completa');
                                
                                                windowNew.setIgnoreMouseEvents(false);
                                                
                                                windowNew.show();
                                                windowNew.focus();
                                                windowNew.setAlwaysOnTop(true);
                                                setTimeout(() => {
                                                    windowNew.setAlwaysOnTop(false);
                                                }, 1000);
                                
                                                const notification = new Notification({
                                                    title: 'Acción requerida - Poliedro',
                                                    body: 'Ingresa el código de verificación. La ventana ya está habilitada para uso.',
                                                    icon: 'logo-claro.ico'
                                                });
                                                notification.show();
                                
                                                console.log('>> Interacción habilitada permanentemente para Poliedro');
                                                return; 
                                
                                            } else {
                                                throw new Error('Contenido no coincide con mensaje de token');
                                            }
                                
                                        } catch (tokenError) {
                                            console.log('>> No se encontró mensaje de token, verificando login exitoso...');
                                            await page.waitForTimeout(3000);
                                            
                                            windowNew.setIgnoreMouseEvents(false);
                                            windowNew.show();
                                            windowNew.focus();
                                            
                                            console.log('>> Interacción habilitada para uso normal de Poliedro');
                                        }
                                
                                    } catch (e) {
                                        console.log('>> Error en Poliedro, habilitando interacción manual: ' + e);
                                        
                                        windowNew.setIgnoreMouseEvents(false);
                                        windowNew.show();
                                        windowNew.focus();
                                        windowNew.setAlwaysOnTop(true);
                                        setTimeout(() => {
                                            windowNew.setAlwaysOnTop(false);
                                        }, 1000);
                                
                                        const notification = new Notification({
                                            title: 'Atención - Poliedro',
                                            body: 'Complete el proceso manualmente. La ventana está habilitada.',
                                            icon: 'logo-claro.ico'
                                        });
                                        notification.show();
                                    }
                                    
                                    return;
                                } else {
                                    const checkAndClose = async (message, text, xpath) => {
                                        var elementHandles;
                                        if (xpath) {
                                            elementHandles = await page.$x(text, { timeout: 1000 });
                                        } else {
                                            if (data_code != 'SRA074' && text != 'valid') {
                                                elementHandles = await page.$x(`//*[contains(text(), "${text}")]`, { timeout: 1000 });
                                            }
                                        }

                                        if (elementHandles && elementHandles.length > 0) {
                                            if (data_code == 'VIM059' && elementHandles.length <= 2) {
                                                // No hace nada para VIM059 con 2 elementos o menos
                                            } else if (data_code == 'DIM072' && elementHandles.length <= 1) {
                                                // No hace nada para DIM072 con 1 elemento o menos
                                            } else if (data_code == '') {
                                                // No hacer nada para TUN065 - permitir que continúe normalmente
                                                console.log(`>> IDV033: Se encontró texto "${text}" pero se permite continuar`);
                                            } else if (data_code == 'ASC069') {
                                                // No hace nada para ASC069
                                                console.log(`>> ASC069: Se encontró texto "${text}" pero se permite continuar`);
                                            } else {
                                                console.log(`Se encontró mensaje de error de credenciales: ${message}`);
                                                dialog.showErrorBox('Error', 'Parece que hubo un problema con el ingreso. Por favor, repórtalo al Coordinador');
                                                windowNew.close();
                                            }
                                        } else {
                                            console.log(`>> No se encontró mensaje de error de credenciales: ${message}`);
                                        }
                                    };

                                    await checkAndClose('Incorrect', 'incorrect', false) ||
                                        await checkAndClose('Incorrectos', 'INCORRECTOS', false) ||
                                        await checkAndClose('Error', 'error', false) ||
                                        await checkAndClose('Error', 'Error', false) ||
                                        await checkAndClose('Errada', 'errad', false) ||
                                        await checkAndClose('Valid', 'valid', false) ||
                                        await checkAndClose('no se encuentra habilitado para', 'no se encuentra habilitado para', false) ||
                                        await checkAndClose('Could not log', 'could not log', false) ||
                                        await checkAndClose('Form', xpath_username, true);
                                }
                            }
                            windowNew.setIgnoreMouseEvents(false);
                            // windowNew.setOpacity(1);
                            // windowNew.maximize();
                            // windowNew.focus();
                        } else {
                            console.log('>> No se encontro ninguna pagina con la URL proporcionada.');
                        }


                    } catch (error) {
                        console.log(error);
                    }

                } catch (error) {
                    windowNew.setOpacity(1);
                    windowNew.close();
                    console.error('Ha ocurrido un error ', data_code, error);
                    dialog.showErrorBox('Error', 'Ha ocurrido un error ' + error);
                }
            }



        } else {
            console.log(`>> Aplicativo ${data_code} no esta asociado`);
            await dialog.showMessageBox({
                type: 'error',
                defaultId: 0,
                title: 'Error de acceso',
                message: 'Lo siento, no tienes acceso a este aplicativo',
            });
        }
    }

};

// Ensure mainIni is called after app is ready
app.on('ready', mainIni);

const gotTheLock = app.requestSingleInstanceLock();

if (!gotTheLock) {
    app.quit();
} else {
    app.on('second-instance', async (event, argv, workingDirectory) => {
        console.log('>> Segunda instancia');
        console.log(argv);
        // Focus the main window if a second instance is detected
        if (mainWindow) {
            if (mainWindow.isMinimized()) mainWindow.restore();
            mainWindow.focus();
        }

        process.env.MODE = 'prod';
        let url_okan = argv[3];
        let code_okan_str = url_okan.toString();

        // Handle OKAN code from URL or direct argument
        if (argv[3] && !argv.dev) {

            let code_okan = code_okan_str.split('&')[0].replace('rpaclaro:///?code=', '');
            let user_okan = code_okan_str.split('&')[1].replace('user=', '');
            process.env.OKAN = code_okan;
            process.env.USUARIO = user_okan;
            console.log('>> Sgundos instancia code: ' + process.env.OKAN);
            await rpa(process.env.OKAN);
        } else {
            process.env.OKAN = argv.code;
            process.env.USUARIO = argv.user;
        }

        // Set environment mode
        if (argv.dev) {
            process.env.MODE = 'dev';
        } else {
            process.env.MODE = 'prod';
        }

        console.log('>> Iniciando RpaClaro..');
        console.log('_____________________________');
        console.log('RPA CLARO');
        console.log('Usuario: ' + process.env.USUARIO);
        console.log('Version: ' + app_version);
        console.log('Modo: ' + process.env.MODE);
        console.log('_____________________________');

    });

    // app.on('ready', mainIni);
}

// ... existing code ...

app.on('window-all-closed', () => {
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.commandLine.appendSwitch('ignore-certificate-errors');

app.on('certificate-error', (event, webContents, url, error, certificate, callback) => {
    event.preventDefault();
    callback(true);
});

ipcMain.on('openNewWindow', (event, data_code) => {
    rpa(data_code);
});

ipcMain.on('newNotification', (event, message) => {
    const notification = new Notification({
        title: message.title,
        body: message.body,
        icon: 'logo-claro.ico'
    });
    notification.show();
});

ipcMain.on('show-help', () => {
    dialog.showMessageBox({
        type: 'info',
        title: 'Acerca de Mi Aplicación',
        message: `Versión ` + app.getVersion(),
    });
});

ipcMain.on('reload-app', () => {
    mainWindow.webContents.reloadIgnoringCache(); // Reload main window ignoring cache
});

ipcMain.on('close-app', () => {
    app.quit(); // Cierra la aplicación
});
