const { app, BrowserWindow, Menu, dialog, ipcMain, shell } = require('electron');
const path = require('path');
const fs = require('fs');
const { exec } = require('child_process');
const XLSX = require('xlsx');

// Get the system Pandoc path
function getPandocPath() {
  // Check common Pandoc installation locations on Windows
  const commonPaths = [
    'pandoc', // System PATH
    path.join(process.env.USERPROFILE || '', 'AppData', 'Local', 'Pandoc', 'pandoc.exe'),
    path.join('C:', 'Program Files', 'Pandoc', 'pandoc.exe'),
    path.join('C:', 'Program Files (x86)', 'Pandoc', 'pandoc.exe'),
  ];

  // Try each path and return the first one that exists
  for (const pandocPath of commonPaths) {
    if (pandocPath === 'pandoc') {
      // For system PATH, we'll check in checkPandocAvailable()
      return pandocPath;
    } else if (fs.existsSync(pandocPath)) {
      return `"${pandocPath}"`;
    }
  }
  
  // Fallback to system pandoc
  return 'pandoc';
}

// Check if Pandoc is available
function checkPandocAvailable() {
  return new Promise((resolve) => {
    const pandocPath = getPandocPath();
    exec(`${pandocPath} --version`, (error) => {
      resolve(!error);
    });
  });
}

// Simple storage implementation to replace electron-store
const settingsPath = path.join(app.getPath('userData'), 'settings.json');
const store = {
  get: (key, defaultValue) => {
    try {
      const data = fs.readFileSync(settingsPath, 'utf-8');
      const settings = JSON.parse(data);
      return settings[key] || defaultValue;
    } catch {
      return defaultValue;
    }
  },
  set: (key, value) => {
    let settings = {};
    try {
      const data = fs.readFileSync(settingsPath, 'utf-8');
      settings = JSON.parse(data);
    } catch {}
    settings[key] = value;
    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
  }
};

let mainWindow;
let currentFile = null; // This will now represent the active tab's file
let pandocAvailable = null; // Cache pandoc availability check

// Check if pandoc is available
function checkPandocAvailability() {
  return new Promise((resolve) => {
    if (pandocAvailable !== null) {
      resolve(pandocAvailable);
      return;
    }
    
    exec('pandoc --version', (error, stdout, stderr) => {
      pandocAvailable = !error;
      resolve(pandocAvailable);
    });
  });
}

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false
    },
    icon: path.join(__dirname, '../assets/icon.png')
  });

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

  createMenu();

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

  // Handle pending file from file association will be handled by renderer-ready event
}

function buildRecentFilesMenu() {
  const recentFiles = getRecentFiles();

  if (recentFiles.length === 0) {
    return [
      {
        label: 'No recent files',
        enabled: false
      }
    ];
  }

  const recentFileItems = recentFiles.map(filePath => ({
    label: filePath.split(/[\\/]/).pop(), // Get filename only
    click: () => {
      if (fs.existsSync(filePath)) {
        currentFile = filePath;
        const content = fs.readFileSync(filePath, 'utf-8');
        mainWindow.webContents.send('file-opened', { path: filePath, content });
      } else {
        dialog.showErrorBox('File Not Found', `The file "${filePath}" could not be found.`);
      }
    },
    toolTip: filePath // Show full path in tooltip
  }));

  return [
    ...recentFileItems,
    { type: 'separator' },
    {
      label: 'Clear Recent Files',
      click: () => {
        mainWindow.webContents.send('clear-recent-files');
      }
    }
  ];
}

function getRecentFiles() {
  try {
    const recentFiles = JSON.parse(fs.readFileSync(path.join(app.getPath('userData'), 'recent-files.json'), 'utf-8'));
    return recentFiles.filter(file => fs.existsSync(file));
  } catch (e) {
    return [];
  }
}

