//用于控制应用程序寿命和创建本机浏览器窗口的模块
const { app, BrowserWindow } = require('electron')
const path = require('node:path')

function createWindow () {
  // 创建浏览器窗口。
  const mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js')
    }
  })

  // 并加载应用程序的index.html。
  mainWindow.loadFile('index.html')

  // 打开 DevTools。
  // mainWindow.webContents.openDevTools()
}

// 当 Electron 完成时，将调用此方法
// 初始化并准备好创建浏览器窗口。
// 某些 API 只能在此事件发生后使用。
app.whenReady().then(() => {
  createWindow()

  app.on('activate', function () {
// 在 macOS 上，当单击停靠图标，并且没有打开其他窗口。
    if (BrowserWindow.getAllWindows().length === 0) createWindow()
  })
})

// 当所有窗口都关闭时退出，但在 macOS 上除外。在那里，这很常见
// 用于应用程序及其菜单栏保持活动状态，直到用户退出
// 明确使用 Cmd + Q。
app.on('window-all-closed', function () {
  if (process.platform !== 'darwin') app.quit()
})

// 在此文件中，您可以包含应用的特定主进程的其余部分
// 法典。您也可以将它们放在单独的文件中，并在此处需要它们。

const { BrowserWindow } = require('electron')
// ...
 // 创建浏览器窗口。
  const mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js')
    }
  })
// ...

window.myAPI = {
  desktop: true
}

const mainWindow = new BrowserWindow({
  width: 800,
  height: 600,
  webPreferences: {
    preload: path.join(__dirname, 'preload.js'),
    contextIsolation: false, // 不使用上下文隔离
  }
})

// 在上下文隔离启用的情况下使用预加载
const { contextBridge } = require('electron')

contextBridge.exposeInMainWorld('myAPI', {
  doAThing: () => {}
})

// 引入预加载脚本
const {contextBridge, ipcRenderer} = require('electron')
// 暴露一个方法给主进程
contextBridge.exposeInMainWorld('electronAPI', {
  setTitle: (title) => {
    ipcRenderer.send('set-title', title)
  }
})

ipcMain.on('set-title', (event, title) => {
    BrowserWindow.getFocusedWindow().setTitle(title)
})

const mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    ++ frame: false,
    webPreferences: {
        preload: path.join(__dirname, 'preload.js'),
        nodeIntegration: true,
        contextIsolation: true
    }
})

// 引入预加载脚本
const {contextBridge, ipcRenderer} = require('electron')
// 暴露一个方法给主进程
contextBridge.exposeInMainWorld('electronAPI', {
  invoke: (channel, ...args) => {
    return ipcRenderer.invoke(channel, ...args)
  }
})

/**
 * 处理来自渲染进程的'dialog:openFile'事件。
 * 
 * 此函数用于在主进程侧响应渲染进程发起的打开文件对话框请求。它通过dialog.showOpenDialog显示对话框，
 * 并返回用户选择的文件路径。如果用户取消了对话框，则返回undefined。
 * 
 * @returns {Promise<string | undefined>} 用户选择的文件路径，如果取消则为undefined。
 */
ipcMain.handle('dialog:openFile', async () => {
    // 显示打开文件对话框，并等待用户选择文件
    const { canceled, filePaths } = await dialog.showOpenDialog(BrowserWindow.getFocusedWindow(), {
        properties: ['openFile']
    })

    // 根据对话框是否被取消，返回用户选择的文件路径或undefined
    return canceled ? undefined : filePaths[0]
})

btn2.addEventListener('click', async () => {
   const filePaths =await window.electronAPI.invoke('dialog:openFile');
   console.log(filePaths);
});

// 引入预加载脚本
const {contextBridge, ipcRenderer} = require('electron')
// 暴露一个方法给主进程
contextBridge.exposeInMainWorld('electronAPI', {
  invoke: (channel) => {
    return ipcRenderer.invoke(channel)
  }
})

const {app, BrowserWindow, ipcMain,nativeTheme} = require('electron')
// 改变主题
ipcMain.handle('native-theme', async () => {
    if (nativeTheme.shouldUseDarkColors){
        nativeTheme.themeSource = 'light'
    }else{
        nativeTheme.themeSource = 'dark'
    }
    return nativeTheme.themeSource
})
// 系统主题
ipcMain.handle('native-theme-system', async (event, theme) => {
    nativeTheme.themeSource = 'system'
    return 'system'
})

