main.js

const { app, BrowserWindow, ipcMain, dialog, Menu } = require('electron');
const path = require('path');
const express = require('express');
const { spawn } = require('child_process');

let mainWindow;
let serverProcess;

// 启动后端服务器
function startServer() {
  const serverPath = path.join(__dirname, 'server', 'index.js');
  serverProcess = spawn('node', [serverPath], {
    cwd: __dirname,
    stdio: 'inherit'
  });

  serverProcess.on('error', (error) => {
    console.error('服务器启动失败:', error);
  });
}

// 等待服务器就绪
function waitForServer(url, maxAttempts = 30, interval = 1000) {
  return new Promise((resolve, reject) => {
    const http = require('http');
    const urlModule = require('url');
    let attempts = 0;

    const checkServer = () => {
      attempts++;
      try {
        const urlObj = urlModule.parse(url);
        const options = {
          hostname: urlObj.hostname || 'localhost',
          port: urlObj.port || 3000,
          path: urlObj.pathname || '/',
          method: 'GET',
          timeout: 3000
        };
        
        console.log(`尝试连接服务器 (${attempts}/${maxAttempts}):`, options);

        const req = http.request(options, (res) => {
          // 接受更多状态码（包括重定向等）
          if (res.statusCode >= 200 && res.statusCode < 400) {
            console.log(`服务器已就绪 (状态码: ${res.statusCode})`);
            resolve();
          } else {
            console.log(`收到状态码: ${res.statusCode}，继续等待...`);
            if (attempts < maxAttempts) {
              setTimeout(checkServer, interval);
            } else {
              reject(new Error(`服务器返回异常状态码: ${res.statusCode}`));
            }
          }
        });

        req.on('error', (error) => {
          console.log(`连接错误 (尝试 ${attempts}/${maxAttempts}):`, error.message);
          if (attempts < maxAttempts) {
            setTimeout(checkServer, interval);
          } else {
            reject(new Error(`无法连接到开发服务器: ${error.message}`));
          }
        });

        req.on('timeout', () => {
          req.destroy();
          if (attempts < maxAttempts) {
            setTimeout(checkServer, interval);
          } else {
            reject(new Error('服务器连接超时'));
          }
        });

        req.end();
      } catch (error) {
        if (attempts < maxAttempts) {
          setTimeout(checkServer, interval);
        } else {
          reject(new Error(`连接失败: ${error.message}`));
        }
      }
    };

    checkServer();
  });
}

// 创建主窗口
function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    minWidth: 800,
    minHeight: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true,
      enableRemoteModule: false
    },
    icon: path.join(__dirname, 'assets', 'icon.png'),
    show: false // 先不显示，等加载完成后再显示
  });

  // 开发环境加载 React 开发服务器，生产环境加载构建文件
  const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged;
  
  if (isDev) {
    const devUrl = 'http://localhost:3000';
    console.log('准备加载 React 开发服务器...');
    
    // 先尝试直接加载，如果失败再等待
    const tryLoad = () => {
      console.log('尝试直接加载开发服务器:', devUrl);
      mainWindow.loadURL(devUrl)
        .then(() => {
          console.log('✅ 成功加载开发服务器');
          mainWindow.webContents.openDevTools();
          mainWindow.show();
        })
        .catch((error) => {
          console.log('直接加载失败，开始等待服务器就绪...', error.message);
          // 如果直接加载失败，等待服务器就绪
          waitForServer(devUrl)
            .then(() => {
              console.log('✅ 服务器已就绪，重新加载:', devUrl);
              return mainWindow.loadURL(devUrl);
            })
            .then(() => {
              console.log('✅ 成功加载开发服务器');
              mainWindow.webContents.openDevTools();
              mainWindow.show();
            })
            .catch((waitError) => {
              console.error('❌ 等待服务器失败:', waitError);
              mainWindow.loadFile(path.join(__dirname, 'public', 'index.html'));
              mainWindow.show();
              
              // 显示错误对话框
              dialog.showErrorBox(
                '开发服务器连接失败',
                `无法连接到 React 开发服务器 (http://localhost:3000)\n\n请确保已运行 "npm run dev:react" 或 "npm run dev"\n\n错误: ${waitError.message}`
              );
            });
        });
    };
    
    // 延迟一点再尝试，给服务器更多启动时间
    setTimeout(tryLoad, 500);
  } else {
    mainWindow.loadFile(path.join(__dirname, 'build', 'index.html'));
    mainWindow.show();
  }

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

// 处理文件选择对话框
ipcMain.handle('dialog:openFile', async () => {
  const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
    properties: ['openFile', 'multiSelections'],
    filters: [
      { name: 'Markdown文件', extensions: ['md', 'markdown'] },
      { name: '所有文件', extensions: ['*'] }
    ]
  });

  if (canceled) {
    return null;
  } else {
    return filePaths;
  }
});

// 处理目录选择对话框
ipcMain.handle('dialog:openDirectory', async () => {
  const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory']
  });

  if (canceled) {
    return null;
  } else {
    return filePaths[0];
  }
});

// 处理打开文件位置
ipcMain.handle('shell:showItemInFolder', async (event, filePath) => {
  const { shell } = require('electron');
  shell.showItemInFolder(filePath);
});

// 处理打开文件
ipcMain.handle('shell:openPath', async (event, filePath) => {
  const { shell } = require('electron');
  return shell.openPath(filePath);
});

// 应用准备就绪
app.whenReady().then(() => {
  // 移除默认菜单栏
  Menu.setApplicationMenu(null);
  
  startServer();
  createWindow();

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

// 所有窗口关闭时退出
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    if (serverProcess) {
      serverProcess.kill();
    }
    app.quit();
  }
});

// 应用退出前清理
app.on('before-quit', () => {
  if (serverProcess) {
    serverProcess.kill();
  }
});