function createMenu() {
  const template = [
    {
      label: 'File',
      submenu: [
        {
          label: 'New',
          accelerator: 'CmdOrCtrl+N',
          click: () => mainWindow.webContents.send('file-new')
        },
        {
          label: 'Open',
          accelerator: 'CmdOrCtrl+O',
          click: openFile
        },
        {
          label: 'Save',
          accelerator: 'CmdOrCtrl+S',
          click: () => mainWindow.webContents.send('file-save')
        },
        {
          label: 'Save As',
          accelerator: 'CmdOrCtrl+Shift+S',
          click: saveAsFile
        },
        { type: 'separator' },
        {
          label: 'Recent Files',
          submenu: buildRecentFilesMenu()
        },
        { type: 'separator' },
        {
          label: 'Import Document...',
          accelerator: 'CmdOrCtrl+I',
          click: importDocument
        },
        {
          label: 'Export',
          submenu: [
            { label: 'HTML', click: () => exportFile('html') },
            { label: 'PDF', click: () => exportFile('pdf') },
            { label: 'DOCX', click: () => exportFile('docx') },
            { label: 'LaTeX', click: () => exportFile('latex') },
            { label: 'RTF', click: () => exportFile('rtf') },
            { label: 'ODT', click: () => exportFile('odt') },
            { label: 'EPUB', click: () => exportFile('epub') },
            { type: 'separator' },
            { label: 'PowerPoint (PPTX)', click: () => exportFile('pptx') },
            { label: 'OpenDocument Presentation (ODP)', click: () => exportFile('odp') },
            { type: 'separator' },
            { label: 'CSV (Tables)', click: () => exportSpreadsheet('csv') },
            { label: 'XLSX (Tables)', click: () => exportSpreadsheet('xlsx') }
          ]
        },
        { type: 'separator' },
        {
          label: 'Quit',
          accelerator: process.platform === 'darwin' ? 'Cmd+Q' : 'Ctrl+Q',
          click: () => app.quit()
        }
      ]
    },
    {
      label: 'Edit',
      submenu: [
        { label: 'Undo', accelerator: 'CmdOrCtrl+Z', role: 'undo' },
        { label: 'Redo', accelerator: 'CmdOrCtrl+Shift+Z', role: 'redo' },
        { type: 'separator' },
        { label: 'Cut', accelerator: 'CmdOrCtrl+X', role: 'cut' },
        { label: 'Copy', accelerator: 'CmdOrCtrl+C', role: 'copy' },
        { label: 'Paste', accelerator: 'CmdOrCtrl+V', role: 'paste' },
        { label: 'Select All', accelerator: 'CmdOrCtrl+A', role: 'selectAll' },
        { type: 'separator' },
        { 
          label: 'Find & Replace', 
          accelerator: 'CmdOrCtrl+F', 
          click: () => mainWindow.webContents.send('toggle-find') 
        }
      ]
    },
    {
      label: 'View',
      submenu: [
        {
          label: 'Toggle Preview',
          accelerator: 'CmdOrCtrl+P',
          click: () => mainWindow.webContents.send('toggle-preview')
        },
        {
          label: 'Theme',
          submenu: [
            { label: 'Light', click: () => setTheme('light') },
            { label: 'Dark', click: () => setTheme('dark') },
            { label: 'Solarized', click: () => setTheme('solarized') },
            { label: 'Monokai', click: () => setTheme('monokai') },
            { label: 'GitHub', click: () => setTheme('github') }
          ]
        },
        { type: 'separator' },
        {
          label: 'Font Size',
          submenu: [
            { 
              label: 'Increase Font Size', 
              accelerator: 'CmdOrCtrl+Shift+Plus',
              click: () => mainWindow.webContents.send('adjust-font-size', 'increase')
            },
            { 
              label: 'Decrease Font Size', 
              accelerator: 'CmdOrCtrl+Shift+-',
              click: () => mainWindow.webContents.send('adjust-font-size', 'decrease')
            },
            { 
              label: 'Reset Font Size',
              accelerator: 'CmdOrCtrl+Shift+0',
              click: () => mainWindow.webContents.send('adjust-font-size', 'reset')
            }
          ]
        },
        { type: 'separator' },
        { label: 'Reload', accelerator: 'CmdOrCtrl+R', role: 'reload' },
        { label: 'Toggle DevTools', accelerator: 'F12', role: 'toggleDevTools' },
        { type: 'separator' },
        { label: 'Zoom In', accelerator: 'CmdOrCtrl+Plus', role: 'zoomIn' },
        { label: 'Zoom Out', accelerator: 'CmdOrCtrl+-', role: 'zoomOut' },
        { label: 'Reset Zoom', accelerator: 'CmdOrCtrl+0', role: 'resetZoom' }
      ]
    },
    {
      label: 'Batch',
      submenu: [
        {
          label: 'Convert Folder...',
          click: () => showBatchConversionDialog()
        }
      ]
    },
    {
      label: 'Help',
      submenu: [
        {
          label: 'About',
          click: () => {
            dialog.showMessageBox(mainWindow, {
              type: 'info',
              title: 'About PanConverter',
              message: 'PanConverter',
              detail: 'A cross-platform Markdown editor and converter using Pandoc.\n\nVersion: 1.5.0\nAuthor: Amit Haridas\nEmail: amit.wh@gmail.com\nLicense: MIT\n\nFeatures:\n• Windows Explorer context menu integration\n• Tabbed interface for multiple files\n• Advanced markdown editing with live preview\n• Enhanced PDF export with built-in Electron fallback\n• File association support for .md files\n• Command-line interface for batch conversion\n• Advanced export options with templates and metadata\n• Batch file conversion with progress tracking\n• Improved preview typography and spacing\n• Adjustable font sizes via menu (Ctrl+Shift+Plus/Minus)\n• Complete theme support including Monokai fixes\n• Find & replace with match highlighting\n• Line numbers and auto-indentation\n• Export to multiple formats via Pandoc\n• PowerPoint & presentation export\n• Export tables to Excel/ODS spreadsheets\n• Document import & conversion\n• Table creation helper\n• Multiple themes support\n• Undo/redo functionality\n• Live word count and statistics',
              buttons: ['OK']
            });
          }
        },
        {
          label: 'Documentation',
          click: () => shell.openExternal('https://github.com/amitwh/pan-converter')
        }
      ]
    }
  ];

  const menu = Menu.buildFromTemplate(template);
  Menu.setApplicationMenu(menu);
}

