main.js

const { app, BrowserWindow, ipcMain, Menu, Tray, nativeImage, shell } = require('electron');
const path = require('path');
const fs = require('fs');
const http = require('http');
const crypto = require('crypto');
const { google } = require('googleapis');
const { OAuth2Client } = require('google-auth-library');

let oauth2Client = null;
let drive = null;

const isDev = process.env.VITE_DEV_SERVER_URL;
const RESOURCES_PATH = isDev 
  ? path.join(__dirname, '..') 
  : process.resourcesPath;
const APP_ICON_PATH = path.join(__dirname, '..', 'public', 'icon.svg');
const CREDENTIALS_PATH = path.join(RESOURCES_PATH, 'credentials.json');
const TOKEN_PATH = path.join(app.getPath('userData'), 'token.json');
const UPLOADED_FILES_PATH = path.join(app.getPath('userData'), 'uploaded-files.json');
const RECENT_FILES_PATH = path.join(app.getPath('userData'), 'recent-files.json');

let mainWindow = null;
let tray = null;
let isAppReady = false;
let pendingFile = null;
let isHandlingFile = false;
let lastFileOpenRequestAt = 0;
let suppressInitialWindowUntil = Date.now() + 10000;
let isQuitting = false;
let oauthServerState = null;

// Track uploaded files to prevent duplicates
let uploadedFiles = new Map(); // filePath -> { id, webViewLink, uploadedAt }
let recentFiles = [];

function configureMacAppAsAccessory() {
  if (process.platform !== 'darwin') {
    return;
  }

  if (typeof app.setActivationPolicy === 'function') {
    app.setActivationPolicy('regular');
  }
}

function loadUploadedFiles() {
  try {
    if (fs.existsSync(UPLOADED_FILES_PATH)) {
      const data = JSON.parse(fs.readFileSync(UPLOADED_FILES_PATH, 'utf8'));
      uploadedFiles = new Map(Object.entries(data));
      return true;
    }
  } catch (err) {
    console.error('Error loading uploaded files:', err);
  }
  return false;
}

function saveUploadedFiles() {
  try {
    const data = Object.fromEntries(uploadedFiles);
    fs.writeFileSync(UPLOADED_FILES_PATH, JSON.stringify(data, null, 2));
    return true;
  } catch (err) {
    console.error('Error saving uploaded files:', err);
    return false;
  }
}

function loadRecentFiles() {
  try {
    if (fs.existsSync(RECENT_FILES_PATH)) {
      const data = JSON.parse(fs.readFileSync(RECENT_FILES_PATH, 'utf8'));
      recentFiles = Array.isArray(data) ? data.slice(0, 3) : [];
      return true;
    }
  } catch (err) {
    console.error('Error loading recent files:', err);
  }

  recentFiles = [];
  return false;
}

function saveRecentFiles() {
  try {
    fs.writeFileSync(RECENT_FILES_PATH, JSON.stringify(recentFiles, null, 2));
    return true;
  } catch (err) {
    console.error('Error saving recent files:', err);
    return false;
  }
}

function getRecentTargetLabel(filePath) {
  const fileType = getFileType(filePath);

  if (fileType === 'spreadsheet') {
    return 'Google Sheets';
  }

  if (fileType === 'document') {
    return 'Google Docs';
  }

  if (fileType === 'presentation') {
    return 'Google Slides';
  }

  return 'Google Drive';
}

function emitRecentFilesUpdated() {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('recent-files-updated', recentFiles.slice(0, 3));
  }
}

function removeRecentFile(filePath) {
  const nextRecentFiles = recentFiles.filter((file) => file.filePath !== filePath);

  if (nextRecentFiles.length === recentFiles.length) {
    return;
  }

  recentFiles = nextRecentFiles;
  saveRecentFiles();
  emitRecentFilesUpdated();
  updateTrayMenu();
}

function updateRecentFiles(filePath) {
  if (!filePath) {
    return;
  }

  const nextEntry = {
    filePath,
    fileName: path.basename(filePath),
    targetLabel: getRecentTargetLabel(filePath),
    openedAt: new Date().toISOString(),
  };

  recentFiles = [
    nextEntry,
    ...recentFiles.filter((file) => file.filePath !== filePath),
  ].slice(0, 3);

  saveRecentFiles();
  emitRecentFilesUpdated();
  updateTrayMenu();
}

