const { app, BrowserWindow, dialog, ipcMain, shell } = require('electron');
const { spawn, spawnSync } = require('child_process');
const fs = require('fs');
const path = require('path');

const projectRoot = path.resolve(__dirname, '..', '..');
const outputDir = path.join(projectRoot, 'dist-release-final');
const toolLogPath = path.join(__dirname, 'oem-tool.log');
const statePath = path.join(__dirname, 'active-run.json');
const toolAppName = 'OEM Batch Builder Tool';

app.setName(toolAppName);
app.setAppUserModelId('com.oem.batch-builder-tool');

let mainWindow = null;
let running = false;
let currentProcess = null;
let latestResults = [];
let activePollTimer = null;
let activeLogOffset = 0;
let activeSessionDir = '';
let activeResultFile = '';
let activeWorkerLogFile = '';
let activeStageStatusFile = '';
let allowQuitWhileRunning = false;

const gotSingleInstanceLock = app.requestSingleInstanceLock();
if (!gotSingleInstanceLock) {
  appendToolLog(`single-instance lock denied pid=${process.pid} argv=${safeJson(process.argv)}`);
  app.quit();
}

appendToolLog(`process start pid=${process.pid} ppid=${process.ppid} cwd=${process.cwd()} argv=${safeJson(process.argv)}`);

function appendToolLog(message) {
  try {
    fs.appendFileSync(toolLogPath, `[${new Date().toISOString()}] ${message}\n`, 'utf8');
  } catch {
    // ignore logging failure
  }
}

function safeJson(value) {
  try {
    return JSON.stringify(value);
  } catch {
    return String(value);
  }
}

function sendLog(payload) {
  const message = String(payload.message || '');
  if (payload.level === 'stdout' && shouldSuppressWindowLog(message)) return;
  const displayPayload = {
    ...payload,
    message: message.length > 6000 ? `${message.slice(0, 6000)}\n... [full output is in build-output.log]` : message,
  };
  appendToolLog(`${payload.level || 'info'} ${payload.jobId ? `[${payload.jobId}] ` : ''}${displayPayload.message || ''}`);
  if (!mainWindow || mainWindow.isDestroyed()) return;
  mainWindow.webContents.send('oem-tool:log', {
    time: new Date().toISOString(),
    ...displayPayload,
  });
}

function shouldSuppressWindowLog(message) {
  const text = String(message || '');
  return text.includes('[OK] Copied qrcode')
    || text.includes('[OK] Copied logo')
    || text.includes('[OK] Copied login-bg')
    || text.includes('[SKIP] pattern not matched')
    || text.includes('Processing: F:');
}

function readState() {
  try {
    if (!fs.existsSync(statePath)) return null;
    return JSON.parse(fs.readFileSync(statePath, 'utf8').replace(/^\uFEFF/, ''));
  } catch (error) {
    appendToolLog(`readState failed: ${error && error.message ? error.message : String(error)}`);
    return null;
  }
}

function writeState(payload) {
  try {
    fs.writeFileSync(statePath, JSON.stringify(payload, null, 2), 'utf8');
  } catch (error) {
    appendToolLog(`writeState failed: ${error && error.message ? error.message : String(error)}`);
  }
}

function clearStateIfFinished(payload) {
  writeState({
    running: false,
    finishedAt: new Date().toISOString(),
    outputDir,
    results: payload.results || [],
    message: payload.message || '',
    success: Boolean(payload.success),
    sessionDir: activeSessionDir,
  });
}