function openFile() {
  const files = dialog.showOpenDialogSync(mainWindow, {
    properties: ['openFile'],
    filters: [
      { name: 'Markdown', extensions: ['md', 'markdown'] },
      { name: 'All Files', extensions: ['*'] }
    ]
  });

  if (files && files[0]) {
    currentFile = files[0];
    const content = fs.readFileSync(currentFile, 'utf-8');
    mainWindow.webContents.send('file-opened', { path: currentFile, content });
  }
}

function saveAsFile() {
  const file = dialog.showSaveDialogSync(mainWindow, {
    defaultExt: '.md',
    filters: [
      { name: 'Markdown', extensions: ['md', 'markdown'] },
      { name: 'All Files', extensions: ['*'] }
    ]
  });

  if (file) {
    currentFile = file;
    mainWindow.webContents.send('get-content-for-save', file);
  }
}

function exportFile(format) {
  if (!currentFile) {
    dialog.showErrorBox('Error', 'Please save the file first');
    return;
  }

  // Show export options dialog
  showExportOptionsDialog(format);
}

function showExportOptionsDialog(format) {
  mainWindow.webContents.send('show-export-dialog', format);
}

function showBatchConversionDialog() {
  mainWindow.webContents.send('show-batch-dialog');
}

function performExportWithOptions(format, options) {
  const outputFile = dialog.showSaveDialogSync(mainWindow, {
    defaultPath: currentFile.replace(/\.[^/.]+$/, `.${format}`),
    filters: [
      { name: format.toUpperCase(), extensions: [format] }
    ]
  });

  if (!outputFile) return; // User cancelled

  console.log(`Attempting to export ${format} to:`, outputFile);

  // Check pandoc availability first
  checkPandocAvailability().then((hasPandoc) => {
    console.log('Pandoc available:', hasPandoc);
    
    if (!hasPandoc) {
      // Handle formats that don't require pandoc
      if (format === 'html') {
        console.log('Using built-in HTML export');
        exportToHTML(outputFile);
        return;
      } else if (format === 'pdf') {
        console.log('Using built-in PDF export');
        exportToPDFElectron(outputFile);
        return;
      } else {
        dialog.showErrorBox('Export Error', 
          `Pandoc is required for ${format.toUpperCase()} export but is not installed or not found in PATH.\n\n` +
          `Please install Pandoc from: https://pandoc.org/installing.html\n\n` +
          `Alternatively, you can export to HTML or PDF using the built-in converters.`
        );
        return;
      }
    }

    // Use pandoc for export with advanced options
    console.log('Using Pandoc for export');
    let pandocCmd = `${getPandocPath()} "${currentFile}" -o "${outputFile}"`;

    // Add template if specified
    if (options.template && options.template !== 'default') {
      pandocCmd += ` --template="${options.template}"`;
    }

    // Add metadata
    if (options.metadata) {
      for (const [key, value] of Object.entries(options.metadata)) {
        if (value.trim()) {
          pandocCmd += ` -M ${key}="${value.replace(/"/g, '\\"')}"`;
        }
      }
    }

    // Add variables
    if (options.variables) {
      for (const [key, value] of Object.entries(options.variables)) {
        if (value.trim()) {
          pandocCmd += ` -V ${key}="${value.replace(/"/g, '\\"')}"`;
        }
      }
    }

    // Add other options
    if (options.toc) pandocCmd += ' --toc';
    if (options.tocDepth) pandocCmd += ` --toc-depth=${options.tocDepth}`;
    if (options.numberSections) pandocCmd += ' --number-sections';
    if (options.citeproc) pandocCmd += ' --citeproc';
    if (options.bibliography) pandocCmd += ` --bibliography="${options.bibliography}"`;
    if (options.csl) pandocCmd += ` --csl="${options.csl}"`;

    // Add specific options for PDF export to ensure proper generation
    if (format === 'pdf') {
      const pdfEngine = options.pdfEngine || 'xelatex';
      const geometry = options.geometry || 'margin=1in';
      pandocCmd += ` --pdf-engine=${pdfEngine} -V geometry:${geometry}`;

      // Try with specified PDF engine
      exec(pandocCmd, (error, stdout, stderr) => {
        if (error) {
          // Try fallback engines if the specified one fails
          const fallbackEngines = ['pdflatex', 'lualatex'];
          tryPdfFallback(currentFile, outputFile, fallbackEngines, 0, options, error);
        } else {
          showExportSuccess(outputFile);
        }
      });
    } else if (format === 'docx') {
      pandocCmd = `${getPandocPath()} "${currentFile}" -t docx -o "${outputFile}"`;
      exportWithPandoc(pandocCmd, outputFile, format);
    } else if (format === 'html') {
      pandocCmd = `${getPandocPath()} "${currentFile}" -t html5 --standalone -o "${outputFile}"`;
      exportWithPandoc(pandocCmd, outputFile, format);
    } else if (format === 'latex') {
      pandocCmd = `${getPandocPath()} "${currentFile}" -t latex -o "${outputFile}"`;
      exportWithPandoc(pandocCmd, outputFile, format);
    } else {
      // Generic export for other formats
      exportWithPandoc(pandocCmd, outputFile, format);
    }
  }).catch((error) => {
    console.error('Error checking pandoc availability:', error);
    dialog.showErrorBox('Export Error', `Error checking system requirements: ${error.message}`);
  });
}

