/**
 * @fileoverview Chahua Database Manager - Electron Main Process
 * @description แอปพลิเคชัน Desktop สำหรับจัดการฐานข้อมูล Chahua Web Store
 * คุณสมบัติ: การจัดการฐานข้อมูล, SQL Query Editor, Schema Migration, License Validation
 * @author ทีมพัฒนา Chahua
 * @version 1.0.0
 * @since 2024-01-01
 * @calledBy Electron launcher, Database management workflows
 * @dependencies 
 * - electron: Desktop application framework
 * - ./license-guard: License validation system
 * - ./server/database-server: Database connection server
 * - ./preload.js: Electron preload script
 * - ./renderer/index.html: Main application UI
 * @features
 * - Desktop database management interface
 * - PostgreSQL connection management
 * - SQL query execution and results display
 * - Database schema visualization
 * - License-based access control
 * - Multi-language support (Thai/English)
 * - Backup and restore functionality
 * @security
 * - Context isolation enabled
 * - Node integration disabled
 * - License validation required
 * - Secure preload script
 * @example
 * // Launch the application
 * npm start
 * // Or with development mode
 * npm run dev
 */

const { app, BrowserWindow, Menu, ipcMain, dialog, shell } = require('electron');
const path = require('path');
const fs = require('fs');
const { ensureLicensed, installLicenseFromContent, getLicensePath } = require('./license-guard');
const DatabaseServer = require('./server/database-server');

/**
 * ตัวแปรอ้างอิงหน้าต่างหลักของแอปพลิเคชัน
 * @type {BrowserWindow|null} อินสแตนซ์หน้าต่างหลักของ Electron
 * @description เก็บอ้างอิงหน้าต่างหลักเพื่อป้องกันการถูก garbage collect
 */
let mainWindow;

/**
 * อินสแตนซ์เซิร์ฟเวอร์ฐานข้อมูล
 * @type {DatabaseServer|null} อินสแตนซ์เซิร์ฟเวอร์สำหรับการเชื่อมต่อฐานข้อมูล
 * @description จัดการการเชื่อมต่อและการดำเนินการฐานข้อมูล
 */
let databaseServer;

/**
 * สร้างหน้าต่างหลักของแอปพลิเคชัน
 * @function createWindow
 * @description สร้างและกำหนดค่าหน้าต่าง Electron หลักพร้อมการตั้งค่าความปลอดภัย
 * @returns {void}
 * @features
 * - Context isolation สำหรับความปลอดภัย
 * - Preload script สำหรับ IPC communication
 * - การจัดการลิงก์ภายนอก
 * - DevTools ในโหมดพัฒนา
 * @security
 * - nodeIntegration: false - ปิดการเข้าถึง Node.js จาก renderer
 * - contextIsolation: true - แยกบริบทระหว่าง main และ renderer
 * - webSecurity: true - เปิดใช้ web security
 */
const createWindow = () => {
  // Create the browser window
  mainWindow = new BrowserWindow({
    width: 1400,
    height: 900,
    minWidth: 1200,
    minHeight: 700,
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      preload: path.join(__dirname, 'preload.js'),
      webSecurity: true
    },
    titleBarStyle: 'default',
    show: false // Don't show until ready
  });

  // Load the app
  mainWindow.loadFile('renderer/index.html');

  // Show window when ready
  mainWindow.once('ready-to-show', () => {
    mainWindow.show();
    
    // Open DevTools in development
    if (process.argv.includes('--dev')) {
      mainWindow.webContents.openDevTools();
    }
  });

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

  // Handle external links
  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    shell.openExternal(url);
    return { action: 'deny' };
  });
};

/**
 * ตรวจสอบและจัดการลิขสิทธิ์การใช้งาน
 * @async
 * @function gateLicense
 * @description ตรวจสอบความถูกต้องของลิขสิทธิ์และแสดงหน้าต่างการติดตั้งลิขสิทธิ์หากจำเป็น
 * @returns {Promise<void>}
 * @throws {Error} เมื่อไม่สามารถตรวจสอบลิขสิทธิ์ได้
 * @features
 * - การตรวจสอบลิขสิทธิ์อัตโนมัติ
 * - หน้าต่างการติดตั้งลิขสิทธิ์
 * - การจัดการข้อผิดพลาดลิขสิทธิ์
 */