function createWindow() {
  appendToolLog('createWindow start');
  const staleFailure = repairStaleRunningState();
  if (staleFailure) {
    appendToolLog(`repaired stale active run before window creation: ${staleFailure.message}`);
  }
  mainWindow = new BrowserWindow({
    width: 1320,
    height: 860,
    minWidth: 1120,
    minHeight: 720,
    title: toolAppName,
    backgroundColor: '#f6f7fb',
    show: false,
    webPreferences: {
      preload: path.join(__dirname, 'preload.cjs'),
      contextIsolation: true,
      nodeIntegration: false,
    },
  });
  mainWindow.webContents.on('console-message', (_event, level, message, line, sourceId) => {
    appendToolLog(`renderer console level=${level} ${sourceId || ''}:${line || 0} ${message}`);
  });
  mainWindow.webContents.on('preload-error', (_event, preloadPath, error) => {
    appendToolLog(`preload-error ${preloadPath}: ${error && error.stack ? error.stack : error}`);
  });
  mainWindow.webContents.on('did-crash', (_event, killed) => {
    appendToolLog(`renderer did-crash killed=${killed}`);
  });
  mainWindow.webContents.on('destroyed', () => {
    appendToolLog('webContents destroyed');
  });
  mainWindow.on('unresponsive', () => {
    appendToolLog('window unresponsive');
  });
  mainWindow.on('responsive', () => {
    appendToolLog('window responsive');
  });

  const showMainWindow = () => {
    if (!mainWindow || mainWindow.isDestroyed()) return;
    appendToolLog(`showMainWindow visible=${mainWindow.isVisible()} minimized=${mainWindow.isMinimized()}`);
    mainWindow.setTitle(toolAppName);
    if (mainWindow.isMinimized()) mainWindow.restore();
    mainWindow.center();
    mainWindow.show();
    mainWindow.focus();
    mainWindow.moveTop();
    appendToolLog(`showMainWindow done visible=${mainWindow.isVisible()} bounds=${JSON.stringify(mainWindow.getBounds())}`);
  };

  mainWindow.loadFile(path.join(__dirname, 'index.html'));
  showMainWindow();
  mainWindow.on('page-title-updated', event => {
    event.preventDefault();
    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.setTitle(toolAppName);
  });
  mainWindow.once('ready-to-show', showMainWindow);
  mainWindow.webContents.once('did-finish-load', () => setTimeout(showMainWindow, 50));
  setTimeout(showMainWindow, 2000);
  mainWindow.webContents.on('render-process-gone', (_event, details) => {
    appendToolLog(`render-process-gone: ${JSON.stringify(details)}`);
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.reload();
    }
  });
  mainWindow.webContents.on('did-fail-load', (_event, errorCode, errorDescription, validatedURL) => {
    appendToolLog(`did-fail-load: ${errorCode} ${errorDescription} ${validatedURL}`);
  });
  mainWindow.on('close', event => {
    if (running && !allowQuitWhileRunning) {
      const payload = pollActiveSession();
      if (payload) {
        finishActiveSession({ ...payload, outputDir });
        return;
      }
      const pid = getKnownWorkerPid();
      if (!pid || !isProcessAlive(pid)) {
        markStaleRunStopped(`window close allowed because worker is not alive. pid=${pid || 'unknown'}`);
        return;
      }
      event.preventDefault();
      appendToolLog(`window close requested while worker is running; keep tool window open. pid=${pid}`);
      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.show();
        mainWindow.focus();
      }
    }
  });
  mainWindow.on('closed', () => {
    appendToolLog('window closed');
    mainWindow = null;
    if (running) {
      setTimeout(() => {
        if (!mainWindow) createWindow();
      }, 300);
    }
  });
}

function readNewWorkerLogs(workerLogFile) {
  if (!fs.existsSync(workerLogFile)) return;
  const stat = fs.statSync(workerLogFile);
  if (stat.size <= activeLogOffset) return;

  const fd = fs.openSync(workerLogFile, 'r');
  const buffer = Buffer.alloc(stat.size - activeLogOffset);
  fs.readSync(fd, buffer, 0, buffer.length, activeLogOffset);
  fs.closeSync(fd);
  activeLogOffset = stat.size;

  const lines = buffer.toString('utf8').split(/\r?\n/).filter(Boolean);
  for (const line of lines) {
    try {
      sendLog(JSON.parse(line));
    } catch {
      sendLog({ level: 'info', message: line });
    }
  }
}

function stopActivePoll() {
  if (activePollTimer) {
    clearInterval(activePollTimer);
    activePollTimer = null;
  }
}

function setActiveSession(sessionDir) {
  activeSessionDir = sessionDir;
  activeResultFile = path.join(sessionDir, 'result.json');
  activeWorkerLogFile = path.join(sessionDir, 'worker.log');
  activeStageStatusFile = path.join(sessionDir, 'stage-status.json');
  activeLogOffset = 0;
}

function readJsonFile(filePath) {
  try {
    if (!filePath || !fs.existsSync(filePath)) return null;
    return JSON.parse(fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, ''));
  } catch (error) {
    appendToolLog(`readJsonFile failed ${filePath}: ${error && error.message ? error.message : String(error)}`);
    return null;
  }
}