function tryPdfFallback(inputFile, outputFile, engines, index, options, lastError) {
  if (index >= engines.length) {
    dialog.showErrorBox('PDF Export Error',
      `Failed to export PDF with all available engines. Please ensure you have one of the following installed:\n` +
      `• XeLaTeX (recommended): sudo apt-get install texlive-xetex\n` +
      `• PDFLaTeX: sudo apt-get install texlive-latex-base\n` +
      `• LuaLaTeX: sudo apt-get install texlive-luatex\n\n` +
      `Last error: ${lastError.message}`
    );
    return;
  }

  const engine = engines[index];
  const geometry = options.geometry || 'margin=1in';
  let pandocCmd = `${getPandocPath()} "${inputFile}" --pdf-engine=${engine} -V geometry:${geometry} -o "${outputFile}"`;

  // Add all other options
  if (options.template && options.template !== 'default') {
    pandocCmd += ` --template="${options.template}"`;
  }

  if (options.metadata) {
    for (const [key, value] of Object.entries(options.metadata)) {
      if (value.trim()) {
        pandocCmd += ` -M ${key}="${value.replace(/"/g, '\\"')}"`;
      }
    }
  }

  exec(pandocCmd, (error, stdout, stderr) => {
    if (error) {
      tryPdfFallback(inputFile, outputFile, engines, index + 1, options, error);
    } else {
      showExportSuccess(outputFile);
    }
  });
}

function showExportSuccess(outputFile) {
  dialog.showMessageBox(mainWindow, {
    type: 'info',
    title: 'Export Complete',
    message: `File exported successfully to ${outputFile}`,
    buttons: ['OK']
  });
}

// Helper function to export with pandoc (general)
function exportWithPandoc(pandocCmd, outputFile, format) {
  console.log(`Executing Pandoc command: ${pandocCmd}`);
  
  exec(pandocCmd, (error, stdout, stderr) => {
    if (error) {
      console.error(`Pandoc error for ${format}:`, error);
      console.error(`Pandoc stderr:`, stderr);
      console.error(`Pandoc stdout:`, stdout);
      
      // Provide more specific error messages
      let errorMessage = `Failed to export to ${format.toUpperCase()}`;
      
      if (error.message.includes('not found') || error.message.includes('not recognized')) {
        errorMessage += '\n\nPandoc is not installed or not found in PATH.';
        errorMessage += '\nPlease install Pandoc from: https://pandoc.org/installing.html';
      } else if (stderr) {
        errorMessage += `\n\nError details: ${stderr}`;
      } else {
        errorMessage += `\n\nError details: ${error.message}`;
      }
      
      errorMessage += `\n\nCommand used: ${pandocCmd}`;
      
      dialog.showErrorBox('Export Error', errorMessage);
    } else {
      console.log(`Successfully exported to ${format}:`, outputFile);
      console.log(`Pandoc stdout:`, stdout);
      if (stderr) {
        console.warn(`Pandoc stderr (non-fatal):`, stderr);
      }
      showExportSuccess(outputFile);
    }
  });
}

// Helper function to export PDF with pandoc (with fallbacks)
function exportWithPandocPDF(pandocCmd, outputFile) {
  exec(pandocCmd, (error, stdout, stderr) => {
    if (error) {
      console.log('XeLaTeX failed, trying PDFLaTeX...');
      // Fallback to pdflatex
      const fallbackCmd = pandocCmd.replace('--pdf-engine=xelatex', '--pdf-engine=pdflatex');
      exec(fallbackCmd, (fallbackError, fallbackStdout, fallbackStderr) => {
        if (fallbackError) {
          console.log('PDFLaTeX failed, trying Electron PDF...');
          // Final fallback to Electron PDF
          exportToPDFElectron(outputFile);
        } else {
          console.log('Successfully exported PDF with PDFLaTeX');
          showExportSuccess(outputFile);
        }
      });
    } else {
      console.log('Successfully exported PDF with XeLaTeX');
      showExportSuccess(outputFile);
    }
  });
}

