main.js

const { app, BrowserWindow, ipcMain, dialog, clipboard, systemPreferences, session, Menu } = require('electron');
const path = require('path');
const fs = require('fs');
const { exec } = require('child_process');
const os = require('os');

let mainWindow;
let speakProcess = null;
const dbPath = path.join(app.getPath('userData'), 'luna_db.json');

// Initialize Simple JSON Database
function loadDB() {
  try {
    if (fs.existsSync(dbPath)) {
      const data = fs.readFileSync(dbPath, 'utf8');
      return JSON.parse(data);
    }
  } catch (err) {
    console.error('Failed to load database, resetting...', err);
  }
  return {};
}

function saveDB(data) {
  try {
    fs.writeFileSync(dbPath, JSON.stringify(data, null, 2), 'utf8');
    return true;
  } catch (err) {
    console.error('Failed to save database', err);
    return false;
  }
}

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1100,
    height: 750,
    minWidth: 800,
    minHeight: 600,
    // Custom frameless look on macOS for premium glassmorphism
    titleBarStyle: 'hiddenInset',
    vibrancy: 'under-window', // macOS native vibrancy effect
    visualEffectState: 'active',
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false
    }
  });

  // Load the compiled frontend files directly from the dist directory.
  // This prevents port conflicts with other running dev servers (like Aura Insights on port 5173).
  mainWindow.loadFile(path.join(__dirname, 'dist/index.html'));

  // Handle closed window
  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  // Forward renderer console statements to terminal log output for troubleshooting
  mainWindow.webContents.on('console-message', (event, level, message, line, sourceId) => {
    console.log(`[RENDERER] ${message} (at ${path.basename(sourceId)}:${line})`);
  });
}

app.whenReady().then(() => {
  // Request microphone permissions on macOS system level
  if (process.platform === 'darwin') {
    systemPreferences.askForMediaAccess('microphone').then(accessGranted => {
      console.log(`[SYSTEM] macOS Microphone Access Status: ${accessGranted}`);
    }).catch(err => {
      console.error('[SYSTEM] Error requesting macOS microphone access:', err);
    });
  }

  // Approve media/microphone request permission handler for the renderer process
  session.defaultSession.setPermissionRequestHandler((webContents, permission, callback) => {
    if (permission === 'media') {
      return callback(true); // Approved
    }
    callback(false); // Refused other permissions for security
  });

  // Set up custom application menu to ensure "Start Dictation" exists in the Edit menu
  const template = [
    {
      label: 'Luna',
      submenu: [
        { role: 'about' },
        { type: 'separator' },
        { role: 'services' },
        { type: 'separator' },
        { role: 'hide' },
        { role: 'hideOthers' },
        { role: 'unhide' },
        { type: 'separator' },
        { role: 'quit' }
      ]
    },
    {
      label: 'Edit',
      submenu: [
        { role: 'undo' },
        { role: 'redo' },
        { type: 'separator' },
        { role: 'cut' },
        { role: 'copy' },
        { role: 'paste' },
        { role: 'selectAll' },
        { type: 'separator' },
        { role: 'startSpeech', label: 'Start Dictation' },
        { role: 'stopSpeech', label: 'Stop Dictation' }
      ]
    },
    {
      label: 'View',
      submenu: [
        { role: 'reload' },
        { role: 'forceReload' },
        { role: 'toggleDevTools' },
        { type: 'separator' },
        { role: 'resetZoom' },
        { role: 'zoomIn' },
        { role: 'zoomOut' },
        { type: 'separator' },
        { role: 'togglefullscreen' }
      ]
    },
    {
      label: 'Window',
      submenu: [
        { role: 'minimize' },
        { role: 'zoom' },
        { type: 'separator' },
        { role: 'front' }
      ]
    }
  ];
  Menu.setApplicationMenu(Menu.buildFromTemplate(template));

  createWindow();

  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
      createWindow();
    }
  });
});

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

// IPC Handler: Database Operations
ipcMain.handle('db-save', (event, { key, data }) => {
  const db = loadDB();
  db[key] = data;
  return saveDB(db);
});

ipcMain.handle('db-load', (event, { key }) => {
  const db = loadDB();
  return db[key] || null;
});

ipcMain.handle('db-delete', (event, { key }) => {
  const db = loadDB();
  delete db[key];
  return saveDB(db);
});

ipcMain.handle('db-wipe-all', () => {
  return saveDB({});
});

// IPC Handler: Clipboard Shelf
ipcMain.handle('read-clipboard-text', () => {
  return clipboard.readText();
});