function readWorkerPidFromSession(sessionDir) {
  try {
    const pidFile = path.join(sessionDir, 'worker.pid');
    if (!fs.existsSync(pidFile)) return null;
    const parsed = Number(fs.readFileSync(pidFile, 'utf8').replace(/^\uFEFF/, '').trim());
    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
  } catch (error) {
    appendToolLog(`readWorkerPidFromSession failed: ${error && error.message ? error.message : String(error)}`);
    return null;
  }
}

function waitForWorkerPidFromSession(sessionDir, timeoutMs = 5000) {
  const started = Date.now();
  const sleepBuffer = new SharedArrayBuffer(4);
  const sleepView = new Int32Array(sleepBuffer);
  while (Date.now() - started < timeoutMs) {
    const pid = readWorkerPidFromSession(sessionDir);
    if (pid) return pid;
    Atomics.wait(sleepView, 0, 0, 100);
  }
  return null;
}

function makeJobsFailure(jobs, sessionDir, message) {
  const safeJobs = Array.isArray(jobs) ? jobs : [];
  return {
    success: false,
    results: safeJobs.map(job => ({
      id: job.id,
      brandName: job.brandName,
      version: job.version,
      success: false,
      outputDir,
      buildOutputFile: sessionDir ? path.join(sessionDir, 'build-output.log') : '',
      artifacts: [],
      message,
    })),
    outputDir,
    message,
  };
}

function getKnownWorkerPid() {
  const state = readState();
  if (currentProcess && currentProcess.pid) return currentProcess.pid;
  if (state && state.pid) return state.pid;
  if (activeSessionDir) return readWorkerPidFromSession(activeSessionDir);
  if (state && state.sessionDir) return readWorkerPidFromSession(state.sessionDir);
  return null;
}

function repairStaleRunningState() {
  const state = readState();
  if (!state || !state.running || !state.sessionDir) return null;

  const resultPath = state.resultFile || path.join(state.sessionDir, 'result.json');
  if (fs.existsSync(resultPath)) return null;

  const pid = state.pid || readWorkerPidFromSession(state.sessionDir);
  if (pid && isProcessAlive(pid)) return null;
  const launcherStartedAt = state.launcherStartedAt ? Date.parse(state.launcherStartedAt) : 0;
  if (!pid && launcherStartedAt && Date.now() - launcherStartedAt < 15000) return null;

  if (activeSessionDir !== state.sessionDir) {
    setActiveSession(state.sessionDir);
  }

  const failed = makeMissingResultFailure({
    ...state,
    pid,
  });
  finishActiveSession(failed);
  return failed;
}

function markStaleRunStopped(message) {
  stopActivePoll();
  running = false;
  currentProcess = null;
  writeState({
    ...(readState() || {}),
    running: false,
    stoppedAt: new Date().toISOString(),
    outputDir,
    sessionDir: activeSessionDir,
    message,
  });
  appendToolLog(message);
}

function pollActiveSession() {
  if (!activeSessionDir) return null;
  readNewWorkerLogs(activeWorkerLogFile);
  if (!fs.existsSync(activeResultFile)) return null;
  try {
    return JSON.parse(fs.readFileSync(activeResultFile, 'utf8'));
  } catch (error) {
    return {
      success: false,
      results: latestResults,
      outputDir,
      message: error && error.message ? error.message : String(error),
    };
  }
}

function makeMissingResultFailure(state) {
  const stage = readJsonFile(path.join(state.sessionDir, 'stage-status.json')) || readJsonFile(activeStageStatusFile);
  const jobs = Array.isArray(state.jobs) ? state.jobs : [];
  const firstJob = jobs[0] || {};
  const stageText = stage && stage.stage ? ` Last stage: ${stage.stage} (${stage.status || 'unknown'}).` : '';
  const message = `Worker process ${state.pid || 'unknown'} stopped without producing result.json.${stageText} See ${state.workerLogFile || activeWorkerLogFile}`;
  return {
    success: false,
    results: jobs.length > 0 ? jobs.map(job => ({
      id: job.id,
      brandName: job.brandName,
      version: job.version,
      success: false,
      outputDir,
      buildOutputFile: path.join(state.sessionDir, 'build-output.log'),
      artifacts: [],
      message,
      stage,
    })) : [{
      id: firstJob.id || 'oem-0',
      brandName: firstJob.brandName || 'OEM',
      success: false,
      outputDir,
      buildOutputFile: path.join(state.sessionDir, 'build-output.log'),
      artifacts: [],
      message,
      stage,
    }],
    outputDir,
    message,
  };
}

