import { app } from 'electron'
import fs from 'fs'
import path from 'path'
import logger from './logger.js'

/**
 * 简化的单实例管理器
 * 使用 Electron 内置的 requestSingleInstanceLock 方法
 */
export class SingleInstanceManager {
  constructor() {
    this.lockFile = null
    this.isLocked = false
  }

  /**
   * 检查是否为第一个实例
   * 使用 Electron 内置的单实例锁机制
   */
  checkSingleInstance() {
    // 直接使用 Electron 的单实例锁
    const gotTheLock = app.requestSingleInstanceLock()
    logger.info(`单实例锁检查结果: ${gotTheLock}`)
    
    if (gotTheLock) {
      // 成功获取锁，创建锁文件作为备份
      this.createLock()
      return true
    } else {
      // 无法获取锁，说明已有实例运行
      logger.info('检测到已有实例运行，阻止新实例启动')
      return false
    }
  }

  /**
   * 创建锁文件作为备份
   */
  createLock() {
    try {
      const userDataPath = app.getPath('userData')
      this.lockFile = path.join(userDataPath, 'single-instance-lock')
      
      // 写入当前进程的 PID
      fs.writeFileSync(this.lockFile, process.pid.toString())
      this.isLocked = true
      
      logger.info(`创建单实例锁文件: ${this.lockFile}, PID: ${process.pid}`)
      
      // 监听应用退出事件，清理锁文件
      app.on('before-quit', () => {
        this.removeLock()
      })
      
      app.on('will-quit', () => {
        this.removeLock()
      })
      
      // 监听进程退出信号
      process.on('exit', () => {
        this.removeLock()
      })
      
      process.on('SIGINT', () => {
        this.removeLock()
        process.exit(0)
      })
      
      process.on('SIGTERM', () => {
        this.removeLock()
        process.exit(0)
      })
      
    } catch (error) {
      logger.error('创建锁文件失败:', error)
    }
  }

  /**
   * 移除锁文件
   */
  removeLock() {
    if (this.lockFile && this.isLocked) {
      try {
        if (fs.existsSync(this.lockFile)) {
          fs.unlinkSync(this.lockFile)
          logger.info(`移除锁文件: ${this.lockFile}`)
        }
        this.isLocked = false
      } catch (error) {
        logger.error('移除锁文件失败:', error)
      }
    }
  }
}

export default SingleInstanceManager 