// Export to HTML using marked (no pandoc required)
function exportToHTML(outputFile) {
  try {
    const marked = require('marked');
    const markdownContent = fs.readFileSync(currentFile, 'utf8');
    const htmlContent = marked.parse(markdownContent);
    
    const fullHtml = `<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Exported Document</title>
    <style>
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
            line-height: 1.6;
            color: #333;
            max-width: 800px;
            margin: 0 auto;
            padding: 40px;
        }
        h1, h2, h3, h4, h5, h6 {
            margin-top: 1.5em;
            margin-bottom: 0.5em;
        }
        code {
            background: #f4f4f4;
            padding: 2px 4px;
            border-radius: 3px;
            font-family: Consolas, Monaco, 'Courier New', monospace;
        }
        pre {
            background: #f4f4f4;
            padding: 1em;
            border-radius: 5px;
            overflow-x: auto;
        }
        pre code {
            background: transparent;
            padding: 0;
        }
        blockquote {
            border-left: 4px solid #ddd;
            margin-left: 0;
            padding-left: 1em;
            color: #666;
        }
        table {
            border-collapse: collapse;
            width: 100%;
            margin: 1em 0;
        }
        th, td {
            border: 1px solid #ddd;
            padding: 8px;
            text-align: left;
        }
        th {
            background-color: #f4f4f4;
        }
        a {
            color: #0066cc;
            text-decoration: none;
        }
        a:hover {
            text-decoration: underline;
        }
        img {
            max-width: 100%;
            height: auto;
        }
    </style>
</head>
<body>
    ${htmlContent}
</body>
</html>`;

    fs.writeFileSync(outputFile, fullHtml, 'utf8');
    console.log('Successfully exported HTML');
    showExportSuccess(outputFile);
  } catch (error) {
    console.error('HTML export error:', error);
    dialog.showErrorBox('HTML Export Error', `Failed to export HTML: ${error.message}`);
  }
}