function finishActiveSession(payload) {
  stopActivePoll();
  latestResults = payload.results || [];
  running = false;
  currentProcess = null;
  clearStateIfFinished(payload);
  sendLog({ level: payload.success ? 'info' : 'error', message: payload.message || 'Build queue finished' });
}

function finishStartupFailure(jobs, sessionDir, message) {
  finishActiveSession(makeJobsFailure(jobs, sessionDir, message));
}

function findNodeExe() {
  const candidates = [
    process.env.npm_node_execpath,
    process.env.NODE_EXE,
  ].filter(Boolean);

  for (const candidate of candidates) {
    if (fs.existsSync(candidate)) return candidate;
  }

  const result = spawnSync('where.exe', ['node.exe'], {
    cwd: projectRoot,
    encoding: 'utf8',
    windowsHide: true,
  });
  const found = String(result.stdout || '')
    .split(/\r?\n/)
    .map(line => line.trim())
    .find(Boolean);
  if (found && fs.existsSync(found)) return found;
  return 'node.exe';
}

function launchDetachedWorker(workerPath, relativeJobsFile, relativeSessionDir) {
  const sessionDir = path.resolve(projectRoot, relativeSessionDir);
  fs.mkdirSync(sessionDir, { recursive: true });

  const nodeExe = findNodeExe();
  const stdoutFd = fs.openSync(path.join(sessionDir, 'worker-main.stdout.log'), 'a');
  const stderrFd = fs.openSync(path.join(sessionDir, 'worker-main.stderr.log'), 'a');
  appendToolLog(`launchDetachedWorker node=${nodeExe} worker=${workerPath} jobs=${relativeJobsFile} session=${relativeSessionDir}`);
  const worker = spawn(nodeExe, [workerPath, relativeJobsFile, relativeSessionDir], {
    cwd: projectRoot,
    windowsHide: true,
    detached: true,
    stdio: ['ignore', stdoutFd, stderrFd],
  });
  fs.closeSync(stdoutFd);
  fs.closeSync(stderrFd);

  if (!worker.pid) {
    throw new Error('Build worker did not return a PID.');
  }
  fs.writeFileSync(path.join(sessionDir, 'worker.pid'), String(worker.pid), 'utf8');
  worker.unref();

  return {
    launcherPid: null,
    workerPid: worker.pid,
  };
}

function startActivePoll() {
  stopActivePoll();
  activePollTimer = setInterval(() => {
    const payload = pollActiveSession();
    if (payload) {
      finishActiveSession({ ...payload, outputDir });
    }
  }, 700);
}

function isProcessAlive(pid) {
  if (!pid) return false;
  try {
    process.kill(Number(pid), 0);
    return true;
  } catch {
    return false;
  }
}

ipcMain.handle('oem-tool:diagnostic', async (_event, payload) => {
  const message = payload && payload.message ? payload.message : 'renderer diagnostic';
  appendToolLog(`renderer diagnostic: ${message} ${safeJson(payload && payload.payload ? payload.payload : {})}`);
  return { ok: true };
});

ipcMain.handle('oem-tool:pick-image', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openFile'],
    filters: [{ name: 'Images', extensions: ['png', 'jpg', 'jpeg', 'webp', 'ico', 'icns'] }],
  });
  if (result.canceled) return null;
  return result.filePaths[0] || null;
});