function extractFileFromArgs(argv) {
  const supportedExtensions = ['.csv', '.xlsx', '.docx', '.txt', '.pptx'];

  for (const arg of argv) {
    if (!arg || arg.startsWith('-')) continue;

    const ext = path.extname(arg).toLowerCase();
    if (!supportedExtensions.includes(ext)) continue;

    if (fs.existsSync(arg)) {
      return arg;
    }
  }

  return null;
}

function getFileType(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  if (ext === '.csv' || ext === '.xlsx') return 'spreadsheet';
  if (ext === '.docx' || ext === '.txt') return 'document';
  if (ext === '.pptx') return 'presentation';
  return null;
}

function createWindow(showWindow = true) {
  if (mainWindow && !mainWindow.isDestroyed()) {
    if (showWindow) {
      mainWindow.show();
      mainWindow.focus();
    }
    return mainWindow;
  }

  const windowOptions = {
    width: 500,
    height: 550,
    resizable: false,
    skipTaskbar: process.platform === 'darwin',
    show: showWindow, // Only show if needed
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      preload: path.join(__dirname, 'preload.js'),
    },
  };

  if (fs.existsSync(APP_ICON_PATH)) {
    windowOptions.icon = APP_ICON_PATH;
  }

  mainWindow = new BrowserWindow(windowOptions);

  if (process.env.VITE_DEV_SERVER_URL) {
    mainWindow.loadURL(process.env.VITE_DEV_SERVER_URL);
    mainWindow.webContents.openDevTools();
  } else {
    mainWindow.loadFile(path.join(__dirname, '../dist/index.html'));
  }

  if (showWindow) {
    mainWindow.show();
  }

  updateTrayMenu();

  mainWindow.on('show', () => {
    updateTrayMenu();
  });

  mainWindow.on('hide', () => {
    updateTrayMenu();
  });

  mainWindow.on('close', (event) => {
    if (isQuitting || process.platform !== 'darwin') {
      return;
    }

    event.preventDefault();
    mainWindow.hide();
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
    updateTrayMenu();
  });

  return mainWindow;
}

function getTrayImage() {
  const trayIconPath = path.join(__dirname, 'assets/trayTemplate.svg');
  let image = nativeImage.createFromPath(trayIconPath);

  if (process.platform === 'darwin' && !image.isEmpty()) {
    image = image.resize({ width: 18, height: 18 });
    image.setTemplateImage(true);
  }

  return image;
}

function showMainWindow() {
  const window = createWindow(true);

  if (process.platform === 'darwin' && app.dock) {
    app.dock.hide();
  }

  return window;
}

function emitFileError(message, { showWindow = false } = {}) {
  if (showWindow) {
    showMainWindow();
  }

  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('file-error', message);
  }
}

function formatUserFacingError(error) {
  const message = error?.message || 'Something went wrong while opening your file.';

  if (message.includes('Not authenticated')) {
    return 'Please sign in with Google before opening files.';
  }

  if (message.includes('Unsupported file type')) {
    return 'This file type is not supported yet. Please use CSV, XLSX, DOCX, TXT, or PPTX.';
  }

  if (message.includes('conversionUnsupportedConversionPath')) {
    return 'Google could not convert this file. Make sure the file is valid and not corrupted.';
  }

  if (message.includes('Conversion of the uploaded content to the requested output type is not supported.')) {
    return 'Google could not convert this file. Make sure the file is valid and not corrupted.';
  }

  if (message.includes('EADDRINUSE')) {
    return 'Google sign-in could not start because port 3000 is already in use. Close the conflicting app and try again.';
  }

  return message;
}

function getTrayStatus() {
  if (isHandlingFile) {
    return {
      title: 'Opening…',
      detail: 'Opening a file in Google apps',
    };
  }

  if (loadToken()) {
    return {
      title: 'Ready',
      detail: 'Signed in and ready to open files',
    };
  }

  return {
    title: 'Sign in',
    detail: 'Sign in with Google to start opening files',
  };
}

function openRecentFile(filePath) {
  if (!filePath) {
    return;
  }

  if (!fs.existsSync(filePath)) {
    removeRecentFile(filePath);
    emitFileError(`Recent file is no longer available: ${path.basename(filePath)}`, { showWindow: true });
    return;
  }

  processFile(filePath, true).catch((err) => {
    console.error('Error opening recent file:', err);
    emitFileError(formatUserFacingError(err), { showWindow: shouldShowWindowForError(err) || !mainWindow });
  });
}

