// Offline desktop implementation of the repository seam: maps each operation to a
// Tauri command backed by the on-device SQLite store (desktop/src-tauri/src/local).
// Selected by index.ts when running inside the desktop shell with no server.
//
// Argument keys are camelCase; Tauri converts them to the Rust commands' snake_case
// parameters (e.g. labelIds -> label_ids). A few operations have no offline meaning
// yet (account auth, device linking, attachment upload, URL unfurl, file import) —
// those reject with a clear message rather than silently failing; the board, editor,
// capture, filters, labels, checklists and reminders all work fully offline.

import { invoke } from "../desktop/bridge";
import type { Note, NoteRevision } from "../stores/notes";
import type { Label } from "../stores/labels";
import type { SavedFilter } from "../stores/savedFilters";
import type { Device } from "../stores/devices";
import type { TitleEntry } from "../stores/titles";
import type { User } from "../stores/session";
import type { PublicConfig } from "../stores/config";
import type { DeviceToken, ImportResult, Repo } from "./repo";

const NEEDS_SERVER = "That's not available offline — connect a server to use it.";

export const local: Repo = {
  config: {
    get: () => invoke<PublicConfig>("config_get"),
  },

  auth: {
    me: () => invoke<User>("auth_me"),
    login: () => Promise.reject(new Error("You're offline — there's no account to sign in to.")),
    register: () => Promise.reject(new Error("You're offline — accounts are created on a server.")),
    logout: () => Promise.resolve(),
  },

  devices: {
    list: () => Promise.resolve<Device[]>([]),
    create: () => Promise.reject<DeviceToken>(new Error(NEEDS_SERVER)),
    remove: () => Promise.resolve(),
  },

  labels: {
    list: () => invoke<Label[]>("labels_list"),
    create: (name) => invoke<Label>("labels_create", { name }),
    rename: (id, name) => invoke<Label>("labels_rename", { id, name }),
    setColor: (id, color) => invoke<Label>("labels_set_color", { id, color }),
    remove: (id) => invoke<void>("labels_remove", { id }),
    merge: (sourceId, into) => invoke<Label>("labels_merge", { sourceId, into }),
  },

  notes: {
    list: (query) => invoke<Note[]>("notes_list", { query }),
    get: (id) => invoke<Note>("notes_get", { id }),
    create: (input) => invoke<Note>("notes_create", { input }),
    update: (id, changes) => invoke<Note>("notes_update", { id, changes }),
    completeReminder: (id) => invoke<Note>("notes_complete_reminder", { id }),
    snoozeReminder: (id, minutes) => invoke<Note>("notes_snooze_reminder", { id, minutes }),
    setLabels: (id, labelIds) => invoke<Note>("notes_set_labels", { id, labelIds }),
    addItem: (id, text) => invoke<Note>("notes_add_item", { id, text }),
    updateItem: (id, itemId, changes) => invoke<Note>("notes_update_item", { id, itemId, changes }),
    deleteItem: (id, itemId) => invoke<Note>("notes_delete_item", { id, itemId }),
    uploadAttachment: () => Promise.reject<Note>(new Error(NEEDS_SERVER)),
    deleteAttachment: (id, attId) => invoke<Note>("notes_delete_attachment", { id, attId }),
    unfurl: () => Promise.reject<Note>(new Error(NEEDS_SERVER)),
    deletePreview: (id, previewId) => invoke<Note>("notes_delete_preview", { id, previewId }),
    import: () => Promise.reject<ImportResult>(new Error(NEEDS_SERVER)),
    reorder: (orderedIds) => invoke<void>("notes_reorder", { orderedIds }),
    trash: (id) => invoke<Note>("notes_trash", { id }),
    restore: (id) => invoke<Note>("notes_restore", { id }),
    deleteForever: (id) => invoke<void>("notes_delete_forever", { id }),
    revisions: (id) => invoke<NoteRevision[]>("notes_revisions", { id }),
    restoreRevision: (id, revId) => invoke<Note>("notes_restore_revision", { id, revId }),
    reminders: () => invoke<Note[]>("notes_reminders"),
    titles: () => invoke<TitleEntry[]>("notes_titles"),
  },

  savedFilters: {
    list: () => invoke<SavedFilter[]>("saved_filters_list"),
    create: (name, params) => invoke<SavedFilter>("saved_filters_create", { name, params }),
    remove: (id) => invoke<void>("saved_filters_remove", { id }),
    rename: (id, name) => invoke<SavedFilter>("saved_filters_rename", { id, name }),
  },
};