// IPC Handler: System Information
ipcMain.handle('get-system-info', () => {
  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  const usedMem = totalMem - freeMem;
  const cpus = os.cpus();
  
  return {
    platform: process.platform,
    ramUsage: {
      usedGB: (usedMem / (1024 ** 3)).toFixed(1),
      totalGB: (totalMem / (1024 ** 3)).toFixed(1),
      percent: Math.round((usedMem / totalMem) * 100)
    },
    cpuCount: cpus.length,
    cpuModel: cpus[0].model
  };
});

// IPC Handler: Directory Selector dialog
ipcMain.handle('select-directory', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory']
  });
  if (result.canceled) {
    return null;
  }
  return result.filePaths[0];
});

// IPC Handler: File Selector dialog
ipcMain.handle('select-file', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openFile']
  });
  if (result.canceled) {
    return null;
  }
  const filePath = result.filePaths[0];
  return {
    path: filePath,
    name: path.basename(filePath),
    size: fs.statSync(filePath).size
  };
});

// IPC Handler: Ask Permission (Native dialog fallback)
ipcMain.handle('request-permission', async (event, { title, message }) => {
  const result = await dialog.showMessageBox(mainWindow, {
    type: 'question',
    buttons: ['Deny', 'Allow'],
    defaultId: 1,
    title: title || 'Permission Requested',
    message: message || 'Luna is requesting permission to run a system action.'
  });
  return result.response === 1; // 1 represents Allow
});