function updateTrayMenu() {
  if (!tray) {
    return;
  }

  const trayStatus = getTrayStatus();
  const recentMenuItems = recentFiles.length > 0
    ? recentFiles.slice(0, 3).map((file) => ({
        label: `${file.fileName} → ${file.targetLabel}`,
        toolTip: file.filePath,
        click: () => openRecentFile(file.filePath),
      }))
    : [{
        label: 'No recent files yet',
        enabled: false,
      }];

  tray.setToolTip(`GOpen — ${trayStatus.detail}`);

  if (process.platform === 'darwin' && typeof tray.setTitle === 'function') {
    tray.setTitle(trayStatus.title);
  }

  tray.setContextMenu(Menu.buildFromTemplate([
    {
      label: 'GOpen',
      enabled: false,
    },
    {
      label: `Status: ${trayStatus.detail}`,
      enabled: false,
    },
    { type: 'separator' },
    {
      label: mainWindow && mainWindow.isVisible() ? 'Hide App Window' : 'Show App Window',
      click: () => {
        if (mainWindow && mainWindow.isVisible()) {
          mainWindow.hide();
          updateTrayMenu();
          return;
        }

        showMainWindow();
        updateTrayMenu();
      },
    },
    {
      label: 'Recent Files',
      submenu: recentMenuItems,
    },
    { type: 'separator' },
    {
      label: 'Exit App',
      click: () => {
        isQuitting = true;
        app.quit();
      },
    },
  ]));
}

function createTray() {
  if (tray) {
    updateTrayMenu();
    return tray;
  }

  tray = new Tray(getTrayImage());
  updateTrayMenu();

  tray.on('click', () => {
    if (mainWindow && mainWindow.isVisible()) {
      mainWindow.hide();
      updateTrayMenu();
      return;
    }

    showMainWindow();
    updateTrayMenu();
  });

  return tray;
}

function loadCredentials() {
  try {
    if (fs.existsSync(CREDENTIALS_PATH)) {
      const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf8'));
      oauth2Client = new OAuth2Client(
        credentials.web.client_id,
        credentials.web.client_secret,
        credentials.web.redirect_uris[0]
      );
      return true;
    } else {
      console.error('credentials.json not found at:', CREDENTIALS_PATH);
    }
  } catch (err) {
    console.error('Error loading credentials:', err);
  }
  return false;
}

function loadToken() {
  try {
    if (!oauth2Client && !loadCredentials()) {
      return false;
    }

    if (fs.existsSync(TOKEN_PATH)) {
      const token = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'));
      oauth2Client.setCredentials(token);
      drive = google.drive({ version: 'v3', auth: oauth2Client });
      return true;
    }
  } catch (err) {
    console.error('Error loading token:', err);
  }
  return false;
}

function saveToken(token) {
  try {
    if (!oauth2Client && !loadCredentials()) {
      return false;
    }

    fs.writeFileSync(TOKEN_PATH, JSON.stringify(token));
    oauth2Client.setCredentials(token);
    drive = google.drive({ version: 'v3', auth: oauth2Client });
    return true;
  } catch (err) {
    console.error('Error saving token:', err);
    return false;
  }
}

function getAuthUrl() {
  if (!oauth2Client) return null;
  
  const authUrl = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: ['https://www.googleapis.com/auth/drive.file'],
    prompt: 'consent',
  });
  return authUrl;
}

