import { app, BrowserWindow, ipcMain, shell, session, protocol, net, Tray, Menu, nativeImage } from 'electron';
import path from 'path';
import Store from 'electron-store';
import { exec } from 'child_process';
import dotenv from 'dotenv';
import axios from 'axios';
import fs from 'fs';
import { pathToFileURL } from 'url';
import { fetchProfileData, scrapeBanStatus } from './services/steam-web';
import { scrapeCooldown } from './services/scraper';
import { steamClient, LocalSteamAccount } from './services/steam-client';
import { BackendService } from './services/backend';

// Reliable isDev check
const isDev = !app.isPackaged;

app.name = "Ultimate Ban Tracker";

// Load environment variables
dotenv.config({ path: path.join(app.getAppPath(), '..', '.env') });

// --- Types & Interfaces ---
interface Account {
  _id: string;
  steamId: string;
  personaName: string;
  loginName: string;
  steamLoginSecure?: string;
  loginConfig?: any;
  sessionUpdatedAt?: string;
  autoCheckCooldown: boolean;
  avatar: string;
  localAvatar?: string;
  profileUrl: string;
  status: string;
  vacBanned: boolean;
  gameBans: number;
  lastBanCheck: string;
  lastScrapeTime?: string;
  cooldownExpiresAt?: string;
  authError?: boolean;
  notes?: string;
}

interface ServerConfig {
  url: string;
  token?: string;
  serverSteamId?: string;
  enabled: boolean;
  theme?: string;
}

// --- App State ---
let mainWindow: BrowserWindow | null = null;
let tray: Tray | null = null;
let backend: BackendService | null = null;
(app as any).isQuitting = false;

const store = new Store<{ accounts: Account[], serverConfig: ServerConfig }>({
  defaults: { 
    accounts: [], 
    serverConfig: { url: 'https://ultimate-ban-tracker.narl.io', enabled: false } 
  }
}) as any;

// --- Avatar Cache Logic ---
const AVATAR_DIR = path.join(app.getPath('userData'), 'avatars');
if (!fs.existsSync(AVATAR_DIR)) fs.mkdirSync(AVATAR_DIR, { recursive: true });

const downloadAvatar = async (steamId: string, url: string): Promise<string | undefined> => {
  if (!url) return undefined;
  const localPath = path.join(AVATAR_DIR, `${steamId}.jpg`);
  try {
    const response = await axios.get(url, { responseType: 'arraybuffer', timeout: 5000 });
    fs.writeFileSync(localPath, Buffer.from(response.data));
    return localPath;
  } catch (e) {
    return undefined;
  }
};

// --- Backend ---
const initBackend = () => {
  const config = store.get('serverConfig');
  if (config && config.enabled && config.url) {
    backend = new BackendService(config.url, config.token);
  } else {
    backend = null;
  }
};

// --- System Tray ---
const createTray = () => {
  const assetsDir = path.join(__dirname, '..', 'assets-build');
  const possibleIcons = ['icon.svg', 'icon.png'];
  let iconPath = '';

  for (const name of possibleIcons) {
    const fullPath = path.join(assetsDir, name);
    if (fs.existsSync(fullPath)) {
      iconPath = fullPath;
      break;
    }
  }
  
  console.log(`[Tray] Attempting to initialize with icon: ${iconPath || 'NONE FOUND'}`);
  
  if (!iconPath) {
    console.warn(`[Tray] FAILED: No valid icon found in ${assetsDir}`);
    return;
  }
  
  try {
    const icon = nativeImage.createFromPath(iconPath).resize({ width: 16, height: 16 });
    tray = new Tray(icon);
    tray.setToolTip('Ultimate Ban Tracker');
    tray.on('click', () => {
      if (mainWindow) {
        mainWindow.show();
        mainWindow.focus();
      }
    });
    updateTrayMenu();
    console.log(`[Tray] Successfully initialized`);
  } catch (e: any) {
    console.error(`[Tray] Critical error during initialization: ${e.message}`);
  }
};