// Export to PDF using Electron (no pandoc required)
function exportToPDFElectron(outputFile) {
  try {
    const marked = require('marked');
    const markdownContent = fs.readFileSync(currentFile, 'utf8');
    const htmlContent = marked.parse(markdownContent);
    
    const fullHtml = `<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>PDF Export</title>
    <style>
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
            line-height: 1.6;
            color: #333;
            max-width: 800px;
            margin: 0 auto;
            padding: 40px;
        }
        h1, h2, h3, h4, h5, h6 {
            margin-top: 1.5em;
            margin-bottom: 0.5em;
        }
        code {
            background: #f4f4f4;
            padding: 2px 4px;
            border-radius: 3px;
            font-family: Consolas, Monaco, 'Courier New', monospace;
        }
        pre {
            background: #f4f4f4;
            padding: 1em;
            border-radius: 5px;
            overflow-x: auto;
        }
        pre code {
            background: transparent;
            padding: 0;
        }
        blockquote {
            border-left: 4px solid #ddd;
            margin-left: 0;
            padding-left: 1em;
            color: #666;
        }
        table {
            border-collapse: collapse;
            width: 100%;
            margin: 1em 0;
        }
        th, td {
            border: 1px solid #ddd;
            padding: 8px;
            text-align: left;
        }
        th {
            background-color: #f4f4f4;
        }
        img {
            max-width: 100%;
            height: auto;
        }
        @media print {
            body { padding: 20px; }
        }
    </style>
</head>
<body>
    ${htmlContent}
</body>
</html>`;

    // Create a hidden window to render and export PDF
    const pdfWindow = new BrowserWindow({
      show: false,
      webPreferences: {
        nodeIntegration: true,
        contextIsolation: false
      }
    });
    
    pdfWindow.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(fullHtml)}`).then(() => {
      return pdfWindow.webContents.printToPDF({
        marginsType: 1, // Use default margins
        pageSize: 'A4',
        printBackground: true,
        printSelectionOnly: false,
        landscape: false
      });
    }).then((pdfData) => {
      fs.writeFileSync(outputFile, pdfData);
      pdfWindow.close();
      console.log('Successfully exported PDF with Electron');
      showExportSuccess(outputFile);
    }).catch((error) => {
      pdfWindow.close();
      console.error('Electron PDF export error:', error);
      dialog.showErrorBox('PDF Export Error', 
        `Failed to export PDF using built-in engine: ${error.message}\n\n` +
        `For better PDF export, please install Pandoc with LaTeX support.`
      );
    });
  } catch (error) {
    console.error('PDF export setup error:', error);
    dialog.showErrorBox('PDF Export Error', `Failed to setup PDF export: ${error.message}`);
  }
}

function exportSpreadsheet(format) {
  if (!currentFile) {
    dialog.showErrorBox('Error', 'Please save the file first');
    return;
  }

  // Request content from renderer
  mainWindow.webContents.send('get-content-for-spreadsheet', format);
}

function importDocument() {
  const files = dialog.showOpenDialogSync(mainWindow, {
    properties: ['openFile'],
    filters: [
      { name: 'Documents', extensions: ['docx', 'odt', 'rtf', 'html', 'tex', 'epub', 'pdf'] },
      { name: 'Presentations', extensions: ['pptx', 'odp'] },
      { name: 'All Files', extensions: ['*'] }
    ]
  });

  if (files && files[0]) {
    const inputFile = files[0];
    const outputFile = inputFile.replace(/\.[^/.]+$/, '.md');
    
    // Convert to markdown using pandoc
    const pandocCmd = `${getPandocPath()} "${inputFile}" -t markdown -o "${outputFile}"`;
    
    exec(pandocCmd, (error, stdout, stderr) => {
      if (error) {
        dialog.showErrorBox('Import Error', `Failed to import: ${error.message}\n\nMake sure Pandoc is installed.`);
      } else {
        // Open the converted markdown file
        currentFile = outputFile;
        const content = fs.readFileSync(outputFile, 'utf-8');
        mainWindow.webContents.send('file-opened', { path: outputFile, content });
        
        dialog.showMessageBox(mainWindow, {
          type: 'info',
          title: 'Import Complete',
          message: `Document imported successfully as ${outputFile}`,
          buttons: ['OK']
        });
      }
    });
  }
}


function setTheme(theme) {
  store.set('theme', theme);
  mainWindow.webContents.send('theme-changed', theme);
}

// IPC handlers
ipcMain.on('save-file', (event, { path, content }) => {
  fs.writeFileSync(path, content, 'utf-8');
  currentFile = path;
});

ipcMain.on('save-current-file', (event, content) => {
  if (currentFile) {
    fs.writeFileSync(currentFile, content, 'utf-8');
  } else {
    saveAsFile();
  }
});

ipcMain.on('get-theme', (event) => {
  const theme = store.get('theme', 'light');
  event.reply('theme-changed', theme);
});

// Handle tab file tracking for exports
ipcMain.on('set-current-file', (event, filePath) => {
  currentFile = filePath;
});

// Handle renderer ready for file association
ipcMain.on('renderer-ready', (event) => {
  if (app.pendingFile) {
    openFileFromPath(app.pendingFile);
    app.pendingFile = null;
  }
});

// Handle export with options
ipcMain.on('export-with-options', (event, { format, options }) => {
  performExportWithOptions(format, options);
});

// Handle batch conversion
ipcMain.on('batch-convert', (event, { inputFolder, outputFolder, format, options }) => {
  performBatchConversion(inputFolder, outputFolder, format, options);
});

// Handle folder selection for batch conversion
ipcMain.on('select-folder', (event, type) => {
  const folder = dialog.showOpenDialogSync(mainWindow, {
    properties: ['openDirectory']
  });

  if (folder && folder[0]) {
    event.reply('folder-selected', { type, path: folder[0] });
  }
});

ipcMain.on('export-spreadsheet', (event, { content, format }) => {
  const outputFile = dialog.showSaveDialogSync(mainWindow, {
    defaultPath: currentFile.replace(/\.[^/.]+$/, `.${format}`),
    filters: [
      { name: format.toUpperCase(), extensions: [format] }
    ]
  });

  if (outputFile) {
    try {
      // Parse markdown content to extract tables
      const tables = extractTablesFromMarkdown(content);

      if (tables.length === 0) {
        dialog.showErrorBox('Export Error', 'No tables found in the markdown content');
        return;
      }

      if (format === 'csv') {
        // Convert tables to CSV format
        let csvContent = '';
        tables.forEach((table, index) => {
          if (index > 0) csvContent += '\n\n'; // Separate multiple tables
          if (tables.length > 1) csvContent += `"Table ${index + 1}"\n`;

          table.forEach(row => {
            const csvRow = row.map(cell => {
              // Escape quotes and wrap in quotes if necessary
              const cleanCell = cell.replace(/"/g, '""');
              return cleanCell.includes(',') || cleanCell.includes('"') || cleanCell.includes('\n')
                ? `"${cleanCell}"` : cleanCell;
            }).join(',');
            csvContent += csvRow + '\n';
          });
        });

        // Write CSV file
        fs.writeFileSync(outputFile, csvContent, 'utf-8');
      } else if (format === 'xlsx') {
        // Convert tables to XLSX format
        const workbook = XLSX.utils.book_new();
        
        tables.forEach((table, index) => {
          const sheetName = tables.length > 1 ? `Table${index + 1}` : 'Table';
          const worksheet = XLSX.utils.aoa_to_sheet(table);
          XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
        });

        // Write XLSX file
        XLSX.writeFile(workbook, outputFile);
      }

      dialog.showMessageBox(mainWindow, {
        type: 'info',
        title: 'Export Complete',
        message: `${format.toUpperCase()} exported successfully to ${outputFile}`,
        buttons: ['OK']
      });
    } catch (error) {
      dialog.showErrorBox('Export Error', `Failed to export: ${error.message}`);
    }
  }
});

// Helper function to extract tables from markdown
function extractTablesFromMarkdown(markdown) {
  const tables = [];
  const lines = markdown.split('\n');
  let currentTable = [];
  let inTable = false;
  
  for (const line of lines) {
    if (line.includes('|')) {
      if (!inTable) {
        inTable = true;
        currentTable = [];
      }
      
      // Skip separator lines (|---|---|)
      if (!line.match(/^\s*\|?\s*:?-+:?\s*\|/)) {
        const cells = line.split('|')
          .map(cell => cell.trim())
          .filter(cell => cell !== '');
        
        if (cells.length > 0) {
          currentTable.push(cells);
        }
      }
    } else if (inTable && line.trim() === '') {
      // End of table
      if (currentTable.length > 0) {
        tables.push(currentTable);
      }
      currentTable = [];
      inTable = false;
    }
  }
  
  // Add last table if exists
  if (currentTable.length > 0) {
    tables.push(currentTable);
  }
  
  return tables;
}

function performBatchConversion(inputFolder, outputFolder, format, options) {
  if (!fs.existsSync(inputFolder)) {
    dialog.showErrorBox('Error', 'Input folder does not exist');
    return;
  }

  // Create output folder if it doesn't exist
  if (!fs.existsSync(outputFolder)) {
    try {
      fs.mkdirSync(outputFolder, { recursive: true });
    } catch (error) {
      dialog.showErrorBox('Error', `Failed to create output folder: ${error.message}`);
      return;
    }
  }

  // Find all markdown files in input folder
  const markdownFiles = [];

  function findMarkdownFiles(dir) {
    const files = fs.readdirSync(dir);

    for (const file of files) {
      const fullPath = path.join(dir, file);
      const stat = fs.statSync(fullPath);

      if (stat.isDirectory()) {
        findMarkdownFiles(fullPath); // Recursive search
      } else if (file.match(/\.(md|markdown)$/i)) {
        markdownFiles.push(fullPath);
      }
    }
  }

  findMarkdownFiles(inputFolder);

  if (markdownFiles.length === 0) {
    dialog.showErrorBox('No Files Found', 'No markdown files found in the selected folder');
    return;
  }

  // Show progress dialog
  let completedCount = 0;
  const totalCount = markdownFiles.length;

  // Process each file
  const processNextFile = (index) => {
    if (index >= markdownFiles.length) {
      // All files processed
      dialog.showMessageBox(mainWindow, {
        type: 'info',
        title: 'Batch Conversion Complete',
        message: `Successfully converted ${completedCount} out of ${totalCount} files to ${format.toUpperCase()}.`,
        buttons: ['OK']
      });
      return;
    }

    const inputFile = markdownFiles[index];
    const relativePath = path.relative(inputFolder, inputFile);
    const baseName = path.basename(relativePath, path.extname(relativePath));
    const outputFile = path.join(outputFolder, relativePath.replace(/\.(md|markdown)$/i, `.${format}`));

    // Create subdirectories in output folder if needed
    const outputDir = path.dirname(outputFile);
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }

    // Build pandoc command
    let pandocCmd = `${getPandocPath()} "${inputFile}" -o "${outputFile}"`;

    // Add template if specified
    if (options.template && options.template !== 'default') {
      pandocCmd += ` --template="${options.template}"`;
    }

    // Add metadata
    if (options.metadata) {
      for (const [key, value] of Object.entries(options.metadata)) {
        if (value.trim()) {
          pandocCmd += ` -M ${key}="${value.replace(/"/g, '\\"')}"`;
        }
      }
    }

    // Add variables
    if (options.variables) {
      for (const [key, value] of Object.entries(options.variables)) {
        if (value.trim()) {
          pandocCmd += ` -V ${key}="${value.replace(/"/g, '\\"')}"`;
        }
      }
    }

    // Add other options
    if (options.toc) pandocCmd += ' --toc';
    if (options.tocDepth) pandocCmd += ` --toc-depth=${options.tocDepth}`;
    if (options.numberSections) pandocCmd += ' --number-sections';
    if (options.citeproc) pandocCmd += ' --citeproc';
    if (options.bibliography) pandocCmd += ` --bibliography="${options.bibliography}"`;
    if (options.csl) pandocCmd += ` --csl="${options.csl}"`;

    // Add PDF-specific options
    if (format === 'pdf') {
      const pdfEngine = options.pdfEngine || 'xelatex';
      const geometry = options.geometry || 'margin=1in';
      pandocCmd += ` --pdf-engine=${pdfEngine} -V geometry:${geometry}`;
    }

    // Execute conversion
    exec(pandocCmd, (error, stdout, stderr) => {
      if (!error) {
        completedCount++;
      }

      // Update progress (you could send this to renderer for a progress bar)
      mainWindow.webContents.send('batch-progress', {
        completed: index + 1,
        total: totalCount,
        currentFile: path.basename(inputFile),
        success: !error
      });

      // Process next file
      processNextFile(index + 1);
    });
  };

  // Start processing
  processNextFile(0);
}