function startOAuthServer() {
  if (oauthServerState?.startupPromise) {
    return oauthServerState.startupPromise;
  }

  const PORT = 3000;
  let server;

  const startupPromise = new Promise((resolve, reject) => {
    let settled = false;
    let timeoutId;

    const finish = (callback, value) => {
      if (settled) {
        return;
      }

      settled = true;
      clearTimeout(timeoutId);
      callback(value);
    };

    const cleanup = () => {
      if (oauthServerState?.server === server) {
        oauthServerState = null;
      }
    };

    server = http.createServer(async (req, res) => {
      if (req.url.startsWith('/oauth2callback')) {
        const url = new URL(req.url, `http://localhost:${PORT}`);
        const code = url.searchParams.get('code');

        if (code) {
          try {
            const { tokens } = await oauth2Client.getToken(code);
            saveToken(tokens);

            res.writeHead(200, { 'Content-Type': 'text/html' });
            res.end(`
              <html>
                <body style="display:flex;justify-content:center;align-items:center;height:100vh;font-family:system-ui;">
                  <div style="text-align:center;">
                    <h1 style="color:#4ade80;">✓ Success!</h1>
                    <p>You can close this window and return to the app.</p>
                  </div>
                </body>
              </html>
            `);

            if (mainWindow) {
              mainWindow.webContents.send('auth-success');
            }

            updateTrayMenu();

            setTimeout(() => server.close(), 1000);
            finish(resolve, true);
          } catch (err) {
            res.writeHead(500);
            res.end('Error exchanging code for token: ' + err.message);
            finish(reject, err);
            server.close();
          }
        } else {
          res.writeHead(400);
          res.end('No code received');
          const error = new Error('No code received');
          finish(reject, error);
          server.close();
        }
      } else {
        res.writeHead(404);
        res.end('Not found');
      }
    });

    oauthServerState = {
      server,
      startupPromise: null,
    };

    server.once('error', (error) => {
      cleanup();
      finish(reject, error);
    });

    server.once('close', () => {
      cleanup();
    });

    server.listen(PORT, () => {
      console.log(`OAuth server listening on port ${PORT}`);
      resolve(true);
    });

    timeoutId = setTimeout(() => {
      const timeoutError = new Error('OAuth timeout');
      finish(reject, timeoutError);
      server.close();
    }, 120000);
  });

  if (oauthServerState) {
    oauthServerState.startupPromise = startupPromise;
  }

  return startupPromise;
}

async function uploadToDrive(filePath) {
  if (!drive) {
    throw new Error('Google Drive not authenticated');
  }

  const ext = path.extname(filePath).toLowerCase();
  const fileName = path.basename(filePath, ext);
  const fileContent = fs.createReadStream(filePath);

  let mimeType;
  let googleMimeType;

  if (ext === '.csv') {
    mimeType = 'text/csv';
    googleMimeType = 'application/vnd.google-apps.spreadsheet';
  } else if (ext === '.xlsx') {
    mimeType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
    googleMimeType = 'application/vnd.google-apps.spreadsheet';
  } else if (ext === '.docx') {
    mimeType = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
    googleMimeType = 'application/vnd.google-apps.document';
  } else if (ext === '.txt') {
    mimeType = 'text/plain';
    googleMimeType = 'application/vnd.google-apps.document';
  } else if (ext === '.pptx') {
    mimeType = 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
    googleMimeType = 'application/vnd.google-apps.presentation';
  } else {
    throw new Error('Unsupported file type');
  }

  const response = await drive.files.create({
    requestBody: {
      name: fileName,
      mimeType: googleMimeType,
    },
    media: {
      mimeType: mimeType,
      body: fileContent,
    },
    fields: 'id, webViewLink',
  });

  return {
    id: response.data.id,
    webViewLink: response.data.webViewLink,
  };
}

async function handleFile(filePath, showWindowOnError = true) {
  try {
    if (!loadToken()) {

      if (showWindowOnError) {
        createWindow(true);
      }
      throw new Error('Not authenticated. Please login with Google first.');
    }

    const fileType = getFileType(filePath);
    if (!fileType) {
      throw new Error('Unsupported file type');
    }

    loadUploadedFiles();

    const fileHash = getFileHash(filePath);
    if (!fileHash) {
      throw new Error('Could not read file');
    }

    const existingUpload = uploadedFiles.get(fileHash);
    if (existingUpload) {
      console.log('File already uploaded, opening existing:', existingUpload.webViewLink);
      await shell.openExternal(existingUpload.webViewLink);
      updateRecentFiles(filePath);
      return { success: true, url: existingUpload.webViewLink, existing: true };
    }

    console.log('Uploading file:', filePath);
    const result = await uploadToDrive(filePath);
    
    uploadedFiles.set(fileHash, {
      id: result.id,
      webViewLink: result.webViewLink,
      filePath: filePath,
      fileName: path.basename(filePath),
      uploadedAt: new Date().toISOString()
    });
    saveUploadedFiles();
    
    console.log('Uploaded successfully:', result.webViewLink);
    
    await shell.openExternal(result.webViewLink);
    updateRecentFiles(filePath);
    
    return { success: true, url: result.webViewLink };
  } catch (error) {
    console.error('Error handling file:', error);
    throw error;
  }
}