async function gateLicense() {
  try {
    await ensureLicensed();
  } catch (err) {
    const choice = await dialog.showMessageBox({
      type: 'error',
      title: 'License Required',
      message: 'ไม่พบ/ไม่ผ่านการตรวจสอบคีย์',
      detail: `${err.message}\n\nคุณต้องติดตั้งไฟล์คีย์ก่อนใช้งาน`,
      buttons: ['ติดตั้งคีย์...', 'ออกจากโปรแกรม'],
      cancelId: 1,
      defaultId: 0
    });
    if (choice.response === 1) {
      app.quit();
      return false;
    }
    // เลือกไฟล์คีย์จากเครื่อง
    const pick = await dialog.showOpenDialog({
      title: 'เลือกไฟล์ license.key',
      properties: ['openFile'],
      filters: [{ name: 'License', extensions: ['key', 'txt'] }]
    });
    if (pick.canceled || !pick.filePaths?.[0]) {
      app.quit();
      return false;
    }
    const content = fs.readFileSync(pick.filePaths[0], 'utf8');
    try {
      const data = await installLicenseFromContent(content);
      await dialog.showMessageBox({
        type: 'info',
        message: 'ติดตั้งคีย์สำเร็จ',
        detail: `หมดอายุ: ${new Date(data.expiresAt).toLocaleString()}\nที่อยู่ไฟล์: ${getLicensePath()}`
      });
      return true;
    } catch (e) {
      await dialog.showErrorBox('คีย์ไม่ถูกต้อง', e.message);
      app.quit();
      return false;
    }
  }
  return true;
}