const updateTrayMenu = () => {
  if (!tray) return;
  const accounts = store.get('accounts') as Account[];
  const config = store.get('serverConfig');

  const contextMenu = Menu.buildFromTemplate([
    { label: `Ultimate Ban Tracker v${app.getVersion()}`, enabled: false },
    { type: 'separator' },
    { 
      label: 'Switch Account', 
      submenu: accounts.length > 0 ? accounts.map(acc => ({
        label: `${acc.personaName} ${acc.loginName ? `(${acc.loginName})` : ''}`,
        enabled: !!acc.loginName,
        click: () => handleSwitchAccount(acc.loginName)
      })) : [{ label: 'No accounts found', enabled: false }]
    },
    { 
      label: 'Sync Now', 
      enabled: !!config?.enabled,
      click: () => syncAccounts()
    },
    { type: 'separator' },
    { label: 'Show Dashboard', click: () => { if (mainWindow) mainWindow.show(); } },
    { label: 'Quit', click: () => { (app as any).isQuitting = true; app.quit(); } }
  ]);

  tray.setContextMenu(contextMenu);
};

// --- Steam Logic ---
const killSteam = async () => {
  return new Promise<void>((resolve) => {
    const command = process.platform === 'win32' ? 'taskkill /f /im steam.exe' : 'pkill -9 steam';
    exec(command, () => setTimeout(resolve, 1000));
  });
};

const startSteam = () => {
  const command = process.platform === 'win32' ? 'start steam://open/main' : 'steam &';
  exec(command);
};

const handleSwitchAccount = async (loginName: string) => {
  if (!loginName) return false;
  try {
    await killSteam();
    const accounts = store.get('accounts') as Account[];
    const account = accounts.find(a => a.loginName === loginName);
    if (process.platform === 'win32') {
      const regCommand = `reg add "HKCU\\Software\\Valve\\Steam" /v AutoLoginUser /t REG_SZ /d "${loginName}" /f`;
      const rememberCommand = `reg add "HKCU\\Software\\Valve\\Steam" /v RememberPassword /t REG_DWORD /d 1 /f`;
      await new Promise<void>((res, rej) => exec(`${regCommand} && ${rememberCommand}`, (e) => e ? rej(e) : res()));
      if (account && account.loginConfig) steamClient.injectAccountConfig(loginName, account.loginConfig);
    } else if (process.platform === 'linux') {
      await steamClient.setAutoLoginUser(loginName, account?.loginConfig, account?.steamId);
    }
    startSteam();
    return true;
  } catch (e) { return false; }
};

// --- Scraper Helper ---
const scrapeAccountData = async (account: Account) => {
  const now = new Date();
  try {
    // 1. Refresh Basic Profile & Bans
    const profile = await fetchProfileData(account.steamId, account.steamLoginSecure);
    const bans = await scrapeBanStatus(profile.profileUrl, account.steamLoginSecure);
    
    account.personaName = profile.personaName;
    account.profileUrl = profile.profileUrl;
    account.vacBanned = bans.vacBanned;
    account.gameBans = bans.gameBans;
    account.status = (bans.vacBanned || bans.gameBans > 0) ? 'banned' : 'none';
    account.lastBanCheck = now.toISOString();

    if (profile.avatar && (!account.localAvatar || profile.avatar !== account.avatar)) {
      account.avatar = profile.avatar;
      const localPath = await downloadAvatar(account.steamId, profile.avatar);
      if (localPath) account.localAvatar = localPath;
    }

    // 2. Refresh Cooldowns if session is active
    if (account.steamLoginSecure) {
      try {
        const result = await scrapeCooldown(account.steamId, account.steamLoginSecure);
        account.authError = false;
        account.lastScrapeTime = now.toISOString();
        if (result.isActive) {
          account.cooldownExpiresAt = result.expiresAt ? result.expiresAt.toISOString() : new Date(Date.now() + 86400000).toISOString();
          if (backend) await backend.pushCooldown(account.steamId, account.cooldownExpiresAt);
        } else {
          account.cooldownExpiresAt = undefined;
          if (backend) await backend.pushCooldown(account.steamId, undefined);
        }
      } catch (e: any) {
        if (e.message.includes('cookie') || e.message.includes('Sign In')) account.authError = true;
      }
    }

    // 3. Share updated state with backend
    if (backend && !account._id.startsWith('shared_')) {
      await backend.shareAccount(account);
    }

    return true;
  } catch (e) {
    console.error(`[Scraper] Failed to scrape ${account.personaName}:`, e);
    return false;
  }
};