function shouldShowWindowForError(error) {
  return error?.message?.includes('Not authenticated');
}

async function processFile(filePath, showWindowOnError = true) {
  isHandlingFile = true;
  updateTrayMenu();

  try {
    return await handleFile(filePath, showWindowOnError);
  } catch (error) {
    const userFacingMessage = formatUserFacingError(error);

    if (showWindowOnError) {
      emitFileError(userFacingMessage, { showWindow: shouldShowWindowForError(error) || !mainWindow });
    }

    throw error;
  } finally {
    isHandlingFile = false;
    updateTrayMenu();
  }
}

ipcMain.handle('check-auth', async () => {
  const hasCredentials = loadCredentials();
  const hasToken = hasCredentials && loadToken();
  
  let userInfo = null;
  if (hasToken && drive) {
    try {
      const about = await drive.about.get({ fields: 'name, photoUrl, emailAddress' });
      userInfo = {
        name: about.data.name,
        email: about.data.emailAddress,
        photoUrl: about.data.photoUrl,
      };
    } catch (err) {
      console.error('Error getting user info:', err);
    }
  }
  
  return {
    hasCredentials,
    isAuthenticated: hasToken,
    user: userInfo,
  };
});

ipcMain.handle('get-auth-url', async () => {
  if (!loadCredentials()) {
    return { error: 'Google credentials not configured. Please contact the developer.' };
  }
  
  const authUrl = getAuthUrl();
  if (!authUrl) {
    return { error: 'Failed to generate auth URL' };
  }

  try {
    await startOAuthServer();
  } catch (error) {
    console.error('Failed to start OAuth server:', error);
    return { error: formatUserFacingError(error) };
  }
  
  await shell.openExternal(authUrl);
  
  return { success: true };
});

ipcMain.handle('upload-file', (event, filePath) => {
  return handleFile(filePath);
});

ipcMain.handle('get-recent-files', () => {
  loadRecentFiles();
  return recentFiles.slice(0, 3);
});

ipcMain.handle('quit-app', () => {
  isQuitting = true;
  app.quit();
  return { success: true };
});

ipcMain.handle('clear-auth', () => {
  try {
    if (fs.existsSync(TOKEN_PATH)) {
      fs.unlinkSync(TOKEN_PATH);
    }
    drive = null;
    updateTrayMenu();
    return { success: true };
  } catch (err) {
    return { error: err.message };
  }
});

app.on('will-finish-launching', () => {
  configureMacAppAsAccessory();
});

app.on('before-quit', () => {
  isQuitting = true;
});

app.whenReady().then(() => {
  isAppReady = true;
  loadRecentFiles();
  createTray();
  configureMacAppAsAccessory();

  if (pendingFile) {
    processFile(pendingFile).catch((err) => {
      console.error('Error with pending file:', err);
      emitFileError(formatUserFacingError(err), { showWindow: shouldShowWindowForError(err) || !mainWindow });
    });
    pendingFile = null;
  }
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', () => {
  const launchedFromRecentFileOpen = Date.now() - lastFileOpenRequestAt < 5000;
  const stillInInitialLaunchWindow = Date.now() < suppressInitialWindowUntil;

  if (isHandlingFile || pendingFile || launchedFromRecentFileOpen || stillInInitialLaunchWindow) {
    return;
  }

  if (BrowserWindow.getAllWindows().length === 0) {
    showMainWindow();
  } else if (mainWindow) {
    mainWindow.show();
  }
});

app.on('open-file', async (event, filePath) => {
  event.preventDefault();
  lastFileOpenRequestAt = Date.now();
  
  if (isAppReady) {
    processFile(filePath, true).catch((err) => {
      console.error('Error opening file:', err);
      emitFileError(formatUserFacingError(err), { showWindow: shouldShowWindowForError(err) || !mainWindow });
    });
  } else {
    pendingFile = filePath;
  }
});

const initialFile = extractFileFromArgs(process.argv.slice(1));
if (initialFile) {
  pendingFile = initialFile;
  lastFileOpenRequestAt = Date.now();
}