main.js

const { app, BrowserWindow, ipcMain, Tray, Menu, nativeImage, dialog } = require('electron');
const path = require('path');
const { spawn, execSync } = require('child_process');
const fs = require('fs');

let mainWindow;
let tray = null;
let xrayProcess = null;
let isQuitting = false;

// Функции для управления системным прокси Windows
function enableSystemProxy(proxyAddress) {
    try {
        execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD /d 1 /f`, { windowsHide: true });
        execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyServer /t REG_SZ /d "${proxyAddress}" /f`, { windowsHide: true });
        execSync(`netsh winhttp set proxy "${proxyAddress}"`, { windowsHide: true });
        return true;
    } catch (err) {
        return false;
    }
}

function disableSystemProxy() {
    try {
        execSync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" /v ProxyEnable /t REG_DWORD /d 0 /f`, { windowsHide: true });
        execSync(`netsh winhttp reset proxy`, { windowsHide: true });
        return true;
    } catch (err) {
        return false;
    }
}

function setProxyEnvironment(proxyAddress) {
    try {
        const httpProxy = `http://${proxyAddress}`;
        execSync(`setx HTTP_PROXY "${httpProxy}"`, { windowsHide: true });
        execSync(`setx HTTPS_PROXY "${httpProxy}"`, { windowsHide: true });
        execSync(`setx ALL_PROXY "${httpProxy}"`, { windowsHide: true });
        process.env.HTTP_PROXY = httpProxy;
        process.env.HTTPS_PROXY = httpProxy;
        process.env.ALL_PROXY = httpProxy;
        return true;
    } catch (err) {
        return false;
    }
}

function clearProxyEnvironment() {
    try {
        execSync(`setx HTTP_PROXY ""`, { windowsHide: true });
        execSync(`setx HTTPS_PROXY ""`, { windowsHide: true });
        execSync(`setx ALL_PROXY ""`, { windowsHide: true });
        delete process.env.HTTP_PROXY;
        delete process.env.HTTPS_PROXY;
        delete process.env.ALL_PROXY;
        return true;
    } catch (err) {
        return false;
    }
}


// Полная очистка при выходе
function cleanupAndQuit() {
    writeLog('Application closing, cleaning up...');
    if (xrayProcess) {
        xrayProcess.kill();
        xrayProcess = null;
    }
    disableSystemProxy();
    clearProxyEnvironment();
    writeLog('Cleanup complete');
}

const logFile = path.join(__dirname, 'xray', 'vpn.log');

function writeLog(message) {
    const timestamp = new Date().toISOString();
    const logLine = `[${timestamp}] ${message}\n`;
    fs.appendFileSync(logFile, logLine);
}

function createTray() {
    const iconPath = path.join(__dirname, 'icon.ico');
    let trayIcon;
    if (fs.existsSync(iconPath)) {
        trayIcon = nativeImage.createFromPath(iconPath);
    } else {
        const size = 16;
        const buffer = Buffer.alloc(size * size * 4);
        for (let i = 0; i < size * size; i++) {
            buffer[i * 4] = 96;
            buffer[i * 4 + 1] = 75;
            buffer[i * 4 + 2] = 162;
            buffer[i * 4 + 3] = 255;
        }
        trayIcon = nativeImage.createFromBuffer(buffer, { width: size, height: size });
    }
    tray = new Tray(trayIcon);
    updateTrayMenu();
    tray.setToolTip('MyVPN - Отключен');
    tray.on('double-click', () => {
        if (mainWindow) mainWindow.show();
    });
}

function updateTrayMenu() {
    const isConnected = xrayProcess !== null;
    const contextMenu = Menu.buildFromTemplate([
        { label: 'MyVPN', enabled: false },
        { type: 'separator' },
        { label: isConnected ? '● Подключен' : '○ Отключен', enabled: false },
        { type: 'separator' },
        { label: 'Открыть', click: () => { if (mainWindow) mainWindow.show(); } },
        {
            label: isConnected ? 'Отключить VPN' : 'Подключить VPN',
            click: async () => {
                if (isConnected) await disconnectVPN();
                else await connectVPN();
                updateTrayMenu();
            }
        },
        { type: 'separator' },
        { label: 'Выход', click: () => { isQuitting = true; cleanupAndQuit(); app.quit(); } }
    ]);
    tray.setContextMenu(contextMenu);
    tray.setToolTip(isConnected ? 'MyVPN - Подключен' : 'MyVPN - Отключен');
}

function createWindow() {
    fs.writeFileSync(logFile, '');
    mainWindow = new BrowserWindow({
        width: 600, height: 700, minWidth: 400, minHeight: 500, resizable: true,
        webPreferences: { nodeIntegration: true, contextIsolation: false }
    });
    mainWindow.loadFile('index.html');
    mainWindow.setMenuBarVisibility(false);
    mainWindow.on('close', (event) => { if (!isQuitting) { event.preventDefault(); mainWindow.hide(); } });
    mainWindow.on('minimize', (event) => { event.preventDefault(); mainWindow.hide(); });
}

app.whenReady().then(() => { createWindow(); createTray(); });
app.on('window-all-closed', () => { });
app.on('before-quit', () => { isQuitting = true; cleanupAndQuit(); });


