// IndexedDB model library.
//
// v2 layout (this file):
//   models      store, keyPath "id"        -> one record per model, id = uuid
//   modelChunks store, keyPath [modelId, index] -> { modelId, index, data: ArrayBuffer }
//
// Why a uuid primary key: one browser should hold many models, the same file may
// legitimately be registered twice under different names, and records must stay
// addressable after a rename. Nothing user-visible keys off the id.
//
// Why chunks instead of one blob:
//   1. pause/resume - a Range request continues from meta.received without
//      rewriting hundreds of MB already stored;
//   2. loading - chunks stream straight into the Emscripten FS, so no second
//      full-size buffer is assembled in JS memory;
//   3. hashing - the same generator feeds the SHA-256, 4 MiB at a time.
//
// A record with source "file" normally has *no* chunks: the bytes stay on the
// user's disk and are read in slices at load time. `copied` marks the opt-in
// case where the user asked for a copy to live in the browser instead.

export const DB_NAME = "llmjs-models";
export const DB_VERSION = 2;
export const CHUNK_SIZE = 4 * 1024 * 1024;

const MODEL_STORE = "models";
const CHUNK_STORE = "modelChunks";

let dbPromise = null;

export function newModelId() {
    if (globalThis.crypto && typeof crypto.randomUUID === "function") return crypto.randomUUID();
    const bytes = crypto.getRandomValues(new Uint8Array(16));
    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
}

export function nameFromUrl(url) {
    try {
        const base = new URL(url, "http://localhost/").pathname.split("/").filter(Boolean).pop() || "model";
        return base.replace(/\.gguf$/i, "");
    } catch (_) {
        return "model";
    }
}

// --- v1 -> v2 ---------------------------------------------------------------
// v1 keyed records by url (out-of-line keys) and chunks by "url|00000000".
// Migration runs inside the versionchange transaction: copy the old stores into
// the new ones, then drop the old ones.
function migrateV1(db, tx, models, chunks) {
    const v1meta = tx.objectStore("meta");
    const v1chunks = tx.objectStore("chunks");
    const ids = new Map();

    const metaCursor = v1meta.openCursor();
    metaCursor.onsuccess = () => {
        const cursor = metaCursor.result;
        if (cursor) {
            const old = cursor.value || {};
            const id = newModelId();
            if (old.url) ids.set(old.url, id);
            models.put({
                id,
                name: nameFromUrl(old.url || ""),
                source: "url",
                url: old.url || null,
                fileName: null,
                total: old.total || 0,
                received: old.received || 0,
                complete: !!old.complete,
                copied: true,          // v1 only ever stored downloaded bytes
                sha256: null,
                expectedSha256: null,
                created: old.updated || Date.now(),
                updated: old.updated || Date.now(),
            });
            cursor.continue();
            return;
        }

        const chunkCursor = v1chunks.openCursor();
        chunkCursor.onsuccess = () => {
            const c = chunkCursor.result;
            if (c) {
                const key = String(c.key);
                const bar = key.lastIndexOf("|");
                const modelId = ids.get(key.slice(0, bar));
                const index = Number(key.slice(bar + 1));
                if (modelId !== undefined && Number.isFinite(index)) {
                    chunks.put({ modelId, index, data: c.value });
                }
                c.continue();
                return;
            }
            db.deleteObjectStore("meta");
            db.deleteObjectStore("chunks");
        };
    };
}

export function openDB() {
    if (!dbPromise) {
        dbPromise = new Promise((resolve, reject) => {
            if (typeof indexedDB === "undefined") {
                reject(new Error("IndexedDB is not available in this context"));
                return;
            }
            const req = indexedDB.open(DB_NAME, DB_VERSION);
            req.onupgradeneeded = (event) => {
                const db = req.result;
                const tx = req.transaction;
                const models = db.objectStoreNames.contains(MODEL_STORE)
                    ? tx.objectStore(MODEL_STORE)
                    : db.createObjectStore(MODEL_STORE, { keyPath: "id" });
                const chunks = db.objectStoreNames.contains(CHUNK_STORE)
                    ? tx.objectStore(CHUNK_STORE)
                    : db.createObjectStore(CHUNK_STORE, { keyPath: ["modelId", "index"] });
                if (event.oldVersion === 1) migrateV1(db, tx, models, chunks);
            };
            req.onsuccess = () => resolve(req.result);
            req.onerror = () => reject(req.error);
        });
    }
    return dbPromise;
}

