/**
 * Electron API mocks for testing
 * Mocks safeStorage, app, and other Electron APIs
 */

import { vi } from "vitest";

// In-memory storage for encrypted passwords (simulates OS keychain)
const encryptedStore = new Map<string, string>();

/**
 * Mock safeStorage for password encryption
 * In tests, we use a simple reversible encoding instead of actual encryption
 */
export const safeStorage = {
  /**
   * Encrypt a string (simulated)
   * In production, this uses OS-specific encryption
   */
  encryptString: vi.fn((plaintext: string): Buffer => {
    const encoded = Buffer.from(`encrypted:${plaintext}`).toString("base64");
    return Buffer.from(encoded);
  }),

  /**
   * Decrypt a buffer (simulated)
   */
  decryptString: vi.fn((encrypted: Buffer): string => {
    const decoded = encrypted.toString();
    const base64Content = decoded.replace("encrypted:", "");
    return Buffer.from(base64Content, "base64")
      .toString()
      .replace("encrypted:", "");
  }),

  /**
   * Check if encryption is available
   */
  isEncryptionAvailable: vi.fn((): boolean => true),

  /**
   * Get the current storage backend
   */
  getSelectedStorageBackend: vi.fn((): string => "mock_backend"),
};

/**
 * Mock Electron app
 */
export const app = {
  getName: vi.fn(() => "Kintone Customize Manager"),
  getVersion: vi.fn(() => "1.0.0"),
  getPath: vi.fn((key: string): string => {
    const paths: Record<string, string> = {
      userData: "/tmp/kintone-manager-test/userData",
      home: "/tmp/kintone-manager-test/home",
      temp: "/tmp/kintone-manager-test/temp",
      appData: "/tmp/kintone-manager-test/appData",
      desktop: "/tmp/kintone-manager-test/desktop",
      documents: "/tmp/kintone-manager-test/documents",
      downloads: "/tmp/kintone-manager-test/downloads",
    };
    return paths[key] || "/tmp/kintone-manager-test";
  }),
  whenReady: vi.fn(() => Promise.resolve()),
  on: vi.fn(),
  quit: vi.fn(),
  isReady: vi.fn(() => true),
};

/**
 * Mock ipcMain for IPC handler tests
 */
class IPCMainMock {
  private handlers = new Map<string, Function>();

  handle = vi.fn((channel: string, handler: Function) => {
    this.handlers.set(channel, handler);
  });

  handleOnce = vi.fn((channel: string, handler: Function) => {
    this.handlers.set(channel, handler);
  });

  removeHandler = vi.fn((channel: string) => {
    this.handlers.delete(channel);
  });

  // Helper to call a handler directly in tests
  async invoke(channel: string, ...args: unknown[]): Promise<unknown> {
    const handler = this.handlers.get(channel);
    if (!handler) {
      throw new Error(`No handler registered for channel: ${channel}`);
    }
    return handler({}, ...args);
  }
}

export const ipcMain = new IPCMainMock();

/**
 * Mock BrowserWindow
 */
export const BrowserWindow = vi.fn().mockImplementation(() => ({
  loadURL: vi.fn(),
  loadFile: vi.fn(),
  on: vi.fn(),
  webContents: {
    on: vi.fn(),
    send: vi.fn(),
    openDevTools: vi.fn(),
  },
  show: vi.fn(),
  close: vi.fn(),
}));

/**
 * Mock dialog
 */
export const dialog = {
  showOpenDialog: vi.fn().mockResolvedValue({ canceled: false, filePaths: [] }),
  showMessageBox: vi.fn().mockResolvedValue({ response: 0 }),
  showSaveDialog: vi.fn().mockResolvedValue({ canceled: false, filePath: "" }),
};

/**
 * Mock clipboard
 */
export const clipboard = {
  writeText: vi.fn(),
  readText: vi.fn(() => ""),
};

// Default export with all mocked APIs
export default {
  app,
  safeStorage,
  ipcMain,
  BrowserWindow,
  dialog,
  clipboard,
};