// IPC Handler: System Automations Runner
ipcMain.handle('run-automation', async (event, { action, data }) => {
  switch (action) {
    case 'trigger-macos-dictation':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }
        
        try {
          if (mainWindow) {
            mainWindow.focus();
          }
          
          // Natively send startSpeech: Cocoa message down macOS responder chain (requires zero accessibility permissions)
          Menu.sendActionToFirstResponder('startSpeech:');
          resolve({ success: true, message: 'Natively triggered dictation overlay.' });
        } catch (err) {
          resolve({ success: false, error: err.message });
        }
      });

    case 'open-app':
      return new Promise((resolve) => {
        const rawAppName = data.appName ? data.appName.toLowerCase().trim() : '';
        
        // Dictionary mapping common queries, aliases, and typos to exact macOS app names
        const appMapping = {
          'calendar': 'Calendar',
          'calender': 'Calendar',
          'maps': 'Maps',
          'apple maps': 'Maps',
          'chrome': 'Google Chrome',
          'google chrome': 'Google Chrome',
          'spotify': 'Spotify',
          'mail': 'Mail',
          'email': 'Mail',
          'music': 'Music',
          'apple music': 'Music',
          'notes': 'Notes',
          'safari': 'Safari',
          'terminal': 'Terminal',
          'vscode': 'Visual Studio Code',
          'visual studio code': 'Visual Studio Code',
          'code': 'Visual Studio Code',
          'xcode': 'Xcode',
          'finder': 'Finder',
          'reminders': 'Reminders',
          'calculator': 'Calculator'
        };

        const targetApp = appMapping[rawAppName] || data.appName;
        // Escape quotes to prevent injections
        const sanitizedAppName = targetApp.replace(/["'\\]/g, '');
        exec(`open -a "${sanitizedAppName}"`, (err, stdout, stderr) => {
          if (err) {
            resolve({ success: false, error: err.message });
          } else {
            resolve({ success: true, message: `Successfully opened ${targetApp}.` });
          }
        });
      });

    case 'create-reminder':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }

        const title = data.title;
        // Escape quotes for AppleScript syntax compatibility
        const escapedTitle = title.replace(/"/g, '\\"');
        const appleScript = `tell application "Reminders" to make new reminder with properties {name:"${escapedTitle}"}`;

        exec(`osascript -e '${appleScript}'`, (err, stdout, stderr) => {
          if (err) {
            console.error('[REMINDERS] AppleScript execution error:', stderr || err.message);
            resolve({ success: false, error: err.message });
          } else {
            resolve({ success: true, message: `Added "${title}" to macOS Reminders.` });
          }
        });
      });

    case 'draft-email':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }
        const subject = data.subject || 'New Email Draft';
        const body = data.body || '';
        const appleScript = `tell application "Mail" to make new outgoing message with properties {subject:"${subject.replace(/"/g, '\\"')}", content:"${body.replace(/"/g, '\\"')}", visible:true}`;
        
        exec(`osascript -e '${appleScript}' -e 'tell application "Mail" to activate'`, (err) => {
          if (err) resolve({ success: false, error: err.message });
          else resolve({ success: true, message: `Created draft email about "${subject}".` });
        });
      });

    case 'create-calendar-event':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }
        const title = data.title || 'New Event';
        const appleScript = `tell application "Calendar" to tell calendar 1 to make new event with properties {summary:"${title.replace(/"/g, '\\"')}"}`;
        
        exec(`osascript -e '${appleScript}'`, (err) => {
          if (err) resolve({ success: false, error: err.message });
          else resolve({ success: true, message: `Created calendar event for "${title}".` });
        });
      });

    case 'create-note':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }
        const body = data.body || 'New Note';
        const appleScript = `tell application "Notes" to make new note with properties {body:"${body.replace(/"/g, '\\"')}"}`;
        
        exec(`osascript -e '${appleScript}'`, (err) => {
          if (err) resolve({ success: false, error: err.message });
          else resolve({ success: true, message: `Created note: "${body.slice(0, 30)}...".` });
        });
      });

    case 'music-control':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }
        const cmd = data.command || 'play';
        const appleScript = `tell application "Music" to ${cmd}`;
        
        exec(`osascript -e '${appleScript}'`, (err) => {
          if (err) resolve({ success: false, error: err.message });
          else resolve({ success: true, message: `Sent music control: ${cmd}.` });
        });
      });

    case 'search-contacts':
      return new Promise((resolve) => {
        if (process.platform !== 'darwin') {
          return resolve({ success: false, error: 'Supported only on macOS' });
        }
        const query = data.query || '';
        const appleScript = `tell application "Contacts" to name of every person whose name contains "${query.replace(/"/g, '\\"')}"`;
        
        exec(`osascript -e '${appleScript}'`, (err, stdout, stderr) => {
          if (err) {
            resolve({ success: false, error: err.message });
          } else {
            const list = stdout.trim();
            resolve({ success: true, message: list ? `Found contact(s): ${list}` : `No contacts found matching "${query}".` });
          }
        });
      });

    case 'open-link':
      return new Promise((resolve) => {
        const url = data.url;
        if (!url) return resolve({ success: false, error: 'No URL provided' });
        // Sanitize characters to prevent shell escapes
        const sanitizedUrl = url.replace(/[^a-zA-Z0-9.\-_:/?=&%#]/g, '');
        
        exec(`open "${sanitizedUrl}"`, (err) => {
          if (err) resolve({ success: false, error: err.message });
          else resolve({ success: true, message: `Opened link in web browser: ${url}` });
        });
      });

    case 'search-files':
      return new Promise((resolve) => {
        const query = data.query;
        // Clean query to avoid shell injections
        const sanitizedQuery = query.replace(/[^a-zA-Z0-9.\-_ ]/g, '');
        // Spotlight search command (mdfind) limited to top 15 results
        // Searching downloads and documents for speed
        const searchPath = data.searchPath || '~/';
        const cmd = `mdfind -onlyin ${searchPath} -name "${sanitizedQuery}" | head -n 15`;
        
        exec(cmd, (err, stdout, stderr) => {
          if (err) {
            resolve({ success: false, error: err.message });
          } else {
            const files = stdout.split('\n').filter(line => line.trim().length > 0).map(filePath => {
              return {
                name: path.basename(filePath),
                path: filePath,
                dir: path.dirname(filePath)
              };
            });
            resolve({ success: true, files });
          }
        });
      });

    case 'organize-files':
      return new Promise((resolve) => {
        const targetDir = data.targetDir || path.join(os.homedir(), 'Downloads');
        
        if (!fs.existsSync(targetDir)) {
          return resolve({ success: false, error: 'Directory does not exist' });
        }

        const categories = {
          Documents: ['.pdf', '.docx', '.doc', '.txt', '.xlsx', '.xls', '.ppt', '.pptx', '.md', '.csv'],
          Images: ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.heic', '.bmp'],
          Code: ['.js', '.jsx', '.ts', '.tsx', '.html', '.css', '.py', '.rb', '.go', '.rs', '.json', '.c', '.cpp'],
          Audios: ['.mp3', '.wav', '.m4a', '.flac', '.ogg'],
          Videos: ['.mp4', '.mov', '.avi', '.mkv', '.webm'],
          Archives: ['.zip', '.tar', '.gz', '.rar', '.7z', '.dmg', '.pkg']
        };

        try {
          const files = fs.readdirSync(targetDir);
          let movedCount = 0;

          files.forEach(file => {
            const fullPath = path.join(targetDir, file);
            const stat = fs.statSync(fullPath);

            // Process only files, skip directories
            if (stat.isFile() && !file.startsWith('.')) {
              const ext = path.extname(file).toLowerCase();
              let matchedCategory = 'Others';

              for (const [category, extensions] of Object.entries(categories)) {
                if (extensions.includes(ext)) {
                  matchedCategory = category;
                  break;
                }
              }

              const destDir = path.join(targetDir, matchedCategory);
              if (!fs.existsSync(destDir)) {
                fs.mkdirSync(destDir);
              }

              const destPath = path.join(destDir, file);
              fs.renameSync(fullPath, destPath);
              movedCount++;
            }
          });

          resolve({ success: true, message: `Organized ${movedCount} files in ${path.basename(targetDir)} into category folders.` });
        } catch (err) {
          resolve({ success: false, error: err.message });
        }
      });

    case 'read-file':
      return new Promise((resolve) => {
        const filePath = data.filePath;
        if (!fs.existsSync(filePath)) {
          return resolve({ success: false, error: 'File does not exist' });
        }
        
        try {
          const stat = fs.statSync(filePath);
          const extension = path.extname(filePath).toLowerCase();

          if (extension === '.pdf') {
            const { PDFParse } = require('pdf-parse');
            const dataBuffer = fs.readFileSync(filePath);
            const uint8 = new Uint8Array(dataBuffer.buffer, dataBuffer.byteOffset, dataBuffer.byteLength);
            const p = new PDFParse(uint8);
            
            p.getText().then(function(pdfData) {
              resolve({ success: true, content: pdfData.text, size: stat.size });
            }).catch(err => {
              resolve({ success: false, error: 'Failed to parse PDF: ' + err.message });
            });
          } else {
            if (stat.size > 2 * 1024 * 1024) { // Limit to 2MB to avoid freezing
              return resolve({ success: false, error: 'File size exceeds 2MB limit for summarization' });
            }
            const content = fs.readFileSync(filePath, 'utf8');
            resolve({ success: true, content, size: stat.size });
          }
        } catch (err) {
          resolve({ success: false, error: err.message });
        }
      });

    default:
      return Promise.resolve({ success: false, error: `Unknown automation action: ${action}` });
  }
});