// Handle command line interface for file conversion
function handleCLIConversion(args) {
  const command = args[0];
  const filePath = args[args.length - 1]; // File path is always last argument
  
  if (!fs.existsSync(filePath)) {
    console.error(`Error: File not found: ${filePath}`);
    app.quit();
    return;
  }

  // Show conversion dialog for --convert command
  if (command === '--convert') {
    showConversionDialog(filePath);
    return;
  }

  // Direct conversion for --convert-to command
  if (command === '--convert-to' && args.length >= 3) {
    const format = args[1];
    performCLIConversion(filePath, format);
    return;
  }

  console.error('Usage: --convert <file> OR --convert-to <format> <file>');
  app.quit();
}

// Show conversion dialog for CLI
function showConversionDialog(filePath) {
  const { dialog } = require('electron');
  
  // Create a hidden window for dialog operations
  const hiddenWindow = new BrowserWindow({
    show: false,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: false
    }
  });

  const formats = [
    { name: 'PDF', value: 'pdf' },
    { name: 'HTML', value: 'html' },
    { name: 'DOCX', value: 'docx' },
    { name: 'LaTeX', value: 'latex' },
    { name: 'RTF', value: 'rtf' },
    { name: 'ODT', value: 'odt' },
    { name: 'PowerPoint', value: 'pptx' }
  ];

  // Create format selection dialog using message box
  const formatButtons = formats.map(f => f.name);
  formatButtons.push('Cancel');

  dialog.showMessageBox(hiddenWindow, {
    type: 'question',
    title: 'PanConverter - Choose Format',
    message: `Convert "${path.basename(filePath)}" to:`,
    detail: 'Select the output format for conversion',
    buttons: formatButtons,
    defaultId: 0,
    cancelId: formatButtons.length - 1
  }).then(result => {
    if (result.response < formats.length) {
      const selectedFormat = formats[result.response].value;
      performCLIConversion(filePath, selectedFormat);
    } else {
      console.log('Conversion cancelled');
      app.quit();
    }
    hiddenWindow.destroy();
  });
}

