main.js

const { app, BrowserWindow, Tray, Menu, ipcMain, globalShortcut, clipboard, nativeImage, dialog, screen, desktopCapturer } = require('electron');
const path = require('path');
const fs = require('fs');
const { exec } = require('child_process');
const { promisify } = require('util');
const execAsync = promisify(exec);

// Manejo de instancia única para abrir la ventana al seleccionar en el menú del sistema
const gotTheLock = app.requestSingleInstanceLock();

// Desactivar aceleración por hardware en Linux para solucionar pantalla negra en ventanas transparentes (overlay)
app.disableHardwareAcceleration();
app.commandLine.appendSwitch('enable-transparent-visuals');

if (!gotTheLock) {
  app.quit();
} else {
  app.on('second-instance', () => {
    if (editorWindow) {
      if (editorWindow.isMinimized()) editorWindow.restore();
      editorWindow.show();
      editorWindow.focus();
    }
  });
}

let tray = null;
let editorWindow = null;
let overlayWindow = null;
let currentScreenshotDataUrl = null;

function getCombinedDisplayBounds() {
  const displays = screen.getAllDisplays();
  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
  displays.forEach((display) => {
    const { x, y, width, height } = display.bounds;
    minX = Math.min(minX, x);
    minY = Math.min(minY, y);
    maxX = Math.max(maxX, x + width);
    maxY = Math.max(maxY, y + height);
  });
  return {
    x: minX,
    y: minY,
    width: maxX - minX,
    height: maxY - minY
  };
}

function createEditorWindow() {
  const primaryDisplay = screen.getPrimaryDisplay();
  const { width, height } = primaryDisplay.workAreaSize;

  editorWindow = new BrowserWindow({
    width: Math.min(1400, width),
    height: Math.min(900, height),
    minWidth: 400,
    minHeight: 200,
    icon: path.join(__dirname, 'icon128.png'),
    title: 'ScreenShot - Editor de Capturas',
    show: false,
    frame: false,
    autoHideMenuBar: true,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true,
      sandbox: false
    }
  });

  editorWindow.loadFile(path.join(__dirname, 'index.html'));

  editorWindow.on('close', (e) => {
    if (!app.isQuitting) {
      e.preventDefault();
      editorWindow.hide();
    }
  });
}

// Obtener captura de pantalla cruda en vivo del escritorio completo
async function captureDesktopRaw() {
  if (editorWindow && editorWindow.isVisible()) {
    editorWindow.hide();
  }
  if (overlayWindow && !overlayWindow.isDestroyed()) {
    overlayWindow.hide();
  }

  // Ocultar temporalmente el menú emergente del tray para no capturarlo en pantalla
  if (tray) {
    tray.setContextMenu(Menu.buildFromTemplate([]));
  }

  // Esperar 250ms para que el gestor de ventanas del SO cierre la ventana del menú contextual
  await new Promise((resolve) => setTimeout(resolve, 250));

  const tempFilePath = path.join(app.getPath('temp'), `screenshot_${Date.now()}.png`);
  let capturedDataUrl = null;
  let captured = false;

  // Intento 1: Herramientas CLI del sistema que capturan la pantalla completa con todas las ventanas activas
  try {
    await execAsync(`import -window root "${tempFilePath}" || gnome-screenshot -f "${tempFilePath}" || maim "${tempFilePath}" || scrot --multidisp "${tempFilePath}" || scrot -z "${tempFilePath}"`);
    if (fs.existsSync(tempFilePath) && fs.statSync(tempFilePath).size > 0) {
      const imageBuffer = fs.readFileSync(tempFilePath);
      capturedDataUrl = `data:image/png;base64,${imageBuffer.toString('base64')}`;
      fs.unlinkSync(tempFilePath);
      captured = true;
    }
  } catch (err) {
    console.error('Error en captura CLI:', err);
  }

  // Intento 2: Fallback nativo desktopCapturer de Electron si fallan las herramientas del sistema
  if (!captured) {
    try {
      const bounds = getCombinedDisplayBounds();
      const primaryDisplay = screen.getPrimaryDisplay();
      const scaleFactor = primaryDisplay.scaleFactor || 1;
      const sources = await desktopCapturer.getSources({
        types: ['screen'],
        thumbnailSize: {
          width: Math.round(bounds.width * scaleFactor),
          height: Math.round(bounds.height * scaleFactor)
        }
      });
      if (sources && sources.length > 0) {
        capturedDataUrl = sources[0].thumbnail.toDataURL();
        captured = true;
      }
    } catch (err) {
      console.error('Error en captura nativa desktopCapturer:', err);
    }
  }

  // Restaurar el menú contextual del tray
  if (tray) {
    setupTrayMenu();
  }

  return captured ? capturedDataUrl : null;
}