ipcMain.handle('oem-tool:run-batch', async (_event, jobs) => {
  appendToolLog(`run-batch invoked jobs=${Array.isArray(jobs) ? jobs.length : 'invalid'}`);
  if (running) {
    appendToolLog('run-batch rejected: already running');
    return { success: false, message: 'Build queue is already running', results: latestResults, outputDir };
  }
  if (!Array.isArray(jobs) || jobs.length === 0) {
    appendToolLog('run-batch rejected: no jobs');
    return { success: false, message: 'No OEM jobs selected', results: [], outputDir };
  }

  const sessionDir = path.join(__dirname, 'runs', `${Date.now()}`);
  const jobsFile = path.join(sessionDir, 'jobs.json');

  try {
    fs.mkdirSync(sessionDir, { recursive: true });
    fs.writeFileSync(jobsFile, JSON.stringify(jobs, null, 2), 'utf8');

    running = true;
    latestResults = [];
    setActiveSession(sessionDir);

    const relativeSessionDir = path.relative(projectRoot, sessionDir);
    const relativeJobsFile = path.relative(projectRoot, jobsFile);
    const workerPath = path.join('tools', 'oem-batch-builder', 'worker.cjs');

    writeState({
      running: true,
      startedAt: new Date().toISOString(),
      pid: null,
      launcherPid: null,
      outputDir,
      sessionDir,
      jobsFile,
      resultFile: activeResultFile,
      workerLogFile: activeWorkerLogFile,
      stageStatusFile: activeStageStatusFile,
      jobs,
      message: 'Starting worker',
      launcherStartedAt: new Date().toISOString(),
    });
    appendToolLog(`run-batch state written session=${sessionDir}`);

    const launchInfo = launchDetachedWorker(workerPath, relativeJobsFile, relativeSessionDir);
    const workerPid = launchInfo.workerPid || readWorkerPidFromSession(sessionDir);
    appendToolLog(`run-batch launchDetachedWorker returned launcherPid=${launchInfo.launcherPid} workerPid=${workerPid || ''}`);
    currentProcess = workerPid ? { pid: workerPid } : null;

    writeState({
      ...(readState() || {}),
      running: true,
      pid: workerPid || null,
      launcherPid: launchInfo.launcherPid,
      outputDir,
      sessionDir,
      jobsFile,
      resultFile: activeResultFile,
      workerLogFile: activeWorkerLogFile,
      stageStatusFile: activeStageStatusFile,
      jobs,
      launcherStartedAt: new Date().toISOString(),
      message: workerPid ? `Worker started. pid=${workerPid}` : `Worker launcher started. launcherPid=${launchInfo.launcherPid}`,
    });
    sendLog({ level: 'info', message: workerPid ? `Started background worker. pid=${workerPid} jobs=${jobs.length}` : `Started worker launcher. pid=${launchInfo.launcherPid} jobs=${jobs.length}` });
    appendToolLog(`background worker launcherPid=${launchInfo.launcherPid} workerPid=${workerPid || ''} worker=${workerPath} jobs=${relativeJobsFile}`);
    startActivePoll();
    appendToolLog(`run-batch accepted session=${sessionDir} launcherPid=${launchInfo.launcherPid} workerPid=${workerPid || ''}`);
    return {
      success: true,
      accepted: true,
      running: true,
      sessionDir,
      outputDir,
      message: `Build started. Logs: ${activeWorkerLogFile}`,
      results: [],
    };
  } catch (error) {
    const message = `Failed to start build worker: ${error && error.message ? error.message : String(error)}`;
    appendToolLog(`${message}\n${error && error.stack ? error.stack : ''}`);
    if (running || activeSessionDir === sessionDir) {
      finishStartupFailure(jobs, sessionDir, message);
    } else {
      appendToolLog(message);
    }
    return { success: false, running: false, outputDir, message, results: latestResults };
  }
});

ipcMain.handle('oem-tool:get-status', async () => {
  const staleFailure = repairStaleRunningState();
  if (staleFailure) {
    return {
      running: false,
      results: staleFailure.results || [],
      outputDir,
      sessionDir: activeSessionDir,
      message: staleFailure.message,
    };
  }

  const state = readState();
  if (state && state.running && state.sessionDir) {
    if (!fs.existsSync(state.sessionDir)) {
      const failed = {
        success: false,
        results: [],
        outputDir,
        message: `Previous build state points to a missing session directory: ${state.sessionDir}`,
      };
      finishActiveSession(failed);
      return { running: false, results: [], outputDir, sessionDir: state.sessionDir, message: failed.message };
    }
    if (!state.pid) {
      const workerPid = readWorkerPidFromSession(state.sessionDir);
      if (workerPid) {
        state.pid = workerPid;
        writeState({ ...state, pid: workerPid });
      } else {
        const launcherStartedAt = state.launcherStartedAt ? Date.parse(state.launcherStartedAt) : 0;
        if (launcherStartedAt && Date.now() - launcherStartedAt < 15000) {
          return { running: true, results: latestResults, outputDir, sessionDir: state.sessionDir, workerLogFile: state.workerLogFile, message: 'Worker launcher is starting' };
        }
        const failed = makeMissingResultFailure(state);
        finishActiveSession(failed);
        return { running: false, results: failed.results, outputDir, sessionDir: state.sessionDir, message: failed.message };
      }
    }
    if (activeSessionDir !== state.sessionDir) {
      setActiveSession(state.sessionDir);
      running = true;
      startActivePoll();
    }
    const payload = pollActiveSession();
    if (payload) {
      finishActiveSession({ ...payload, outputDir });
      return { running: false, results: latestResults, outputDir, sessionDir: state.sessionDir };
    }
    if (state.pid && !isProcessAlive(state.pid)) {
      const failed = makeMissingResultFailure(state);
      finishActiveSession(failed);
      return { running: false, results: failed.results, outputDir, sessionDir: state.sessionDir, message: failed.message };
    }
    return { running: true, results: latestResults, outputDir, sessionDir: state.sessionDir, workerLogFile: state.workerLogFile, stage: readJsonFile(state.stageStatusFile) };
  }
  return { running, results: latestResults, outputDir, sessionDir: activeSessionDir };
});