// --- Sync Worker ---
const syncAccounts = async () => {
  initBackend();
  let accounts = store.get('accounts') as Account[];
  let hasChanges = false;
  
  if (backend) {
    try {
      const shared = await backend.getSharedAccounts();
      for (const s of shared) {
        const exists = accounts.find(a => a.steamId === s.steamId);
        if (!exists) {
          accounts.push({
            _id: `shared_${s.steamId}`,
            steamId: s.steamId, personaName: s.personaName, avatar: s.avatar, profileUrl: s.profileUrl,
            vacBanned: s.vacBanned, gameBans: s.gameBans, cooldownExpiresAt: s.cooldownExpiresAt,
            loginName: s.loginName || '', steamLoginSecure: s.steamLoginSecure, loginConfig: s.loginConfig,
            sessionUpdatedAt: s.sessionUpdatedAt, autoCheckCooldown: !!s.steamLoginSecure,
            status: (s.vacBanned || s.gameBans > 0) ? 'banned' : 'none', lastBanCheck: new Date().toISOString()
          });
          hasChanges = true;
        } else {
          const sDate = s.sessionUpdatedAt ? new Date(s.sessionUpdatedAt) : new Date(0);
          const lDate = exists.sessionUpdatedAt ? new Date(exists.sessionUpdatedAt) : new Date(0);
          if (sDate > lDate) {
            if (s.loginName) exists.loginName = s.loginName;
            if (s.loginConfig) exists.loginConfig = s.loginConfig;
            if (s.steamLoginSecure) { exists.steamLoginSecure = s.steamLoginSecure; exists.autoCheckCooldown = true; exists.authError = false; }
            exists.sessionUpdatedAt = s.sessionUpdatedAt;
            hasChanges = true;
          }
          if (s.cooldownExpiresAt && (!exists.cooldownExpiresAt || new Date(s.cooldownExpiresAt) > new Date(exists.cooldownExpiresAt))) {
            exists.cooldownExpiresAt = s.cooldownExpiresAt;
            hasChanges = true;
          }
        }
      }
    } catch (e) { }
  }

  if (hasChanges) {
    store.set('accounts', accounts);
    if (mainWindow) mainWindow.webContents.send('accounts-updated', accounts);
    updateTrayMenu();
  }

  if (accounts.length === 0) return;

  const updatedAccounts = [...accounts];
  let scrapeChanges = false;

  for (const account of updatedAccounts) {
    try {
      const now = new Date();
      
      // OPTIMIZATION: Ensure ALL authenticated accounts are shared with the server on every sync cycle
      if (backend && !account._id.startsWith('shared_')) {
        await backend.shareAccount(account);
      }

      const lastCheck = account.lastBanCheck ? new Date(account.lastBanCheck) : new Date(0);
      if ((now.getTime() - lastCheck.getTime()) / 3600000 > 6 || !account.personaName) {
        await scrapeAccountData(account);
        scrapeChanges = true;
      }

      if (account.autoCheckCooldown && account.steamLoginSecure) {
        if (account.cooldownExpiresAt && new Date(account.cooldownExpiresAt) > now) continue;
        const lastScrape = account.lastScrapeTime ? new Date(account.lastScrapeTime) : new Date(0);
        if ((now.getTime() - lastScrape.getTime()) / 3600000 > 8) {
          await new Promise(r => setTimeout(r, Math.floor(Math.random() * 60000) + 5000));
          await scrapeAccountData(account);
          scrapeChanges = true;
        }
      }
    } catch (error) { }
  }

  if (scrapeChanges) {
    store.set('accounts', updatedAccounts);
    if (mainWindow) mainWindow.webContents.send('accounts-updated', updatedAccounts);
    updateTrayMenu();
  }
};