function createOverlayWindow() {
  if (overlayWindow && !overlayWindow.isDestroyed()) return;

  const bounds = getCombinedDisplayBounds();
  overlayWindow = new BrowserWindow({
    x: bounds.x,
    y: bounds.y,
    width: bounds.width,
    height: bounds.height,
    hasShadow: false,
    frame: false,
    transparent: true,
    backgroundColor: '#00000000',
    alwaysOnTop: true,
    skipTaskbar: true,
    resizable: false,
    movable: false,
    show: false,
    enableLargerThanScreen: true,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true,
      sandbox: false
    }
  });

  overlayWindow.setAlwaysOnTop(true, 'screen-saver');
  overlayWindow.loadFile(path.join(__dirname, 'overlay.html'));

  overlayWindow.on('close', (e) => {
    if (!app.isQuitting) {
      e.preventDefault();
      overlayWindow.hide();
    }
  });
}

function showOverlayWithImage(rawDataUrl) {
  const bounds = getCombinedDisplayBounds();
  if (!overlayWindow || overlayWindow.isDestroyed()) {
    createOverlayWindow();
    overlayWindow.webContents.once('did-finish-load', () => {
      overlayWindow.setBounds(bounds);
      overlayWindow.webContents.send('load-overlay', rawDataUrl);
      overlayWindow.show();
      overlayWindow.focus();
    });
  } else {
    overlayWindow.setBounds(bounds);
    overlayWindow.webContents.send('load-overlay', rawDataUrl);
    overlayWindow.show();
    overlayWindow.focus();
  }
}

// Captura de área interactiva (F9 / PrintScreen)
let isCapturing = false;

async function captureArea() {
  if (isCapturing) return;
  isCapturing = true;
  try {
    const rawDataUrl = await captureDesktopRaw();
    if (!rawDataUrl) {
      console.error('No se pudo capturar la pantalla para la selección de área.');
      return;
    }

    showOverlayWithImage(rawDataUrl);
  } finally {
    isCapturing = false;
  }
}

// Captura completa del escritorio sin selección previa
async function captureFullDesktop() {
  const rawDataUrl = await captureDesktopRaw();
  if (rawDataUrl) {
    currentScreenshotDataUrl = rawDataUrl;
    showEditorWithImage(currentScreenshotDataUrl);
  } else {
    console.error('No se pudo realizar la captura de pantalla completa.');
  }
}

function showEditorWithImage(dataUrl) {
  currentScreenshotDataUrl = dataUrl;
  if (!editorWindow) {
    createEditorWindow();
  }
  editorWindow.show();
  editorWindow.maximize();
  editorWindow.focus();
  editorWindow.webContents.send('load-screenshot', dataUrl);
}

function setupTrayMenu() {
  if (!tray) return;
  const contextMenu = Menu.buildFromTemplate([
    {
      label: '✂️ Seleccionar área de captura (F9)',
      click: () => captureArea()
    },
    {
      label: '📸 Tomar captura completa',
      click: () => captureFullDesktop()
    },
    {
      label: '🎨 Abrir editor',
      click: () => {
        if (!editorWindow) createEditorWindow();
        editorWindow.show();
        editorWindow.focus();
        if (currentScreenshotDataUrl) {
          editorWindow.webContents.send('load-screenshot', currentScreenshotDataUrl);
        }
      }
    },
    { type: 'separator' },
    {
      label: '❌ Salir',
      click: () => {
        app.isQuitting = true;
        app.quit();
      }
    }
  ]);
  tray.setContextMenu(contextMenu);
}

function createSystray() {
  const iconPath = path.join(__dirname, 'icon128.png');
  const trayIcon = nativeImage.createFromPath(iconPath).resize({ width: 22, height: 22 });

  tray = new Tray(trayIcon);
  tray.setToolTip('ScreenShot - Captura y Anotación de Pantalla');
  setupTrayMenu();
  tray.on('click', () => captureArea());
}

function removeAutostartLinux() {
  try {
    app.setLoginItemSettings({ openAtLogin: false });
    if (process.platform === 'linux') {
      const autostartFile = path.join(app.getPath('home'), '.config', 'autostart', 'screenshot.desktop');
      if (fs.existsSync(autostartFile)) {
        fs.unlinkSync(autostartFile);
      }
    }
  } catch (err) {
    console.error('Error al remover autostart:', err);
  }
}

// --- Atajos globales con protección contra conflictos de XGrabKey en Linux ---
// En Linux/X11 con múltiples layouts de teclado, XGrabKey puede capturar
// keycodes no deseados (como la tecla "1"). Se registran los atajos solo
// cuando ninguna ventana de la app tiene el foco, y se liberan al enfocar.
let shortcutsRegistered = false;