// Native macOS Speech Output Handler
ipcMain.handle('speak-text', async (event, { text, voice, rate }) => {
  console.log(`[SYSTEM] Speak request received: "${text.slice(0, 40)}${text.length > 40 ? '...' : ''}" (voice: ${voice || 'default'}, rate: ${rate || 'default'})`);
  return new Promise((resolve) => {
    if (process.platform !== 'darwin') {
      console.warn('[SYSTEM] Speak request rejected: Not on macOS.');
      return resolve({ success: false, error: 'Supported only on macOS' });
    }
    
    // Terminate any active say process
    if (speakProcess) {
      try { speakProcess.kill(); } catch (e) {}
      speakProcess = null;
    }
    exec('/usr/bin/killall say 2>/dev/null || true');

    const cleanText = text.replace(/"/g, '\\"').replace(/`/g, '\\`').replace(/\$/g, '\\$');
    const voiceFlag = voice ? `-v "${voice}"` : '';
    const rateFlag = rate ? `-r ${rate}` : '';

    speakProcess = exec(`/usr/bin/say ${voiceFlag} ${rateFlag} "${cleanText}"`, (err) => {
      speakProcess = null;
      if (err) {
        console.error('[SYSTEM] Speech execution failed:', err.message);
        resolve({ success: false, error: err.message });
      } else {
        console.log('[SYSTEM] Speech execution finished successfully.');
        resolve({ success: true });
      }
    });
  });
});

ipcMain.handle('stop-speaking', async () => {
  if (speakProcess) {
    try { speakProcess.kill(); } catch (e) {}
    speakProcess = null;
  }
  exec('/usr/bin/killall say 2>/dev/null || true');
  return { success: true };
});

ipcMain.handle('transcribe-audio', async (event, { base64Data }) => {
  return new Promise((resolve) => {
    try {
      const fs = require('fs');
      const audioBuffer = Buffer.from(base64Data, 'base64');
      const tempPath = path.join(__dirname, 'temp_voice.wav');
      fs.writeFileSync(tempPath, audioBuffer);

      const scriptPath = path.join(__dirname, 'transcribe.swift');
      const cmd = `swift "${scriptPath}" "${tempPath}"`;

      exec(cmd, (err, stdout, stderr) => {
        // Clean up temporary audio file
        try { fs.unlinkSync(tempPath); } catch (e) {}

        if (err) {
          console.error('[SYSTEM] Speech-to-Text script error:', stderr || err.message);
          resolve({ success: false, error: err.message });
        } else {
          const transcription = stdout.trim();
          console.log(`[SYSTEM] Transcribed text: "${transcription}"`);
          resolve({ success: true, text: transcription });
        }
      });
    } catch (err) {
      resolve({ success: false, error: err.message });
    }
  });
});