const scheduleNextSync = () => {
  setTimeout(async () => { await syncAccounts(); scheduleNextSync(); }, isDev ? 120000 : 1800000);
};

// --- Discovery ---
const addingAccounts = new Set<string>();
const handleLocalAccountsFound = async (localAccounts: LocalSteamAccount[]) => {
  const currentAccounts = store.get('accounts') as Account[];
  let hasChanges = false;
  for (const local of localAccounts) {
    if (addingAccounts.has(local.steamId)) continue;
    const exists = currentAccounts.find(a => a.steamId === local.steamId);
    if (exists) {
      if (!exists.loginName && local.accountName) { exists.loginName = local.accountName; hasChanges = true; }
    } else {
      addingAccounts.add(local.steamId);
      try {
        const profile = await fetchProfileData(local.steamId);
        const bans = await scrapeBanStatus(profile.profileUrl);
        const localPath = await downloadAvatar(profile.steamId, profile.avatar);
        currentAccounts.push({
          _id: Date.now().toString() + Math.random().toString().slice(2, 5),
          steamId: local.steamId, personaName: profile.personaName || local.accountName,
          loginName: local.accountName, autoCheckCooldown: false, avatar: profile.avatar,
          localAvatar: localPath, profileUrl: profile.profileUrl,
          status: (bans.vacBanned || bans.gameBans > 0) ? 'banned' : 'none',
          vacBanned: bans.vacBanned, gameBans: bans.gameBans, lastBanCheck: new Date().toISOString()
        });
        hasChanges = true;
      } catch (e) { }
      addingAccounts.delete(local.steamId);
    }
  }
  if (hasChanges) {
    store.set('accounts', currentAccounts);
    if (mainWindow) mainWindow.webContents.send('accounts-updated', currentAccounts);
    updateTrayMenu();
  }
};

// --- Main Window Creation ---
function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1280, height: 800, title: "Ultimate Ban Tracker", backgroundColor: '#171a21', autoHideMenuBar: true,
    webPreferences: { preload: path.join(__dirname, 'preload.js'), nodeIntegration: false, contextIsolation: true }
  });
  
  mainWindow.setMenu(null);
  
  mainWindow.on('close', (event) => {
    if (!(app as any).isQuitting) {
      event.preventDefault();
      mainWindow?.hide();
    }
    return false;
  });

  if (isDev) mainWindow.loadURL('http://localhost:5173');
  else mainWindow.loadFile(path.join(__dirname, '..', 'dist', 'index.html'));
}

// --- App Lifecycle ---
app.whenReady().then(() => {
  protocol.handle('steam-resource', (request) => {
    let rawPath = decodeURIComponent(request.url.replace('steam-resource://', ''));
    if (process.platform !== 'win32' && !rawPath.startsWith('/')) rawPath = '/' + rawPath;
    const absolutePath = path.isAbsolute(rawPath) ? rawPath : path.resolve(rawPath);
    if (!fs.existsSync(absolutePath)) return new Response('Not Found', { status: 404 });
    try { return net.fetch(pathToFileURL(absolutePath).toString()); } catch (e) { return new Response('Error', { status: 500 }); }
  });

  createWindow();
  createTray();
  initBackend();
  setTimeout(syncAccounts, 5000); 
  scheduleNextSync();
  steamClient.startWatching(handleLocalAccountsFound);
});

app.on('window-all-closed', () => { if (process.platform !== 'darwin' && (app as any).isQuitting) app.quit(); });
app.on('activate', () => { if (BrowserWindow.getAllWindows().length === 0) createWindow(); else mainWindow?.show(); });