// Генерация XRay конфига
function generateXrayConfig(config) {
    return {
        log: { loglevel: 'warning' },
        inbounds: [
            { port: 10808, protocol: 'socks', settings: { udp: true }, sniffing: { enabled: true, destOverride: ['http', 'tls'] } },
            { port: 10809, protocol: 'http' }
        ],
        outbounds: [
            {
                protocol: 'vless',
                settings: {
                    vnext: [{
                        address: config.address,
                        port: config.port,
                        users: [{ id: config.uuid, encryption: 'none', flow: config.flow || 'xtls-rprx-vision' }]
                    }]
                },
                streamSettings: {
                    network: config.type || 'tcp',
                    security: config.security || 'reality',
                    realitySettings: config.security === 'reality' ? {
                        serverName: config.sni,
                        fingerprint: config.fingerprint,
                        publicKey: config.publicKey,
                        shortId: config.shortId
                    } : undefined
                },
                tag: 'proxy'
            },
            { protocol: 'freedom', tag: 'direct' }
        ],
        routing: { rules: [{ type: 'field', ip: ['geoip:private'], outboundTag: 'direct' }] }
    };
}

// Подключение VPN через XRay
async function connectVPN() {
    try {
        const xrayPath = path.join(__dirname, 'xray', 'xray.exe');
        const configPath = path.join(__dirname, 'xray', 'config.json');

        if (!fs.existsSync(xrayPath)) {
            writeLog('ERROR: xray.exe not found');
            return { success: false, error: 'xray.exe не найден' };
        }

        const userConfig = loadUserConfig();
        if (userConfig) {
            const xrayConfig = generateXrayConfig(userConfig);
            fs.writeFileSync(configPath, JSON.stringify(xrayConfig, null, 2));
        }

        writeLog('Starting XRay...');
        if (mainWindow) mainWindow.webContents.send('vpn-log', '🔄 Запуск XRay...');

        xrayProcess = spawn(xrayPath, ['run', '-config', configPath], { cwd: path.join(__dirname, 'xray') });

        xrayProcess.stdout.on('data', (data) => {
            const msg = data.toString();
            writeLog(msg);
            if (mainWindow) mainWindow.webContents.send('vpn-log', msg);
        });

        xrayProcess.stderr.on('data', (data) => {
            const msg = data.toString();
            writeLog('STDERR: ' + msg);
            if (mainWindow) mainWindow.webContents.send('vpn-log', msg);
        });

        xrayProcess.on('close', (code) => {
            writeLog(`XRay exited with code: ${code}`);
            if (mainWindow) mainWindow.webContents.send('vpn-disconnected');
            xrayProcess = null;
            updateTrayMenu();
        });

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

        if (xrayProcess && !xrayProcess.killed) {
            const proxyAddress = '127.0.0.1:10809';
            enableSystemProxy(proxyAddress);
            setProxyEnvironment(proxyAddress);
            writeLog('VPN connected (proxy mode)');
            if (mainWindow) mainWindow.webContents.send('vpn-log', '✅ VPN включен (режим прокси)');
        }

        updateTrayMenu();
        return { success: true };
    } catch (error) {
        writeLog('Connect error: ' + error.message);
        return { success: false, error: error.message };
    }
}

async function disconnectVPN() {
    writeLog('VPN disconnecting...');
    if (xrayProcess) { xrayProcess.kill(); xrayProcess = null; }
    disableSystemProxy();
    clearProxyEnvironment();
    writeLog('VPN disconnected');
    updateTrayMenu();
    return { success: true };
}


// Config paths
const userConfigPath = path.join(__dirname, 'xray', 'user-config.json');
const xrayConfigPath = path.join(__dirname, 'xray', 'config.json');

// Parse VLESS URL
function parseVlessUrl(url) {
    try {
        if (!url.startsWith('vless://')) return { error: 'Ссылка должна начинаться с vless://' };
        const withoutProtocol = url.substring(8);
        const [mainPart, name] = withoutProtocol.split('#');
        const [userServer, queryString] = mainPart.split('?');
        const [uuid, serverPort] = userServer.split('@');
        const [address, port] = serverPort.split(':');
        const params = {};
        if (queryString) {
            queryString.split('&').forEach(p => {
                const [key, value] = p.split('=');
                params[key] = decodeURIComponent(value || '');
            });
        }
        return {
            uuid, address, port: parseInt(port),
            name: name ? decodeURIComponent(name) : address,
            security: params.security || 'reality',
            type: params.type || 'tcp',
            sni: params.sni || params.serverName || 'www.google.com',
            fingerprint: params.fp || 'chrome',
            publicKey: params.pbk || '',
            shortId: params.sid || '',
            flow: params.flow || 'xtls-rprx-vision'
        };
    } catch (e) {
        return { error: 'Неверный формат ссылки: ' + e.message };
    }
}

function saveUserConfig(config) { fs.writeFileSync(userConfigPath, JSON.stringify(config, null, 2)); }

function loadUserConfig() {
    try {
        if (fs.existsSync(userConfigPath)) return JSON.parse(fs.readFileSync(userConfigPath, 'utf8'));
    } catch (e) { writeLog('Error loading user config: ' + e.message); }
    return null;
}

// IPC handlers
ipcMain.handle('connect-vpn', connectVPN);
ipcMain.handle('disconnect-vpn', disconnectVPN);
ipcMain.handle('get-status', async () => ({ connected: xrayProcess !== null }));
ipcMain.handle('get-config', async () => loadUserConfig());

ipcMain.handle('save-config', async (event, vlessUrl) => {
    const parsed = parseVlessUrl(vlessUrl);
    if (parsed.error) return { success: false, error: parsed.error };
    saveUserConfig(parsed);
    const xrayConfig = generateXrayConfig(parsed);
    fs.writeFileSync(xrayConfigPath, JSON.stringify(xrayConfig, null, 2));
    writeLog('Config saved: ' + parsed.address + ':' + parsed.port);
    return { success: true, config: parsed };
});

ipcMain.handle('reset-config', async () => {
    try {
        if (fs.existsSync(userConfigPath)) fs.unlinkSync(userConfigPath);
        writeLog('Config reset');
        return { success: true };
    } catch (e) { return { success: false, error: e.message }; }
});