function registerGlobalShortcuts() {
  if (shortcutsRegistered) return;
  try {
    globalShortcut.register('F9', () => captureArea());
    globalShortcut.register('CommandOrControl+Shift+S', () => captureArea());
    shortcutsRegistered = true;
    console.log('Atajo global F9 (y Ctrl+Shift+S) registrado activamente.');
  } catch (err) {
    console.log('Error al registrar atajos globales:', err);
  }
}

app.whenReady().then(() => {
  createSystray();
  createEditorWindow();
  removeAutostartLinux();

  registerGlobalShortcuts();
});

app.on('will-quit', () => {
  globalShortcut.unregisterAll();
});

app.on('window-all-closed', (e) => {
  e.preventDefault();
});

// Handlers IPC
ipcMain.on('take-screenshot', () => {
  captureArea();
});

ipcMain.on('take-area-screenshot', () => {
  captureArea();
});

ipcMain.on('cropped-image-captured', (event, croppedDataUrl) => {
  if (overlayWindow && !overlayWindow.isDestroyed()) {
    overlayWindow.close();
    overlayWindow = null;
  }
  showEditorWithImage(croppedDataUrl);
});

ipcMain.on('close-overlay', () => {
  if (overlayWindow && !overlayWindow.isDestroyed()) {
    overlayWindow.close();
    overlayWindow = null;
  }
});

ipcMain.on('close-editor', () => {
  if (editorWindow) editorWindow.hide();
});

ipcMain.on('minimize-editor', () => {
  if (editorWindow) editorWindow.minimize();
});

ipcMain.on('maximize-editor', () => {
  if (editorWindow) {
    if (editorWindow.isMaximized()) {
      editorWindow.unmaximize();
    } else {
      editorWindow.maximize();
    }
  }
});

ipcMain.handle('copy-to-clipboard', async (event, dataUrl) => {
  try {
    const image = nativeImage.createFromDataURL(dataUrl);
    clipboard.writeImage(image);
    return { success: true };
  } catch (err) {
    console.error('Error al copiar al portapapeles:', err);
    return { success: false, error: err.message };
  }
});

ipcMain.handle('open-image-file', async () => {
  try {
    const { canceled, filePaths } = await dialog.showOpenDialog(editorWindow, {
      title: 'Abrir Imagen para Editar',
      defaultPath: app.getPath('pictures'),
      properties: ['openFile'],
      filters: [
        { name: 'Imágenes', extensions: ['png', 'jpg', 'jpeg', 'webp', 'bmp', 'gif'] }
      ]
    });
    if (canceled || !filePaths || filePaths.length === 0) {
      return { success: false, canceled: true };
    }
    const filePath = filePaths[0];
    const imageBuffer = fs.readFileSync(filePath);
    const ext = path.extname(filePath).toLowerCase().replace('.', '');
    const mimeType = ext === 'png' ? 'image/png' : (ext === 'webp' ? 'image/webp' : 'image/jpeg');
    const dataUrl = `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
    return { success: true, dataUrl, filePath };
  } catch (err) {
    console.error('Error al abrir imagen desde disco:', err);
    return { success: false, error: err.message };
  }
});

ipcMain.handle('select-directory', async () => {
  try {
    const { canceled, filePaths } = await dialog.showOpenDialog(editorWindow, {
      title: 'Seleccionar Carpeta para Guardar Capturas',
      properties: ['openDirectory', 'createDirectory']
    });
    if (canceled || !filePaths || filePaths.length === 0) {
      return { success: false, canceled: true };
    }
    return { success: true, path: filePaths[0] };
  } catch (err) {
    console.error('Error al seleccionar directorio:', err);
    return { success: false, error: err.message };
  }
});

ipcMain.handle('save-image', async (event, dataUrl, defaultDir) => {
  try {
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
    const defaultName = `ScreenShot_${timestamp}.png`;
    const targetDir = (defaultDir && fs.existsSync(defaultDir)) ? defaultDir : app.getPath('pictures');

    const { canceled, filePath } = await dialog.showSaveDialog(editorWindow, {
      title: 'Guardar Captura de Pantalla',
      defaultPath: path.join(targetDir, defaultName),
      filters: [{ name: 'Imágenes PNG', extensions: ['png'] }]
    });

    if (canceled || !filePath) return { success: false, canceled: true };

    const base64Data = dataUrl.replace(/^data:image\/png;base64,/, '');
    fs.writeFileSync(filePath, base64Data, 'base64');
    return { success: true, filePath };
  } catch (err) {
    console.error('Error al guardar la imagen:', err);
    return { success: false, error: err.message };
  }
});