/* ============================================================================
 * db.js — libsql (embedded SQLite) database setup and query helpers
 *
 * The DB file lives at $DB_PATH (mounted volume in Docker so data persists
 * across container rebuilds). libsql is an open-source SQLite fork by Turso
 * with WAL-by-default for concurrent reads.
 *
 * Schema (three small tables):
 *   users         — one row per fingerprint; tracks last app version seen
 *   playlists     — one row per fingerprint; full playlist JSON blob
 *   video_history — one row per (fingerprint, video_id); recent 200 entries
 * ========================================================================== */

import { createClient } from '@libsql/client';
import { join } from 'node:path';

const DB_PATH = process.env.DB_PATH || join(process.cwd(), 'data', 'ytplayer.db');

export const db = createClient({
  url: 'file:' + DB_PATH,
});

// ---- Schema ----------------------------------------------------------------

export async function initDb() {
  await db.executeMultiple(`
    PRAGMA journal_mode = WAL;
    PRAGMA synchronous = NORMAL;
    PRAGMA foreign_keys = ON;

    CREATE TABLE IF NOT EXISTS users (
      fingerprint  TEXT    PRIMARY KEY,
      last_version TEXT,
      last_seen    INTEGER NOT NULL DEFAULT (unixepoch())
    );

    CREATE TABLE IF NOT EXISTS playlists (
      fingerprint TEXT    PRIMARY KEY,
      data        TEXT    NOT NULL DEFAULT '[]',
      updated_at  INTEGER NOT NULL DEFAULT (unixepoch())
    );

    CREATE TABLE IF NOT EXISTS video_history (
      fingerprint TEXT    NOT NULL,
      video_id    TEXT    NOT NULL,
      title       TEXT,
      channel     TEXT,
      thumbnail   TEXT,
      duration    REAL    DEFAULT 0,
      accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
      PRIMARY KEY (fingerprint, video_id)
    );

    CREATE INDEX IF NOT EXISTS idx_vh_fp_time
      ON video_history (fingerprint, accessed_at DESC);

    CREATE TABLE IF NOT EXISTS profiles (
      name       TEXT    PRIMARY KEY,
      data       TEXT    NOT NULL DEFAULT '{}',
      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
      updated_at INTEGER NOT NULL DEFAULT (unixepoch())
    );

    CREATE TABLE IF NOT EXISTS shared_playlists (
      code       TEXT    PRIMARY KEY,
      data       TEXT    NOT NULL DEFAULT '{}',
      created_at INTEGER NOT NULL DEFAULT (unixepoch())
    );

    -- Playlists sent from one profile to another. Holds only a pointer to the
    -- shared_playlists row, never a copy of the videos, so a delivery costs a
    -- few bytes and the recipient decides whether to keep it.
    CREATE TABLE IF NOT EXISTS playlist_inbox (
      id         TEXT    PRIMARY KEY,
      to_name    TEXT    NOT NULL,
      from_name  TEXT,
      code       TEXT    NOT NULL,
      title      TEXT    NOT NULL,
      created_at INTEGER NOT NULL DEFAULT (unixepoch())
    );

    CREATE INDEX IF NOT EXISTS idx_inbox_to
      ON playlist_inbox (to_name, created_at DESC);
  `);
}

// ---- Profiles (named cross-device sync; the name acts as the passkey) ------

// Insert a new profile. Returns false when the name is already taken.
export async function createProfile(name, dataJson) {
  try {
    await db.execute({
      sql: `INSERT INTO profiles (name, data, created_at, updated_at)
            VALUES (?, ?, unixepoch(), unixepoch())`,
      args: [name, dataJson],
    });
    return true;
  } catch (err) {
    const msg = String(err && err.message || err);
    if (msg.includes('UNIQUE') || msg.includes('PRIMARY KEY')) return false;
    throw err;
  }
}

export async function getProfile(name) {
  const r = await db.execute({
    sql: 'SELECT data, updated_at FROM profiles WHERE name = ?',
    args: [name],
  });
  const row = r.rows[0];
  if (!row) return null;
  return { data: row.data, updatedAt: Number(row.updated_at) };
}

// Update an EXISTING profile's data blob. Returns false when it doesn't exist
// (saving must never implicitly create a profile — creation is a deliberate,
// uniqueness-checked act).
export async function saveProfile(name, dataJson) {
  const r = await db.execute({
    sql: 'UPDATE profiles SET data = ?, updated_at = unixepoch() WHERE name = ?',
    args: [dataJson, name],
  });
  return (r.rowsAffected || 0) > 0;
}

// ---- Shared Playlists ------------------------------------------------------

// Insert a new shared playlist. Returns false when the code is already taken.
export async function createSharedPlaylist(code, dataJson) {
  try {
    await db.execute({
      sql: `INSERT INTO shared_playlists (code, data, created_at)
            VALUES (?, ?, unixepoch())`,
      args: [code, dataJson],
    });
    return true;
  } catch (err) {
    const msg = String(err && err.message || err);
    if (msg.includes('UNIQUE') || msg.includes('PRIMARY KEY')) return false;
    throw err;
  }
}

