main.js

const { app, BrowserWindow, ipcMain, dialog } = require('electron');
const path = require('path');
const fs = require('fs');
const yauzl = require('yauzl');

let mainWindow = null;
let progressWindow = null;

function createMainWindow() {
  mainWindow = new BrowserWindow({
    width: 720,
    height: 640,
    minWidth: 560,
    minHeight: 520,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
    },
    title: 'Simple Unzipper — Anakatech',
    backgroundColor: '#0f1419',
    show: false,
  });
  mainWindow.loadFile(path.join(__dirname, 'src', 'renderer', 'index.html'));
  mainWindow.once('ready-to-show', () => {
    mainWindow.show();
    mainWindow.focus();
  });
  mainWindow.on('closed', () => { mainWindow = null; });
}

function createProgressWindow(parent) {
  if (progressWindow) {
    progressWindow.focus();
    return progressWindow;
  }
  progressWindow = new BrowserWindow({
    width: 480,
    height: 320,
    parent,
    modal: true,
    resizable: false,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
    },
    backgroundColor: '#0f1419',
    show: false,
  });
  progressWindow.loadFile(path.join(__dirname, 'src', 'renderer', 'progress.html'));
  progressWindow.once('ready-to-show', () => progressWindow.show());
  progressWindow.on('closed', () => {
    progressWindow = null;
    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.focus();
  });
  return progressWindow;
}

// Normalize zip entry path to use OS separators (handles / and \)
function normalizeEntryPath(fileName) {
  return fileName.split(/[/\\]/).filter(Boolean).join(path.sep);
}

// MS-DOS directory attribute bit in zip external file attributes
const FILE_ATTR_DIR = 0x10;

function extractZip(zipPath, outDir) {
  return new Promise((resolve, reject) => {
    yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
      if (err) return reject(err);
      zipfile.readEntry();
      zipfile.on('entry', (entry) => {
        const rawName = entry.fileName;
        const normalizedName = normalizeEntryPath(rawName.replace(/[/\\]+$/, ''));
        if (!normalizedName) {
          zipfile.readEntry();
          return;
        }
        const destPath = path.join(outDir, normalizedName);
        const hasTrailingSlash = /[/\\]$/.test(rawName);
        const isDirByAttr = entry.uncompressedSize === 0 && (entry.externalFileAttributes & FILE_ATTR_DIR) === FILE_ATTR_DIR;
        const isDirectory = hasTrailingSlash || isDirByAttr;

        if (isDirectory || (entry.uncompressedSize === 0 && !path.extname(normalizedName))) {
          fs.mkdirSync(destPath, { recursive: true });
          zipfile.readEntry();
          return;
        }
        fs.mkdirSync(path.dirname(destPath), { recursive: true });
        zipfile.openReadStream(entry, (e, readStream) => {
          if (e) {
            zipfile.readEntry();
            return;
          }
          const writeStream = fs.createWriteStream(destPath);
          readStream.pipe(writeStream);
          writeStream.on('finish', () => {
            writeStream.close();
            zipfile.readEntry();
          });
        });
      });
      zipfile.on('end', () => resolve());
      zipfile.on('error', reject);
    });
  });
}

async function unzipAll(sourceDir, destDir) {
  const names = fs.readdirSync(sourceDir);
  const zipFiles = names.filter((n) => /\.(zip|ZIP)$/.test(path.extname(n)));
  const results = { total: zipFiles.length, done: 0, errors: [] };
  if (zipFiles.length === 0) {
    if (progressWindow && !progressWindow.isDestroyed()) {
      progressWindow.webContents.send('unzip-complete', results);
    }
    return results;
  }
  for (const name of zipFiles) {
    const zipPath = path.join(sourceDir, name);
    const folderName = path.basename(name, path.extname(name));
    const outDirForZip = path.join(destDir, folderName);
    try {
      await extractZip(zipPath, outDirForZip);
      results.done++;
      if (progressWindow && !progressWindow.isDestroyed()) {
        progressWindow.webContents.send('unzip-progress', results);
      }
    } catch (e) {
      results.errors.push({ file: name, message: e.message });
    }
  }
  return results;
}

ipcMain.handle('select-dir', async (event, which) => {
  const win = BrowserWindow.getFocusedWindow() || BrowserWindow.fromWebContents(event.sender);
  const result = await dialog.showOpenDialog(win || mainWindow, {
    properties: ['openDirectory'],
    title: which === 'source' ? 'Select folder containing ZIP files' : 'Select folder for unzipped files',
  });
  return result.canceled ? null : result.filePaths[0];
});

ipcMain.handle('start-unzip', async (_, sourceDir, destDir) => {
  const win = BrowserWindow.getFocusedWindow();
  if (!sourceDir || !destDir) throw new Error('Please select both source and destination folders.');
  if (!fs.existsSync(sourceDir)) throw new Error('Source folder does not exist.');
  fs.mkdirSync(destDir, { recursive: true });

  createProgressWindow(win);
  progressWindow.webContents.once('did-finish-load', async () => {
    try {
      const results = await unzipAll(sourceDir, destDir);
      if (progressWindow && !progressWindow.isDestroyed()) {
        progressWindow.webContents.send('unzip-complete', results);
      }
    } catch (e) {
      if (progressWindow && !progressWindow.isDestroyed()) {
        progressWindow.webContents.send('unzip-error', e.message);
      }
    }
  });
  return { ok: true };
});

ipcMain.handle('close-progress', () => {
  if (progressWindow && !progressWindow.isDestroyed()) progressWindow.close();
});

app.whenReady().then(createMainWindow);
app.on('window-all-closed', () => app.quit());