// --- IPC Handlers ---
ipcMain.handle('get-accounts', () => store.get('accounts'));
ipcMain.handle('get-server-config', () => store.get('serverConfig'));
ipcMain.handle('update-server-config', (event, config: Partial<ServerConfig>) => {
  const current = store.get('serverConfig');
  const updated = { ...current, ...config };
  store.set('serverConfig', updated);
  initBackend();
  return updated;
});

ipcMain.handle('login-to-server', async () => {
  initBackend();
  const config = store.get('serverConfig') as ServerConfig;
  if (!config.url) return false;
  return new Promise<boolean>((resolve) => {
    const authWindow = new BrowserWindow({
      width: 800, height: 700, parent: mainWindow || undefined, modal: true, title: 'Login to Ban Tracker Server',
      webPreferences: { nodeIntegration: false, contextIsolation: true }
    });
    authWindow.loadURL(`${config.url}/auth/steam`);
    let captured = false;
    const saveServerAuth = (token: string) => {
      if (captured) return; captured = true;
      let serverSteamId = undefined;
      let isAdmin = false;
      try { 
        const payload = JSON.parse(Buffer.from(token.split('.')[1]!, 'base64').toString()); 
        serverSteamId = payload.steamId; 
        isAdmin = !!payload.isAdmin;
      } catch (e) {}
      const current = store.get('serverConfig');
      store.set('serverConfig', { ...current, token, serverSteamId, isAdmin, enabled: true });
      initBackend();
      authWindow.close();
      resolve(true);
    };
    const filter = { urls: [`${config.url}/*`] };
    authWindow.webContents.session.webRequest.onHeadersReceived(filter, (details, callback) => {
      const headers = details.responseHeaders || {};
      const authToken = headers['x-ubt-auth-token']?.[0] || headers['X-UBT-Auth-Token']?.[0];
      if (authToken) saveServerAuth(authToken);
      callback({ cancel: false });
    });
    authWindow.on('page-title-updated', (event, title) => {
      if (title.includes('AUTH_TOKEN:')) { const token = title.split('AUTH_TOKEN:')[1]; if (token) saveServerAuth(token); }
    });
    authWindow.on('closed', () => resolve(false));
  });
});

ipcMain.handle('get-server-user-info', () => ({ steamId: store.get('serverConfig').serverSteamId }));
ipcMain.handle('sync-now', async () => { await syncAccounts(); return true; });

ipcMain.handle('scrape-account', async (event, steamId: string) => {
  const accounts = store.get('accounts') as Account[];
  const account = accounts.find(a => a.steamId === steamId);
  if (!account) return false;
  
  console.log(`[Main] Manually triggering scrape for ${account.personaName}...`);
  const success = await scrapeAccountData(account);
  if (success) {
    store.set('accounts', accounts);
    if (mainWindow) mainWindow.webContents.send('accounts-updated', accounts);
    updateTrayMenu();
  }
  return success;
});

ipcMain.handle('add-account', async (event, { identifier }) => {
  try {
    initBackend();
    if (backend) {
      const shared = await backend.getCommunityAccounts();
      const existing = shared.find((s: any) => s.steamId === identifier || s.profileUrl.includes(identifier));
      if (existing) {
        const accounts = store.get('accounts') as Account[];
        if (accounts.find(a => a.steamId === existing.steamId)) throw new Error('Account already tracked');
        const newAccount: Account = {
          _id: `shared_${existing.steamId}`, steamId: existing.steamId, personaName: existing.personaName,
          avatar: existing.avatar, profileUrl: existing.profileUrl, vacBanned: existing.vacBanned,
          gameBans: existing.gameBans, cooldownExpiresAt: existing.cooldownExpiresAt,
          loginName: existing.loginName || '', steamLoginSecure: existing.steamLoginSecure,
          loginConfig: existing.loginConfig, sessionUpdatedAt: existing.sessionUpdatedAt,
          autoCheckCooldown: !!existing.steamLoginSecure, status: (existing.vacBanned || existing.gameBans > 0) ? 'banned' : 'none',
          lastBanCheck: new Date().toISOString()
        };
        store.set('accounts', [...accounts, newAccount]);
        updateTrayMenu();
        return newAccount;
      }
    }
    const profile = await fetchProfileData(identifier);
    const bans = await scrapeBanStatus(profile.profileUrl);
    const localAvatar = await downloadAvatar(profile.steamId, profile.avatar);
    const accounts = store.get('accounts') as Account[];
    const newAccount: Account = {
      _id: Date.now().toString(), steamId: profile.steamId, personaName: profile.personaName,
      loginName: '', avatar: profile.avatar, localAvatar: localAvatar, profileUrl: profile.profileUrl,
      autoCheckCooldown: false, vacBanned: bans.vacBanned, gameBans: bans.gameBans,
      status: (bans.vacBanned || bans.gameBans > 0) ? 'banned' : 'none', lastBanCheck: new Date().toISOString()
    };
    store.set('accounts', [...accounts, newAccount]);
    updateTrayMenu();
    return newAccount;
  } catch (error: any) { throw error; }
});