export async function getSharedPlaylist(code) {
  const r = await db.execute({
    sql: 'SELECT data, created_at FROM shared_playlists WHERE code = ?',
    args: [code],
  });
  const row = r.rows[0];
  if (!row) return null;
  return { data: row.data, createdAt: Number(row.created_at) };
}

// ---- Playlist inbox (profile-to-profile sends) ------------------------------

// Queue a shared playlist for a recipient profile. Caller must have verified
// the recipient exists; `code` must already be a row in shared_playlists.
export async function queueInboxPlaylist({ id, toName, fromName, code, title }) {
  await db.execute({
    sql: `INSERT INTO playlist_inbox (id, to_name, from_name, code, title, created_at)
          VALUES (?, ?, ?, ?, ?, unixepoch())`,
    args: [id, toName, fromName || null, code, title],
  });
}

// Pending deliveries for a profile, oldest first so they are offered in the
// order they were sent. Capped so a flooded inbox can't blow up the response.
export async function listInbox(toName, limit = 20) {
  const r = await db.execute({
    sql: `SELECT id, from_name, code, title, created_at
            FROM playlist_inbox
           WHERE to_name = ?
        ORDER BY created_at ASC
           LIMIT ?`,
    args: [toName, limit],
  });
  return r.rows.map((row) => ({
    id: row.id,
    from: row.from_name || null,
    code: row.code,
    title: row.title,
    createdAt: Number(row.created_at),
  }));
}

// Remove one delivery once the recipient has kept or dismissed it. Scoped by
// to_name so knowing an id alone cannot clear someone else's inbox.
export async function deleteInboxItem(toName, id) {
  const r = await db.execute({
    sql: 'DELETE FROM playlist_inbox WHERE to_name = ? AND id = ?',
    args: [toName, id],
  });
  return (r.rowsAffected || 0) > 0;
}

// How many deliveries this recipient already has waiting — used to refuse a
// send that would flood an inbox.
export async function countInbox(toName) {
  const r = await db.execute({
    sql: 'SELECT COUNT(*) AS n FROM playlist_inbox WHERE to_name = ?',
    args: [toName],
  });
  return Number(r.rows[0] ? r.rows[0].n : 0);
}

// ---- Helpers ---------------------------------------------------------------

// Upsert the users row and optionally update playlists.
export async function upsertUser({ fingerprint, appVersion, playlists }) {
  await db.execute({
    sql: `INSERT INTO users (fingerprint, last_version, last_seen)
          VALUES (?, ?, unixepoch())
          ON CONFLICT(fingerprint) DO UPDATE SET
            last_version = excluded.last_version,
            last_seen    = excluded.last_seen`,
    args: [fingerprint, appVersion || null],
  });

  if (Array.isArray(playlists)) {
    await db.execute({
      sql: `INSERT INTO playlists (fingerprint, data, updated_at)
            VALUES (?, ?, unixepoch())
            ON CONFLICT(fingerprint) DO UPDATE SET
              data       = excluded.data,
              updated_at = excluded.updated_at`,
      args: [fingerprint, JSON.stringify(playlists)],
    });
  }
}

// Record a video access (insert or bump accessed_at).
export async function recordVideoAccess(fingerprint, video) {
  await db.execute({
    sql: `INSERT INTO video_history
            (fingerprint, video_id, title, channel, thumbnail, duration, accessed_at)
          VALUES (?, ?, ?, ?, ?, ?, unixepoch())
          ON CONFLICT(fingerprint, video_id) DO UPDATE SET
            title       = excluded.title,
            channel     = excluded.channel,
            thumbnail   = excluded.thumbnail,
            duration    = excluded.duration,
            accessed_at = excluded.accessed_at`,
    args: [
      fingerprint,
      video.id,
      video.title || null,
      video.channel || null,
      video.thumbnail || null,
      video.duration || 0,
    ],
  });

  // Keep only the 200 most recent entries per user to avoid unbounded growth
  await db.execute({
    sql: `DELETE FROM video_history
          WHERE fingerprint = ?
            AND video_id NOT IN (
              SELECT video_id FROM video_history
              WHERE fingerprint = ?
              ORDER BY accessed_at DESC
              LIMIT 200
            )`,
    args: [fingerprint, fingerprint],
  });
}

// Fetch stored data for a fingerprint.
export async function getUserData(fingerprint) {
  const [userRow, plRow, histRows] = await Promise.all([
    db.execute({ sql: 'SELECT last_version FROM users WHERE fingerprint = ?', args: [fingerprint] }),
    db.execute({ sql: 'SELECT data FROM playlists WHERE fingerprint = ?', args: [fingerprint] }),
    db.execute({
      sql: `SELECT video_id AS id, title, channel, thumbnail, duration, accessed_at
            FROM video_history WHERE fingerprint = ?
            ORDER BY accessed_at DESC LIMIT 50`,
      args: [fingerprint],
    }),
  ]);

  const lastVersion = userRow.rows[0]?.last_version || null;
  const playlists   = plRow.rows[0]?.data ? JSON.parse(plRow.rows[0].data) : [];
  const history     = histRows.rows.map((r) => ({
    id: r.id, title: r.title, channel: r.channel,
    thumbnail: r.thumbnail, duration: r.duration,
  }));

  return { lastVersion, playlists, history };
}