// App event handlers
app.whenReady().then(async () => {
  const ok = await gateLicense();
  if (!ok) return;

  // จากนั้นค่อยเริ่มทำงานตามปกติ
  createWindow();
  createMenu();
  
  // Start the database server
  try {
    databaseServer = new DatabaseServer();
    await databaseServer.start();
    console.log(' Database server started successfully');
  } catch (error) {
    console.error(' Failed to start database server:', error);
    dialog.showErrorBox('Server Error', 'Failed to start database server: ' + error.message);
  }

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

app.on('window-all-closed', async () => {
  // Stop database server
  if (databaseServer) {
    await databaseServer.stop();
  }
  
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('before-quit', async () => {
  // Stop database server
  if (databaseServer) {
    await databaseServer.stop();
  }
});

// Create application menu
const createMenu = () => {
  const template = [
    {
      label: 'File',
      submenu: [
        {
          label: 'New Connection',
          accelerator: 'CmdOrCtrl+N',
          click: () => {
            mainWindow.webContents.send('menu-action', 'new-connection');
          }
        },
        {
          label: 'Import SQL File',
          accelerator: 'CmdOrCtrl+O',
          click: async () => {
            const result = await dialog.showOpenDialog(mainWindow, {
              properties: ['openFile'],
              filters: [
                { name: 'SQL Files', extensions: ['sql'] },
                { name: 'All Files', extensions: ['*'] }
              ]
            });
            
            if (!result.canceled && result.filePaths.length > 0) {
              mainWindow.webContents.send('menu-action', 'import-sql', result.filePaths[0]);
            }
          }
        },
        { type: 'separator' },
        {
          label: 'Export Query Results',
          accelerator: 'CmdOrCtrl+E',
          click: () => {
            mainWindow.webContents.send('menu-action', 'export-results');
          }
        },
        { type: 'separator' },
        {
          label: 'Exit',
          accelerator: process.platform === 'darwin' ? 'Cmd+Q' : 'Ctrl+Q',
          click: () => {
            app.quit();
          }
        }
      ]
    },
    {
      label: 'Edit',
      submenu: [
        { role: 'undo' },
        { role: 'redo' },
        { type: 'separator' },
        { role: 'cut' },
        { role: 'copy' },
        { role: 'paste' },
        { role: 'selectall' }
      ]
    },
    {
      label: 'Database',
      submenu: [
        {
          label: 'Test Connection',
          accelerator: 'CmdOrCtrl+T',
          click: () => {
            mainWindow.webContents.send('menu-action', 'test-connection');
          }
        },
        {
          label: 'Refresh Structure',
          accelerator: 'F5',
          click: () => {
            mainWindow.webContents.send('menu-action', 'refresh-structure');
          }
        },
        { type: 'separator' },
        {
          label: 'Execute Query',
          accelerator: 'CmdOrCtrl+Enter',
          click: () => {
            mainWindow.webContents.send('menu-action', 'execute-query');
          }
        }
      ]
    },
    {
      label: 'View',
      submenu: [
        { role: 'reload' },
        { role: 'forceReload' },
        { role: 'toggleDevTools' },
        { type: 'separator' },
        { role: 'resetZoom' },
        { role: 'zoomIn' },
        { role: 'zoomOut' },
        { type: 'separator' },
        { role: 'togglefullscreen' }
      ]
    },
    {
      label: 'License',
      submenu: [
        {
          label: 'ติดตั้ง/เปลี่ยนคีย์...',
          click: async () => {
            const pick = await dialog.showOpenDialog(mainWindow, {
              title: 'เลือกไฟล์ license.key',
              properties: ['openFile'],
              filters: [{ name: 'License', extensions: ['key', 'txt'] }]
            });
            if (pick.canceled) return;
            const content = fs.readFileSync(pick.filePaths[0], 'utf8');
            try {
              const data = await installLicenseFromContent(content);
              dialog.showMessageBox(mainWindow, { 
                type: 'info', 
                message: 'ติดตั้งคีย์สำเร็จ', 
                detail: `หมดอายุ: ${new Date(data.expiresAt).toLocaleString()}` 
              });
            } catch (e) {
              dialog.showErrorBox('คีย์ไม่ถูกต้อง', e.message);
            }
          }
        },
        { type: 'separator' },
        { 
          label: 'ตำแหน่งไฟล์คีย์', 
          click: () => shell.showItemInFolder(getLicensePath()) 
        }
      ]
    },
    {
      label: 'Help',
      submenu: [
        {
          label: 'About Chahua Database Manager',
          click: () => {
            dialog.showMessageBox(mainWindow, {
              type: 'info',
              title: 'About',
              message: 'Chahua Database Manager v1.0.0',
              detail: 'Professional database management tool for multiple database systems.\n\nSupported databases:\n• PostgreSQL\n• MySQL/MariaDB\n• SQLite\n• MongoDB\n• Redis'
            });
          }
        },
        { type: 'separator' },
        {
          label: 'Visit Website',
          click: () => {
            shell.openExternal('https://chahuadev.com');
          }
        }
      ]
    }
  ];

  // macOS specific menu adjustments
  if (process.platform === 'darwin') {
    template.unshift({
      label: app.getName(),
      submenu: [
        { role: 'about' },
        { type: 'separator' },
        { role: 'services' },
        { type: 'separator' },
        { role: 'hide' },
        { role: 'hideOthers' },
        { role: 'unhide' },
        { type: 'separator' },
        { role: 'quit' }
      ]
    });
  }

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

// IPC handlers
ipcMain.handle('get-app-version', () => {
  return app.getVersion();
});

ipcMain.handle('show-save-dialog', async (event, options) => {
  const result = await dialog.showSaveDialog(mainWindow, options);
  return result;
});

ipcMain.handle('show-open-dialog', async (event, options) => {
  const result = await dialog.showOpenDialog(mainWindow, options);
  return result;
});

ipcMain.handle('read-file', async (event, filePath) => {
  try {
    const content = fs.readFileSync(filePath, 'utf8');
    return { success: true, content };
  } catch (error) {
    return { success: false, error: error.message };
  }
});

ipcMain.handle('write-file', async (event, filePath, content) => {
  try {
    fs.writeFileSync(filePath, content, 'utf8');
    return { success: true };
  } catch (error) {
    return { success: false, error: error.message };
  }
});

ipcMain.handle('get-server-port', () => {
  return databaseServer ? databaseServer.getPort() : 3001;
});

// License status handler
ipcMain.handle('license:getStatus', async () => {
  try {
    const d = await ensureLicensed();
    return {
      ok: true,
      data: {
        pluginId: d.pluginId,
        currentTier: d.currentTier,
        expiresAt: d.expiresAt,
        daysRemaining: d.daysRemaining
      }
    };
  } catch (e) {
    return { ok: false, error: e.message };
  }
});

// Handle app updates (future feature)
ipcMain.handle('check-for-updates', async () => {
  // Placeholder for auto-updater
  return { hasUpdate: false };
});

module.exports = { mainWindow };