"use strict";
const utils = require("@electron-toolkit/utils");
const electron = require("electron");
const path = require("path");
const fs = require("fs/promises");
const matter = require("gray-matter");
const flexsearch = require("flexsearch");
const crypto = require("crypto");
class PluginRegistry {
  constructor() {
    this.plugins = /* @__PURE__ */ new Map();
  }
  register(plugin) {
    if (!plugin.id) {
      throw new Error("Plugin must have an id");
    }
    this.plugins.set(plugin.id, plugin);
  }
  get(id) {
    return this.plugins.get(id);
  }
  list() {
    return Array.from(this.plugins.values());
  }
}
class BaseNotesAdapter {
  constructor(config = {}) {
    this.config = config;
  }
  async init() {
    throw new Error("init() not implemented");
  }
  async getAll() {
    throw new Error("getAll() not implemented");
  }
  async create(note) {
    throw new Error("create() not implemented");
  }
  async update(note) {
    throw new Error("update() not implemented");
  }
  async delete(id) {
    throw new Error("delete() not implemented");
  }
}
class FileSystemNotesAdapter extends BaseNotesAdapter {
  constructor(config) {
    super();
    for (const field in config) {
      this[field] = config[field];
    }
  }
  async init() {
    await fs.mkdir(this.notesDir, { recursive: true });
  }
  async getAll() {
    const files = await fs.readdir(this.notesDir);
    const notes = [];
    for (const file of files) {
      if (!file.endsWith(".md")) continue;
      const fullPath = path.join(this.notesDir, file);
      const raw = await fs.readFile(fullPath, "utf8");
      const parsed = matter(raw);
      notes.push({
        ...parsed.data,
        content: parsed.content
      });
    }
    return notes;
  }
  async create(note) {
    await this._write(note);
  }
  async update(note) {
    await this._write(note);
  }
  async delete(id) {
    const filePath = path.join(this.notesDir, `${id}.md`);
    await fs.unlink(filePath);
  }
  async _write(note) {
    const filePath = path.join(this.notesDir, `${note.id}.md`);
    const fileContent = matter.stringify(note.content, {
      id: note.id,
      title: note.title,
      category: note.category ?? null,
      createdAt: note.createdAt,
      updatedAt: note.updatedAt
    });
    await fs.writeFile(filePath, fileContent, "utf8");
  }
}
const filesystemPlugin = {
  id: "filesystem",
  name: "Local Filesystem",
  description: "Stores notes as markdown files locally.",
  version: "1.0.0",
  configSchema: [
    {
      key: "notesDir",
      label: "Notes Directory",
      type: "directory",
      default: path.join(electron.app.getPath("userData"), "notes"),
      required: true
    }
  ],
  createAdapter(config) {
    return new FileSystemNotesAdapter(config);
  }
};
class PluginConfig {
  constructor(defaultPlugin) {
    this.defaultPlugin = defaultPlugin;
    this.configPath = path.join(electron.app.getPath("userData"), "config.json");
  }
  async load() {
    let parsed;
    try {
      const raw = await fs.readFile(this.configPath, "utf8");
      parsed = JSON.parse(raw);
    } catch (err) {
      parsed = null;
    }
    if (!parsed || !parsed.activeAdapter) {
      const defaultConfig = {};
      for (const field of this.defaultPlugin.configSchema) {
        defaultConfig[field.key] = field.default ?? null;
      }
      parsed = {
        activeAdapter: this.defaultPlugin.id,
        adapterConfig: defaultConfig
      };
      await this.write(parsed);
    }
    return parsed;
  }
  async write(configObject) {
    const dir = path.dirname(this.configPath);
    await fs.mkdir(dir, { recursive: true });
    await fs.writeFile(
      this.configPath,
      JSON.stringify(configObject, null, 2),
      "utf8"
    );
  }
}
class NotesAPI {
  constructor(adapter) {
    if (!adapter) {
      throw new Error("NotesAPI requires a storage adapter");
    }
    this.adapter = adapter;
    this.notesCache = /* @__PURE__ */ new Map();
    this.index = new flexsearch.Index({
      tokenize: "tolerant",
      resolution: 9
    });
  }
  async init() {
    await this.adapter.init();
    const notes = await this.adapter.getAll();
    for (const note of notes) {
      this.notesCache.set(note.id, note);
      this.index.add(note.id, note.title + "\n" + note.content);
    }
  }
  /* -----------------------
       Public API
      ------------------------*/
  getCategories() {
    const categories = /* @__PURE__ */ new Set();
    for (const note of this.notesCache.values()) {
      if (note.category) {
        categories.add(note.category);
      }
    }
    return Array.from(categories).sort();
  }
  getCategoryNotes(categoryName) {
    return Array.from(this.notesCache.values()).filter((n) => n.category === categoryName).sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
  }
  getNote(id) {
    return this.notesCache.get(id) ?? null;
  }
  async createNote(metadata = {}, content = "") {
    const id = crypto.randomUUID();
    const now = (/* @__PURE__ */ new Date()).toISOString();
    const note = {
      id,
      title: metadata.title || "Untitled",
      category: metadata.category || null,
      createdAt: now,
      updatedAt: now,
      content
    };
    this.notesCache.set(id, note);
    this.index.add(id, note.title + "\n" + content);
    await this.adapter.create(note);
    return note;
  }
  async deleteNote(id) {
    await this.adapter.delete(id);
    this.notesCache.delete(id);
    this.index.remove(id);
  }
  async updateNote(id, content) {
    const note = this.notesCache.get(id);
    if (!note) throw new Error("Note not found");
    note.content = content;
    note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
    this.index.update(id, note.title + "\n" + content);
    await this.adapter.update(note);
    return note;
  }
  async updateNoteMetadata(id, updates = {}) {
    const note = this.notesCache.get(id);
    if (!note) throw new Error("Note not found");
    const allowedFields = ["title", "category"];
    for (const key of Object.keys(updates)) {
      if (!allowedFields.includes(key)) {
        throw new Error(`Invalid metadata field: ${key}`);
      }
    }
    if (updates.title !== void 0) {
      note.title = updates.title;
    }
    if (updates.category !== void 0) {
      note.category = updates.category;
    }
    note.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
    this.index.update(id, note.title + "\n" + note.content);
    await this.adapter.update(note);
    return note;
  }
  search(query) {
    const ids = this.index.search(query);
    return ids.map((id) => this.notesCache.get(id));
  }
}
const preloadPath = path.join(__dirname, "../preload/index.js");
const rendererPath = path.join(__dirname, "../renderer/index.html");
function createWindow() {
  const mainWindow2 = new electron.BrowserWindow({
    width: 354,
    height: 549,
    show: false,
    autoHideMenuBar: true,
    webPreferences: {
      preload: preloadPath,
      sandbox: false
    }
  });
  mainWindow2.on("ready-to-show", () => {
    mainWindow2.show();
  });
  mainWindow2.webContents.setWindowOpenHandler((details) => {
    electron.shell.openExternal(details.url);
    return { action: "deny" };
  });
  if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
    mainWindow2.loadURL(process.env["ELECTRON_RENDERER_URL"]);
  } else {
    mainWindow2.loadFile(rendererPath);
  }
}
function createNoteWindow(noteId) {
  const noteWindow = new electron.BrowserWindow({
    width: 354,
    height: 549,
    autoHideMenuBar: true,
    webPreferences: {
      preload: preloadPath,
      contextIsolation: true,
      nodeIntegration: false
    }
  });
  if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
    noteWindow.loadURL(
      `${process.env["ELECTRON_RENDERER_URL"]}/note/${noteId}`
    );
  } else {
    mainWindow.loadFile(rendererPath, {
      path: `/notes/${noteId}`
    });
  }
}
electron.app.whenReady().then(async () => {
  utils.electronApp.setAppUserModelId("com.electron");
  electron.app.on("browser-window-created", (_, window) => {
    utils.optimizer.watchWindowShortcuts(window);
  });
  createWindow();
  electron.app.on("activate", function() {
    if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
  });
  electron.ipcMain.on("open-note-window", (_, noteId) => {
    createNoteWindow(noteId);
  });
  const registry = new PluginRegistry();
  registry.register(filesystemPlugin);
  const config = await new PluginConfig(filesystemPlugin).load();
  const plugin = registry.get(config.activeAdapter);
  const adapter = plugin.createAdapter(config.adapterConfig);
  const notesAPI = new NotesAPI(adapter);
  await notesAPI.init();
  electron.ipcMain.handle("notesAPI:call", (_, method, args) => {
    if (!notesAPI[method]) {
      throw new Error("Invalid method");
    }
    return notesAPI[method](...args);
  });
});
electron.app.on("window-all-closed", () => {
  if (process.platform !== "darwin") {
    electron.app.quit();
  }
});