const result = (req) => new Promise((res, rej) => {
    req.onsuccess = () => res(req.result);
    req.onerror = () => rej(req.error);
});

const completed = (tx) => new Promise((res, rej) => {
    tx.oncomplete = () => res();
    tx.onerror = () => rej(tx.error);
    tx.onabort = () => rej(tx.error);
});

const chunkRange = (modelId, from = 0) =>
    IDBKeyRange.bound([modelId, from], [modelId, Number.MAX_SAFE_INTEGER]);

// --- models ----------------------------------------------------------------

export async function getModel(id) {
    const db = await openDB();
    return result(db.transaction(MODEL_STORE, "readonly").objectStore(MODEL_STORE).get(id));
}

export async function putModel(model) {
    const db = await openDB();
    const record = { ...model, updated: Date.now() };
    const tx = db.transaction(MODEL_STORE, "readwrite");
    tx.objectStore(MODEL_STORE).put(record);
    await completed(tx);
    return record;
}

export async function updateModel(id, patch) {
    const model = await getModel(id);
    if (!model) throw new Error(`unknown model ${id}`);
    return putModel({ ...model, ...patch, id });
}

// most recently touched first
export async function listModels() {
    const db = await openDB();
    const all = await result(db.transaction(MODEL_STORE, "readonly").objectStore(MODEL_STORE).getAll());
    return all.sort((a, b) => (b.updated || 0) - (a.updated || 0));
}

export async function findModelByUrl(url) {
    const all = await listModels();
    return all.find((m) => m.url === url);
}

// --- chunks ----------------------------------------------------------------

export async function putChunk(modelId, index, buffer) {
    const db = await openDB();
    const tx = db.transaction(CHUNK_STORE, "readwrite");
    tx.objectStore(CHUNK_STORE).put({ modelId, index, data: buffer });
    await completed(tx);
}

export async function getChunk(modelId, index) {
    const db = await openDB();
    const row = await result(db.transaction(CHUNK_STORE, "readonly").objectStore(CHUNK_STORE).get([modelId, index]));
    return row ? row.data : undefined;
}

export async function chunkCount(modelId) {
    const db = await openDB();
    return result(db.transaction(CHUNK_STORE, "readonly").objectStore(CHUNK_STORE).count(chunkRange(modelId)));
}

// ascending chunk indexes currently stored for this model
export async function chunkIndexes(modelId) {
    const db = await openDB();
    const keys = await result(db.transaction(CHUNK_STORE, "readonly").objectStore(CHUNK_STORE).getAllKeys(chunkRange(modelId)));
    return keys.map((k) => (Array.isArray(k) ? k[1] : Number(k))).sort((a, b) => a - b);
}

// Yields the stored bytes in order. Reads in small batches so the transaction
// is never held open across awaits (which would let it auto-commit) and so a
// 4 GB model never lands in memory as one buffer.
export async function* iterateChunks(modelId, batch = 4) {
    let start = 0;
    for (;;) {
        const db = await openDB();
        const rows = await result(
            db.transaction(CHUNK_STORE, "readonly").objectStore(CHUNK_STORE)
                .getAll(chunkRange(modelId, start), batch),
        );
        if (!rows.length) return;
        const from = start;
        for (let i = 0; i < rows.length; i++) {
            yield { index: from + i, data: rows[i].data };
        }
        if (rows.length < batch) return;
        start += rows.length;
    }
}

export async function clearChunks(modelId) {
    const db = await openDB();
    const tx = db.transaction(CHUNK_STORE, "readwrite");
    const store = tx.objectStore(CHUNK_STORE);
    let deleted = 0;
    const req = store.openCursor(chunkRange(modelId));
    req.onsuccess = () => {
        const cursor = req.result;
        if (!cursor) return;
        cursor.delete();
        deleted++;
        cursor.continue();
    };
    await completed(tx);
    return deleted;
}

// --- lifecycle -------------------------------------------------------------

// removes the record and everything stored for it (the "delete" button)
export async function deleteModel(modelId) {
    const chunks = await clearChunks(modelId);
    const db = await openDB();
    const tx = db.transaction(MODEL_STORE, "readwrite");
    tx.objectStore(MODEL_STORE).delete(modelId);
    await completed(tx);
    return chunks;
}

export async function clearAll() {
    const models = await listModels();
    for (const m of models) await deleteModel(m.id);
    return models.length;
}

export async function storageEstimate() {
    if (navigator.storage && navigator.storage.estimate) {
        try { return await navigator.storage.estimate(); } catch (_) { /* ignore */ }
    }
    return null;
}