// Perform CLI conversion
function performCLIConversion(inputPath, format) {
  try {
    const content = fs.readFileSync(inputPath, 'utf-8');
    const outputPath = inputPath.replace(/\.[^/.]+$/, `.${format}`);
    
    console.log(`Converting "${path.basename(inputPath)}" to ${format.toUpperCase()}...`);
    
    // Use existing export functions but with CLI output
    const pandocCommand = buildPandocCommand(content, format, outputPath);
    
    exec(pandocCommand, (error, stdout, stderr) => {
      if (error) {
        console.error(`Conversion failed: ${error.message}`);
        if (stderr) console.error(`Details: ${stderr}`);
        app.quit();
        return;
      }
      
      console.log(`Successfully converted to: ${outputPath}`);
      
      // Show Windows notification
      if (process.platform === 'win32') {
        exec(`powershell -Command "New-BurntToastNotification -Text 'PanConverter', 'File converted to ${format.toUpperCase()}' -AppLogo '${path.join(__dirname, '../assets/icon.png')}'"`, () => {});
      }
      
      app.quit();
    });
  } catch (error) {
    console.error(`Error reading file: ${error.message}`);
    app.quit();
  }
}

// Build Pandoc command for CLI conversion
function buildPandocCommand(content, format, outputPath) {
  const inputFile = path.join(require('os').tmpdir(), `panconverter_temp_${Date.now()}.md`);
  fs.writeFileSync(inputFile, content, 'utf-8');
  
  let command = `pandoc "${inputFile}" -o "${outputPath}"`;
  
  switch (format) {
    case 'pdf':
      command += ' --pdf-engine=xelatex --variable geometry:margin=1in';
      break;
    case 'html':
      command += ' --self-contained --css';
      break;
    case 'docx':
      command += ' --reference-doc';
      break;
    case 'latex':
      command += ' --standalone';
      break;
    case 'pptx':
      command += ' --slide-level=2';
      break;
  }
  
  return command;
}

app.whenReady().then(() => {
  // Check for command line conversion requests
  const args = process.argv.slice(2);
  if (args.length >= 2 && (args[0] === '--convert' || args[0] === '--convert-to')) {
    handleCLIConversion(args);
    return; // Don't create window for CLI operations
  }
  
  createWindow();
  
  // Handle file association on app startup
  // Process all command line arguments except the first two (node and script path)
  const fileArgs = process.argv.slice(2);
  for (const arg of fileArgs) {
    if ((arg.endsWith('.md') || arg.endsWith('.markdown')) && fs.existsSync(arg)) {
      // Store the file to open after window is ready
      app.pendingFile = arg;
      break;
    }
  }
});

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

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

// IPC handlers for recent files
ipcMain.on('save-recent-files', (event, recentFiles) => {
  try {
    const userDataPath = app.getPath('userData');
    const recentFilesPath = path.join(userDataPath, 'recent-files.json');
    fs.writeFileSync(recentFilesPath, JSON.stringify(recentFiles, null, 2));
  } catch (error) {
    console.error('Error saving recent files:', error);
  }
});

ipcMain.on('clear-recent-files', (event) => {
  try {
    const userDataPath = app.getPath('userData');
    const recentFilesPath = path.join(userDataPath, 'recent-files.json');
    fs.writeFileSync(recentFilesPath, JSON.stringify([], null, 2));
    // Rebuild menu to reflect changes
    createMenu();
    event.reply('recent-files-cleared');
  } catch (error) {
    console.error('Error clearing recent files:', error);
  }
});

// Handle file opening on macOS
app.on('open-file', (event, filePath) => {
  event.preventDefault();
  if (mainWindow) {
    openFileFromPath(filePath);
  } else {
    // Store the file path to open after window is created
    app.pendingFile = filePath;
  }
});

// Handle file opening from command line or file association
function openFileFromPath(filePath) {
  if (fs.existsSync(filePath)) {
    currentFile = filePath;
    const content = fs.readFileSync(filePath, 'utf-8');
    if (mainWindow && mainWindow.webContents) {
      mainWindow.webContents.send('file-opened', { path: filePath, content });
    }
  }
}