const {app, BrowserWindow, Menu, nativeTheme} = require('electron');
// 创建菜单
const createMenuApplication = () => {
    const template = [
            // 菜单标题
            {label: '首页',},
            {
                label: '分类',
                // 子菜单
                submenu: [
                    {label: '系统',},
                    {label: '生活',},
                    {type: 'separator'},
                    {label: '技术',},
                ],
            },
             {
            label: '主题切换',
            submenu: [
                {
                    label: '暗黑',
                    checked: nativeTheme.shouldUseDarkColors,
                    click: () => nativeTheme.themeSource = 'dark'
                },
                {
                    label: '浅色',
                    checked: !nativeTheme.shouldUseDarkColors,
                    click: () => nativeTheme.themeSource = 'light'
                }
                ]
        }
       ]
    // 创建应用级菜单
    const menu = Menu.buildFromTemplate(template);
    Menu.setApplicationMenu(menu)
}

// 当 Electron 完成时，将调用此方法
// 初始化并准备好创建浏览器窗口。
// 某些 API 只能在此事件发生后使用。
    app.whenReady().then(() => {
        // 创建浏览器窗口
        createWindow();
        // 创建菜单
        createMenuApplication();
    }

const {contextBridge, ipcRenderer} = require('electron')
// 暴露给渲染进程
contextBridge.exposeInMainWorld('electronAPI', {
    send: (channel,args) => {
        ipcRenderer.send(channel, args)
    },
    invoke: (channel, ...args) => {
        return ipcRenderer.invoke(channel, args)
    }
})

const {app, BrowserWindow, Menu, nativeTheme,ipcMain} = require('electron');
/**
 * 监听ipcMain的'contextmenu'事件，用于处理右键菜单的逻辑。
 * 当右键菜单被触发时，此函数将构建一个自定义的菜单并显示在相应的窗口中。
 * 
 * @param {Event} event Electron的事件对象，用于传递相关数据。
 * @param {Object[]} arg 右键菜单的初始项数组，来自前端的请求。
 */
ipcMain.on('contextmenu',(event,arg)=>{
    // 构建菜单模板，融合传入的参数和固定的菜单项。
    const template = [
        ...arg,
        // 添加一个固定项：'首页'菜单项。
        // 菜单标题
        {label: '首页',},

    ]
    // 根据菜单模板创建实际的菜单对象。
    // 创建应用级菜单
    const menu = Menu.buildFromTemplate(template);
    // 从事件对象中获取发送请求的Web内容对应的BrowserWindow对象。
    const win = BrowserWindow.fromWebContents(event.sender)
    // 在对应的窗口中弹出构建好的菜单。
    menu.popup({window:win})
})

const {app, BrowserWindow, Menu, nativeTheme, ipcMain, Tray, nativeImage} = require('electron');


let mainWindow = null;
// 创建浏览器窗口。
const createWindow = () => {
    // Create the browser window.
    mainWindow = new BrowserWindow({
        width: 800,
        height: 600,
        webPreferences: {
            preload: path.join(__dirname, 'preload.js'),
        },
    });

    // 并加载应用程序的index.html。
    mainWindow.loadFile(path.join(__dirname, 'index.html'));
// 窗口关闭事件
    mainWindow.on('close', (event) => {
        // 阻止默认事件——彻底关闭该进程
        event.preventDefault();
        mainWindow.hide();
    });
// 窗口关闭事件
    mainWindow.on('closed', () => {
        mainWindow = null;
    })
    // Open the DevTools.
    // mainWindow.webContents.openDevTools();
};

/**
 * 创建系统托盘图标并设置其相关属性。
 * 托盘图标具有一个上下文菜单，包含打开主窗口和退出应用程序的选项。
 * 
 * @remarks
 * 此函数不接受任何参数。
 * 创建的托盘图标和上下文菜单与主应用程序窗口和应用程序本身的行为直接相关。
 */
function createTray() {
    // 构建上下文菜单的模板，包含两个菜单项：打开主窗口和退出。
    const contextMenu = Menu.buildFromTemplate([
        {label: '打开主窗口', click: () => {
            // 点击“打开主窗口”菜单项时，显示主应用程序窗口。
            mainWindow.show()
            }},
        {type: 'separator'}, // 分隔菜单项。
        {label: '退出', click: () => {
            // 点击“退出”菜单项时，销毁主应用程序窗口并退出应用程序。
            mainWindow.destroy();
            app.quit()
            }}
    ])
    // 从路径创建托盘图标的图像。
    const icon = nativeImage.createFromPath('src/assets/tray.jpg');
    // 创建托盘图标实例。
    const tray = new Tray(icon)
    // 设置托盘图标的工具提示文本。
    tray.setToolTip('这是我的应用程序.')
    // 设置托盘图标的标题。
    tray.setTitle('这是标题')
    // 设置托盘图标的上下文菜单。
    tray.setContextMenu(contextMenu)
}

const {app, BrowserWindow, Menu,
    nativeTheme, ipcMain, Tray, nativeImage,++ Notification} = require('electron');


/**
 * 创建一个系统通知。
 * 
 * 该函数通过Notification类创建一个系统通知对象，并配置其标题、正文和图标。
 * 当通知被点击时，会触发点击事件的回调函数。
 */
function createNotification() {
    // 创建一个通知实例，配置通知的标题、正文和图标
    const notification = new Notification({
        title: '通知标题',
        body: '通知内容',
        icon: 'src/assets/tray.jpg',
    })

    // 注册通知点击事件的处理函数
    notification.on('click', () => {
        console.log('通知被点击')
    })

    // 显示通知
    notification.show()
}
app.whenReady().then(() => {
    // 创建浏览器窗口
    createWindow();
    // 创建菜单
    // createMenuApplication();
    // 创建托盘
    createTray()
    // 创建通知
    ++ createNotification()
}

const {app, BrowserWindow, Menu,
    nativeTheme, ipcMain, Tray,
    nativeImage,Notification,
   ++ globalShortcut
} = require('electron');

app.whenReady().then(() => {
    // 创建浏览器窗口
    createWindow();
    // 创建菜单
     createMenuApplication();
    // 创建托盘
    createTray()
    // 创建通知
    createNotification();
   // 注册快捷键
    ++ registerShortcuts();})
/**
 * 注册全局快捷键。
 * 本函数旨在通过监听特定的键盘快捷键，实现一些特定的功能，如打开开发者工具或关闭窗口。
 * 使用Electron的globalShortcut模块来实现这一功能。
 * 
 * @remarks
 * - 'CommandOrControl+Shift+I' 快捷键用于打开开发者工具。
 * - 'CommandOrControl+W' 快捷键用于关闭当前窗口。
 */
function registerShortcuts() {
    // 注册快捷键CommandOrControl+Shift+I，用于打开开发者工具
    globalShortcut.register('CommandOrControl+Shift+I', () => {
       BrowserWindow.getFocusedWindow().webContents.openDevTools();
    });
  
    // 注册快捷键CommandOrControl+W，用于关闭当前窗口
    globalShortcut.register('CommandOrControl+W', () => {
       BrowserWindow.getFocusedWindow().close();
    });
}

app.on("will-quit", () => {
    globalShortcut.unregisterAll();
});

const {contextBridge, ipcRenderer} = require('electron')
// 暴露给渲染进程
contextBridge.exposeInMainWorld('electronAPI', {
    send: (channel,args) => {
        ipcRenderer.send(channel, args)
    },
    invoke: (channel, args) => {
        return ipcRenderer.invoke(channel, args)
    }
})

/**
 * 处理来自渲染进程的对话框消息请求。
 *
 * 此函数用于响应渲染进程（Web页面）发送的请求，以显示各种类型的对话框（如消息框、保存文件对话框等）。
 * 它通过ipcMain模块的事件监听器来接收请求，并使用dialog模块的功能来显示对话框。
 *
 * @param {Event} event IPC事件对象，用于传递对话框选项和接收对话框的返回值。
 * @param {Object} options 对话框的配置选项，如消息文本、按钮标签、对话框类型等。
 * @returns {Number} 对话框的返回值，通常是一个表示用户点击的按钮的索引。
 */
ipcMain.handle('dialog:message-box',  async (event, options) => {
    // 获取发送请求的Web内容对应的BrowserWindow对象
    const win = BrowserWindow.fromWebContents(event.sender)
    // 显示同步消息框，并返回用户的选择
    return  dialog.showMessageBox(win, options)
})

/**
 * 处理来自渲染进程的打开文件对话框请求。
 * 
 * 此函数被设计为在主进程侧响应渲染进程通过IPC（Inter-Process Communication）发送的请求，
 * 具体来说，当渲染进程需要打开一个文件对话框以允许用户选择文件时，它会触发这个事件。
 * 使用Electron的dialog模块来显示操作系统原生的文件选择对话框，并返回用户选择的结果。
 * 
 * @param {Electron.IpcMainEvent} event - IPC事件对象，用于接收和发送消息。
 * @param {Object} options - 显示对话框时的选项，例如文件类型过滤器等。
 * @returns {Promise<Array<string>>} - 返回一个Promise，解析为用户选择的文件路径数组。
 */
ipcMain.handle('dialog:open-file', async (event, options) => {
    // 从事件对象中获取发送请求的渲染进程对应的浏览器窗口对象。
    const win = BrowserWindow.fromWebContents(event.sender)
    // 在找到的浏览器窗口上显示打开文件对话框，并返回对话框的结果。
    return dialog.showOpenDialog(win, options)
})


/**
 * 处理来自渲染进程的'dialog:open-file-content'事件。
 * 
 * 此函数被设计为在主进程内使用，通过IPC（Inter-Process Communication）机制与渲染进程通信。
 * 当渲染进程发送'dialog:open-file-content'事件时，此函数会被调用，用于读取指定文件的内容。
 * 
 * @param {Electron.IpcMainEvent} event - IPC事件对象，用于与发送方通信。
 * @param {string} filePath - 要读取的文件的路径。
 * @returns {Promise<string>} - 返回一个Promise，解析为指定文件的内容，以字符串形式。
 */
ipcMain.handle('dialog:open-file-content', async (event, filePath) => {
    // 使用Node.js的fs模块异步读取文件内容。
    return fs.promises.readFile(filePath, 'utf-8')
})

ipcMain.handle('dialog:save-file', async (event, options) => {
    const win = BrowserWindow.fromWebContents(event.sender)
    return dialog.showSaveDialog(win, options)
})

ipcMain.handle('dialog:save-file-content', async (event, {filePath, content}) => {
    return fs.promises.writeFile(filePath, content)
})

const onlineIcon = nativeImage.createFromPath('src/assets/online.jpeg');
const offlineIcon = nativeImage.createFromPath('src/assets/offline.jpeg');
let tray = null;
function createTray() {
    tray = new Tray(onlineIcon)
}
// 监测当前的在线状态
ipcMain.on('online-status:change', (event, status) => {
    
    // 在线状态，则为在线图标，否则为离线图标
    // if (status) {
    //     tray.setImage(onlineIcon)
    // } else {
    //     tray.setImage(offlineIcon)
    // }
// 图标闪烁的效果
    let flag = true;
    setInterval(() => {
        flag ? tray.setImage(onlineIcon) : tray.setImage(nativeImage.createEmpty());
        flag = !flag;
    },500)
 })

let loadingWindow = null
const createLoadingWindow =() => {
     loadingWindow = new BrowserWindow({
         width: 300,
         height: 300,
         frame: false,
         webPreferences: {
             webSecurity: false, // 添加这一行
             preload: path.join(__dirname, 'preload.js')
         }
     })
        // 并加载应用程序的index.html。
        loadingWindow.loadFile( 'src/loading.html');
}

ipcMain.on('loading-finish', (event) => {
    loadingWindow.close()
    mainWindow.show()
 })

const { BrowserWindow } = require('electron')

const top = new BrowserWindow()
const child = new BrowserWindow({ parent: top })
child.show()
top.show()

const { BrowserWindow } = require('electron')

const top = new BrowserWindow()
const child = new BrowserWindow({ parent: top, modal: true, show: false })
child.loadURL('https://github.com')
child.once('ready-to-show', () => {
  child.show()
})

win.on('close', async(event)=>{

// 阻止默认 行为

// 询问是否确认此操作

const options = {

type: 'question',

title: '操作提示'，

message：'确认关闭当前窗口吗？'

button：['OK', 'Cancel'],

}

cosnt result = await window.ipcRenderer.invoke('dialog:meeage-box',option);

if(result.response === 0){

win.destroy();}

})