ipcMain.handle('update-account', (event, id: string, data: Partial<Account>) => {
  const accounts = store.get('accounts') as Account[];
  const index = accounts.findIndex((a: Account) => a._id === id);
  if (index !== -1) { accounts[index] = { ...accounts[index], ...data } as Account; store.set('accounts', accounts); updateTrayMenu(); return accounts[index]; }
  return null;
});

ipcMain.handle('delete-account', (event, id: string) => {
  const accounts = store.get('accounts') as Account[];
  store.set('accounts', accounts.filter((a: Account) => a._id !== id));
  updateTrayMenu();
  return true;
});

ipcMain.handle('share-account-with-user', async (event, steamId: string, targetSteamId: string) => {
  initBackend();
  if (backend) {
    const accounts = store.get('accounts') as Account[];
    const account = accounts.find(a => a.steamId === steamId);
    if (account) await backend.shareAccount(account);
    return await backend.shareWithUser(steamId, targetSteamId);
  }
  throw new Error('Backend not configured');
});

ipcMain.handle('revoke-account-access', async (event, steamId: string, targetSteamId: string) => {
  initBackend();
  if (backend) return await backend.revokeAccess(steamId, targetSteamId);
  throw new Error('Backend not configured');
});

ipcMain.handle('revoke-all-account-access', async (event, steamId: string) => {
  initBackend();
  if (backend) return await backend.revokeAllAccess(steamId);
  throw new Error('Backend not configured');
});

ipcMain.handle('get-community-accounts', async () => { initBackend(); return backend ? await backend.getCommunityAccounts() : []; });
ipcMain.handle('get-server-users', async () => { initBackend(); return backend ? await backend.getServerUsers() : []; });

// --- Admin IPC ---
ipcMain.handle('admin-get-stats', async () => { initBackend(); return backend ? await backend.getAdminStats() : null; });
ipcMain.handle('admin-get-users', async () => { initBackend(); return backend ? await backend.getAdminUsers() : []; });
ipcMain.handle('admin-delete-user', async (event, userId: string) => { initBackend(); if (backend) await backend.deleteUser(userId); return true; });
ipcMain.handle('admin-get-accounts', async () => { initBackend(); return backend ? await backend.getAdminAccounts() : []; });
ipcMain.handle('admin-remove-account', async (event, steamId: string) => { initBackend(); if (backend) await backend.forceRemoveAccount(steamId); return true; });

ipcMain.handle('switch-account', async (event, loginName: string) => await handleSwitchAccount(loginName));
ipcMain.handle('open-external', (event, url: string) => shell.openExternal(url));