ipcMain.handle('oem-tool:cancel', async () => {
  const state = readState();
  const pid = currentProcess && currentProcess.pid ? currentProcess.pid : state && state.pid;
  if (!pid) return { success: false, message: 'No running build process' };
  spawn('taskkill', ['/F', '/T', '/PID', String(pid)], { windowsHide: true, stdio: 'ignore' });
  stopActivePoll();
  currentProcess = null;
  running = false;
  writeState({ running: false, cancelledAt: new Date().toISOString(), outputDir, sessionDir: activeSessionDir });
  sendLog({ level: 'warn', message: 'Build worker cancelled' });
  return { success: true };
});

ipcMain.handle('oem-tool:open-output-dir', async () => {
  fs.mkdirSync(outputDir, { recursive: true });
  await shell.openPath(outputDir);
  return { success: true, outputDir };
});

app.on('second-instance', () => {
  appendToolLog('second-instance received');
  if (!mainWindow || mainWindow.isDestroyed()) {
    createWindow();
    return;
  }
  if (mainWindow.isMinimized()) mainWindow.restore();
  mainWindow.center();
  mainWindow.show();
  mainWindow.focus();
});

if (gotSingleInstanceLock) {
  app.whenReady().then(() => {
    appendToolLog(`app ready pid=${process.pid}`);
    createWindow();
  }).catch(error => {
    appendToolLog(`app ready failed: ${error && error.stack ? error.stack : error}`);
  });
}
app.on('will-quit', () => {
  appendToolLog(`app will-quit running=${running} activeSession=${activeSessionDir || ''}`);
});
app.on('quit', (_event, exitCode) => {
  appendToolLog(`app quit exitCode=${exitCode} running=${running} activeSession=${activeSessionDir || ''}`);
});
app.on('before-quit', event => {
  appendToolLog(`before-quit running=${running} allowQuitWhileRunning=${allowQuitWhileRunning}`);
  if (running) {
    if (!allowQuitWhileRunning) {
      event.preventDefault();
      appendToolLog('before-quit ignored while worker is running');
      if (!mainWindow || mainWindow.isDestroyed()) {
        createWindow();
      } else {
        if (mainWindow.isMinimized()) mainWindow.restore();
        mainWindow.show();
        mainWindow.focus();
      }
      return;
    }
    writeState({
      ...(readState() || {}),
      running: true,
      outputDir,
      sessionDir: activeSessionDir,
      resultFile: activeResultFile,
      workerLogFile: activeWorkerLogFile,
      stageStatusFile: activeStageStatusFile,
    });
  }
});
app.on('window-all-closed', () => {
  if (running && !allowQuitWhileRunning) {
    appendToolLog('window-all-closed ignored while worker is running');
    return;
  }
  app.quit();
});

process.on('uncaughtException', error => {
  appendToolLog(`uncaughtException: ${error && error.stack ? error.stack : error}`);
  sendLog({ level: 'error', message: `Tool error: ${error && error.message ? error.message : String(error)}` });
});

process.on('unhandledRejection', error => {
  appendToolLog(`unhandledRejection: ${error && error.stack ? error.stack : error}`);
  sendLog({ level: 'error', message: `Tool error: ${error && error.message ? error.message : String(error)}` });
});

process.on('SIGINT', () => {
  appendToolLog(`process SIGINT running=${running} activeSession=${activeSessionDir || ''}`);
});

process.on('SIGTERM', () => {
  appendToolLog(`process SIGTERM running=${running} activeSession=${activeSessionDir || ''}`);
});

process.on('beforeExit', code => {
  appendToolLog(`process beforeExit code=${code} running=${running} activeSession=${activeSessionDir || ''}`);
});

process.on('exit', code => {
  appendToolLog(`process exit code=${code} running=${running} activeSession=${activeSessionDir || ''}`);
});