import assert from 'node:assert/strict';
import { test } from 'node:test';
import { isDismissed, recoveryPrompt, requestPersistence, setDismissed } from '../src/lib/protection-model.ts';

const state = (recovery: 'Unknown' | 'Disabled' | 'Incomplete' | 'Enabled') => ({
  device_id: 'D',
  device_verified: true,
  recovery,
  key_backup: 'Disabled'
});

const browser = { device: false, standalone: false };
const device = { device: true, standalone: false };
const installed = { device: true, standalone: true };

test('recovery prompt follows recovery state', () => {
  assert.equal(recoveryPrompt(null, device, false), null);
  assert.equal(recoveryPrompt(state('Unknown'), device, false), null);
  assert.equal(recoveryPrompt(state('Enabled'), device, false), null);
  assert.equal(recoveryPrompt(state('Incomplete'), device, true), 'recover');
  assert.equal(recoveryPrompt(state('Disabled'), device, false), 'setup');
});

test('only the device build in a browser tab may dismiss the setup prompt', () => {
  assert.equal(recoveryPrompt(state('Disabled'), device, true), null);
  assert.equal(recoveryPrompt(state('Disabled'), installed, true), 'setup');
  assert.equal(recoveryPrompt(state('Disabled'), browser, true), 'setup');
});

test('dismissals are per account', () => {
  const data = new Map<string, string>();
  const store = { getItem: (k: string) => data.get(k) ?? null, setItem: (k: string, v: string) => void data.set(k, v) };
  setDismissed(store, 'storage', '@a:x');
  assert.equal(isDismissed(store, 'storage', '@a:x'), true);
  assert.equal(isDismissed(store, 'storage', '@b:x'), false);
  assert.equal(isDismissed(store, 'recovery', '@a:x'), false);
});

test('persistence is requested only when not already granted', async () => {
  let asked = 0;
  const denied = {
    persisted: async () => false,
    persist: async () => (asked++, false),
    estimate: async () => ({ usage: 5, quota: 100 })
  };
  assert.deepEqual(await requestPersistence(denied), { persisted: false, usage: 5, quota: 100 });
  assert.equal(asked, 1);
  const granted = { persisted: async () => true, persist: async () => (asked++, true) };
  assert.deepEqual(await requestPersistence(granted), { persisted: true, usage: null, quota: null });
  assert.equal(asked, 1);
  assert.equal(await requestPersistence(undefined), null);
});