ipcMain.handle('open-steam-app-login', async () => {
  console.log('[SteamClient] Preparing for fresh login...');
  await killSteam();

  if (process.platform === 'win32') {
    // Clear auto-login registry
    const clearReg = 'reg add "HKCU\\Software\\Valve\\Steam" /v AutoLoginUser /t REG_SZ /d "" /f';
    await new Promise<void>((res) => exec(clearReg, () => res()));
  } else if (process.platform === 'linux') {
    // On Linux we can use the steamClient helper to set an empty user
    await steamClient.setAutoLoginUser("", undefined, "");
  }

  const command = process.platform === 'win32' ? 'start steam://open/login' : 'xdg-open steam://open/login';
  exec(command);
  return true;
});

ipcMain.handle('open-steam-login', async (event, expectedSteamId: string) => {
  // Use a unique partition per account to prevent session bleeding
  const partitionId = expectedSteamId ? `persist:steam-login-${expectedSteamId}` : 'persist:steam-login-new';
  const loginSession = session.fromPartition(partitionId);

  // If adding a brand new account, explicitly clear previous trash
  if (!expectedSteamId) {
    console.log('[Auth] Clearing session for new account login...');
    await loginSession.clearStorageData({ storages: ['cookies', 'localstorage', 'indexdb'] });
  }

  // If we have an existing cookie string for this account, pre-inject it
  if (expectedSteamId) {
    const accounts = store.get('accounts') as Account[];
    const account = accounts.find(a => a.steamId === expectedSteamId);
    if (account?.steamLoginSecure) {
      console.log(`[Auth] Pre-injecting existing cookies for ${account.personaName}...`);
      const cookiePairs = account.steamLoginSecure.split(';').map(c => c.trim());
      for (const pair of cookiePairs) {
        const [name, value] = pair.split('=');
        if (name && value) {
          try {
            await loginSession.cookies.set({
              url: 'https://steamcommunity.com',
              domain: 'steamcommunity.com',
              name: name,
              value: value,
              path: '/',
              secure: true,
              httpOnly: name.includes('Secure')
            });
          } catch (e) {}
        }
      }
    }
  }

  return new Promise<boolean>((resolve) => {
    const loginWindow = new BrowserWindow({
      width: 800, height: 700, parent: mainWindow || undefined, modal: true, title: 'Login to Steam',
      webPreferences: { nodeIntegration: false, contextIsolation: true, partition: partitionId }
    });
    loginWindow.loadURL('https://steamcommunity.com/login/home/?goto=my/gcpd/730');
    const checkCookie = setInterval(async () => {
      try {
        const cookies = await loginSession.cookies.get({ domain: 'steamcommunity.com' });
        const secureCookie = cookies.find(c => c.name === 'steamLoginSecure');
        if (secureCookie) {
          const steamId = decodeURIComponent(secureCookie.value).split('|')[0];
          if (steamId) {
            if (expectedSteamId && steamId !== expectedSteamId) return; 
            clearInterval(checkCookie);
            const cookieString = cookies.map(c => `${c.name}=${c.value}`).join('; ');
            const accounts = store.get('accounts') as Account[];
            const accountIndex = accounts.findIndex(a => a.steamId === steamId);
            if (accountIndex !== -1) {
              const account = accounts[accountIndex]!;
              account.steamLoginSecure = cookieString; account.autoCheckCooldown = true; account.authError = false;
              account.sessionUpdatedAt = new Date().toISOString();
              if (account.loginName) {
                const config = steamClient.extractAccountConfig(account.loginName);
                if (config) account.loginConfig = config;
              }
              try {
                const result = await scrapeCooldown(account.steamId, cookieString);
                account.lastScrapeTime = new Date().toISOString();
                account.cooldownExpiresAt = result.isActive && result.expiresAt ? result.expiresAt.toISOString() : undefined;
              } catch (e) { }
              initBackend();
              if (backend) await backend.shareAccount(account);
              store.set('accounts', accounts);
              if (mainWindow) mainWindow.webContents.send('accounts-updated', accounts);
              updateTrayMenu();
              loginWindow.close();
              resolve(true);
            }
          }
        }
      } catch (error) { }
    }, 1000);
    loginWindow.on('closed', () => { clearInterval(checkCookie); resolve(false); });
  });
});