main.js

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

// --- Config file management (lazy init - must not call app.getPath before ready) ---
let configDir = null;
let configPath = null;

function getConfigDir() {
  if (!configDir) {
    configDir = app.getPath('userData');
  }
  return configDir;
}

function getConfigPath() {
  if (!configPath) {
    configPath = path.join(getConfigDir(), 'config.json');
  }
  return configPath;
}

function getDefaultConfig() {
  return { registry: [], workspaces: [] };
}

function loadConfig() {
  const cfgPath = getConfigPath();
  const cfgDir = getConfigDir();
  try {
    if (!fs.existsSync(cfgPath)) {
      fs.mkdirSync(cfgDir, { recursive: true });
      fs.writeFileSync(cfgPath, JSON.stringify(getDefaultConfig(), null, 2));
    }
    const raw = fs.readFileSync(cfgPath, 'utf-8');
    const config = JSON.parse(raw);
    if (!Array.isArray(config.registry)) config.registry = [];
    if (!Array.isArray(config.workspaces)) config.workspaces = [];
    return config;
  } catch (e) {
    try {
      if (fs.existsSync(cfgPath)) {
        fs.copyFileSync(cfgPath, cfgPath + '.backup');
      }
    } catch (_) {}
    const def = getDefaultConfig();
    fs.writeFileSync(cfgPath, JSON.stringify(def, null, 2));
    return def;
  }
}

function saveConfig(config) {
  fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2));
}

// --- Window ---
let mainWindow;

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 900,
    height: 620,
    minWidth: 700,
    minHeight: 500,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
    },
    icon: undefined,
    title: 'Git Workspace Manager',
  });
  mainWindow.setMenuBarVisibility(false);
  mainWindow.loadFile('index.html');

  // Forward git command logs to renderer
  git.setLogger((entry) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('git-log', entry);
    }
  });
}

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

// --- IPC Handlers ---

ipcMain.handle('get-config', () => loadConfig());

ipcMain.handle('save-config', (_e, config) => {
  saveConfig(config);
  return true;
});

// Add a single repo to registry by picking a folder
ipcMain.handle('pick-repo-folder', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory'],
    title: 'Select a Git Repository Folder',
  });
  if (result.canceled || result.filePaths.length === 0) return null;
  const dirPath = result.filePaths[0];
  try {
    const remoteUrl = await git.gitRemoteUrl(dirPath);
    const id = git.parseRepoId(remoteUrl);
    if (!id) return { error: 'Could not parse org/repo from remote URL: ' + remoteUrl };
    return { id, localPath: dirPath };
  } catch (e) {
    return { error: e.message };
  }
});

// Scan a parent folder for git repos
ipcMain.handle('scan-folder', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory'],
    title: 'Select a Parent Folder to Scan for Repositories',
  });
  if (result.canceled || result.filePaths.length === 0) return [];
  const parentDir = result.filePaths[0];
  const entries = fs.readdirSync(parentDir, { withFileTypes: true });
  const found = [];
  for (const entry of entries) {
    if (!entry.isDirectory()) continue;
    const fullPath = path.join(parentDir, entry.name);
    const gitDir = path.join(fullPath, '.git');
    if (!fs.existsSync(gitDir)) continue;
    try {
      const remoteUrl = await git.gitRemoteUrl(fullPath);
      const id = git.parseRepoId(remoteUrl);
      if (id) found.push({ id, localPath: fullPath });
    } catch (_) {}
  }
  return found;
});

// Get status of a single repo (current branch + dirty)
ipcMain.handle('repo-status', async (_e, localPath) => {
  try {
    if (!fs.existsSync(localPath)) return { error: 'Path not found' };
    const [currentBranch, status] = await Promise.all([
      git.gitCurrentBranch(localPath),
      git.gitStatus(localPath),
    ]);
    return { currentBranch, dirty: status.length > 0 };
  } catch (e) {
    return { error: e.message };
  }
});

// Get branch list for a repo
ipcMain.handle('repo-branches', async (_e, localPath) => {
  try {
    return await git.gitBranchList(localPath);
  } catch (e) {
    return [];
  }
});

// Sync a single repo: fetch, optionally checkout, pull
ipcMain.handle('sync-repo', async (_e, localPath, branch) => {
  const steps = [];
  try {
    steps.push('Fetching...');
    await git.gitFetch(localPath);
    steps.push('Fetched');

    if (branch) {
      steps.push('Checking out ' + branch + '...');
      await git.gitCheckout(localPath, branch);
      steps.push('Checked out ' + branch);
    }

    steps.push('Pulling...');
    await git.gitPull(localPath);
    steps.push('Pulled');

    return { success: true, steps };
  } catch (e) {
    return { success: false, error: e.message, steps };
  }
});

// Export workspace dialog
ipcMain.handle('export-workspace', async (_e, data) => {
  const result = await dialog.showSaveDialog(mainWindow, {
    title: 'Export Workspace',
    defaultPath: data.name.replace(/[^a-zA-Z0-9]/g, '-') + '.json',
    filters: [{ name: 'JSON', extensions: ['json'] }],
  });
  if (result.canceled) return false;
  fs.writeFileSync(result.filePath, JSON.stringify(data, null, 2));
  return true;
});

// Import workspace dialog
ipcMain.handle('import-workspace', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    title: 'Import Workspace',
    filters: [{ name: 'JSON', extensions: ['json'] }],
    properties: ['openFile'],
  });
  if (result.canceled || result.filePaths.length === 0) return null;
  try {
    const raw = fs.readFileSync(result.filePaths[0], 'utf-8');
    return JSON.parse(raw);
  } catch (e) {
    return { error: 'Invalid JSON file: ' + e.message };
  }
});

// Check git availability on startup
ipcMain.handle('check-git', async () => {
  try {
    await git.gitVersion();
    return true;
  } catch (_) {
    return false;
  }
});