const { contextBridge, ipcRenderer } = require("electron");

const logger = {
  log: (message, ...args) => {
    // Always log in development, log with context in production
    if (process.env.NODE_ENV !== "production") {
      /* eslint-disable no-console */
      console.log(`[Preload] ${message}`, ...args);
      /* eslint-enable no-console */
    }
  },
  warn: (message, ...args) => {
    // Always log warnings
    /* eslint-disable no-console */
    console.warn(`[Preload] ${message}`, ...args);
    /* eslint-enable no-console */
  },
  error: (message, ...args) => {
    // Always log errors
    /* eslint-disable no-console */
    console.error(`[Preload] ${message}`, ...args);
    /* eslint-enable no-console */
  },
  info: (message, ...args) => {
    // Always log info in development, log with context in production
    if (process.env.NODE_ENV !== "production") {
      /* eslint-disable no-console */
      console.info(`[Preload] ${message}`, ...args);
      /* eslint-enable no-console */
    }
  },
};

// Use a more direct path resolution approach
const getPath = (pathType) => {
  switch (pathType) {
    case "userData":
      return (
        process.env.APPDATA ||
        (process.platform === "darwin"
          ? `${process.env.HOME}/Library/Application Support`
          : `${process.env.HOME}/.local/share`)
      );
    case "home":
      return process.env.HOME;
    case "appPath":
      return process.resourcesPath;
    default:
      return "";
  }
};

logger.info("Preload script starting...");

// Force electron platform in the renderer process
window.process = { env: { VITE_PLATFORM: "electron" } };

try {
  contextBridge.exposeInMainWorld("electronAPI", {
    // Path utilities
    getPath,

    // IPC functions
    send: (channel, data) => {
      const validChannels = ["toMain"];
      if (validChannels.includes(channel)) {
        ipcRenderer.send(channel, data);
      }
    },
    receive: (channel, func) => {
      const validChannels = ["fromMain"];
      if (validChannels.includes(channel)) {
        ipcRenderer.on(channel, (event, ...args) => func(...args));
      }
    },
    // Environment info
    env: {
      isElectron: true,
      isDev: process.env.NODE_ENV === "development",
      platform: "electron", // Explicitly set platform
    },
    // Path utilities
    getBasePath: () => {
      return process.env.NODE_ENV === "development" ? "/" : "./";
    },
  });

  // Expose protected methods that allow the renderer process to use
  // the ipcRenderer without exposing the entire object
  contextBridge.exposeInMainWorld(
    'electron',
    {
      // SQLite plugin bridge
      sqlite: {
        // Check if SQLite is available
        isAvailable: () => ipcRenderer.invoke('check-sqlite-availability'),
        // Execute SQLite operations
        execute: (method, ...args) => ipcRenderer.invoke('capacitor-sqlite', method, ...args),
      },
      // ... existing exposed methods ...
    }
  );

  // Create a proxy for the CapacitorSQLite plugin
  const createSQLiteProxy = () => {
    return {
      async createConnection(...args) {
        return ipcRenderer.invoke('capacitor-sqlite', 'createConnection', ...args);
      },
      async isConnection(...args) {
        return ipcRenderer.invoke('capacitor-sqlite', 'isConnection', ...args);
      },
      async retrieveConnection(...args) {
        return ipcRenderer.invoke('capacitor-sqlite', 'retrieveConnection', ...args);
      },
      async retrieveAllConnections() {
        return ipcRenderer.invoke('capacitor-sqlite', 'retrieveAllConnections');
      },
      async closeConnection(...args) {
        return ipcRenderer.invoke('capacitor-sqlite', 'closeConnection', ...args);
      },
      async closeAllConnections() {
        return ipcRenderer.invoke('capacitor-sqlite', 'closeAllConnections');
      },
      async isAvailable() {
        return ipcRenderer.invoke('capacitor-sqlite', 'isAvailable');
      },
      async getPlatform() {
        return 'electron';
      },
    };
  };

  // Expose the SQLite plugin proxy
  contextBridge.exposeInMainWorld('CapacitorSQLite', createSQLiteProxy());

  logger.info("Preload script completed successfully");
} catch (error) {
  logger.error("Error in preload script:", error);
}