main.js

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
const { exec } = require('child_process');

function createWindow() {
    const win = new BrowserWindow({
        width: 400,
        height: 600,
        webPreferences: {
            preload: path.join(__dirname, 'preload.js')
        },
        titleBarStyle: 'hiddenInset' // MacOS style
    });

    win.loadFile('index.html');
}

// Fix PATH for GUI apps on macOS to include Homebrew and common paths
const fixPath = () => {
    if (process.platform !== 'darwin') return;
    process.env.PATH = [
        '/opt/homebrew/bin',
        '/usr/local/bin',
        process.env.PATH
    ].join(':');
};

app.whenReady().then(() => {
    fixPath();
    createWindow();

    app.on('activate', () => {
        if (BrowserWindow.getAllWindows().length === 0) {
            createWindow();
        }
    });
});

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

ipcMain.handle('get-orgs', async () => {
    return new Promise((resolve, reject) => {
        exec('sf org list --json', (error, stdout, stderr) => {
            if (error) {
                console.error('Error fetching orgs:', error);
                // Even on error, we might want to return what we have or a specific error message
                reject(stderr || error.message);
                return;
            }
            try {
                const data = JSON.parse(stdout);
                resolve(data.result);
            } catch (e) {
                reject('Failed to parse org list');
            }
        });
    });
});

// Metadata Persistence
const fs = require('fs');
const metadataPath = path.join(app.getPath('userData'), 'org-metadata.json');

const loadMetadata = () => {
    try {
        if (fs.existsSync(metadataPath)) {
            return JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
        }
    } catch (e) {
        console.error('Failed to load metadata', e);
    }
    return {};
};

const saveMetadata = (data) => {
    try {
        fs.writeFileSync(metadataPath, JSON.stringify(data, null, 2));
    } catch (e) {
        console.error('Failed to save metadata', e);
    }
};

ipcMain.handle('get-org-metadata', async () => {
    return loadMetadata();
});

ipcMain.handle('save-org-metadata', async (event, data) => {
    saveMetadata(data);
    return true;
});

ipcMain.handle('open-org', async (event, alias) => {
    return new Promise((resolve, reject) => {
        exec(`sf org open -o "${alias}" -r --json`, (error, stdout, stderr) => {
            if (error) {
                console.error('Error opening org:', error);
                reject(stderr || error.message);
                return;
            }
            try {
                const result = JSON.parse(stdout);
                const url = result.result.url;
                require('electron').shell.openExternal(url);
                resolve(url);
            } catch (e) {
                reject('Failed to parse org url');
            }
        });
    });
});

ipcMain.handle('get-org-url', async (event, alias) => {
    return new Promise((resolve, reject) => {
        exec(`sf org open -o "${alias}" -r --json`, (error, stdout, stderr) => {
            if (error) {
                console.error('Error getting org URL:', error);
                reject(stderr || error.message);
                return;
            }
            try {
                const result = JSON.parse(stdout);
                const url = result.result.url;
                resolve(url);
            } catch (e) {
                reject('Failed to parse org url');
            }
        });
    });
});


ipcMain.handle('login-org', async (event, alias) => {
    return new Promise((resolve, reject) => {
        let cmd = 'sf org login web --json';
        if (alias) {
            cmd += ` -a "${alias}"`;
        }
        exec(cmd, (error, stdout, stderr) => {
            if (error) {
                reject(stderr || error.message);
                return;
            }
            try {
                const result = JSON.parse(stdout);
                resolve(result.result);
            } catch (e) {
                reject('Failed to parse login result');
            }
        });
    });
});

ipcMain.handle('set-alias', async (event, { alias, username }) => {
    return new Promise((resolve, reject) => {
        exec(`sf alias set "${alias}"="${username}" --json`, (error, stdout, stderr) => {
            if (error) {
                reject(stderr || error.message);
                return;
            }
            resolve(true);
        });
    });
});

ipcMain.handle('logout-org', async (event, username) => {
    return new Promise((resolve, reject) => {
        exec(`sf org logout -o "${username}" --no-prompt --json`, (error, stdout, stderr) => {
            if (error) {
                reject(stderr || error.message);
                return;
            }
            resolve(true);
        });
    });
});

ipcMain.handle('open-org-incognito', async (event, alias) => {
    return new Promise((resolve, reject) => {
        // 1. Get the URL
        exec(`sf org open -o "${alias}" -r --json`, (error, stdout, stderr) => {
            if (error) {
                reject(stderr || error.message);
                return;
            }
            try {
                const result = JSON.parse(stdout);
                const url = result.result.url;
                
                // 2. Open in Incognito (Chrome/Edge/Brave support)
                // Defaulting to Chrome for "used in the docker" context as it's common.
                // Fallback to "open -na 'Google Chrome' --args '--incognito' <url>"
                
                const command = `open -na "Google Chrome" --args "--incognito" "${url}"`;
                
                exec(command, (err) => {
                    if (err) {
                        // If Chrome fails, maybe try generic open? But that won't be incognito.
                        // Let's reject so UI knows.
                        console.error('Failed to open incognito', err);
                        reject('Failed to launch Chrome Incognito. Ensure Chrome is installed.');
                    } else {
                        resolve(url);
                    }
                });

            } catch (e) {
                reject('Failed to parse org url for incognito');
            }
        });
    });
});