import { sha256 } from '@noble/hashes/sha2.js';
import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
import { beforeEach, describe, expect, it } from 'vitest';

import {
  decryptSavedWalletMaterial,
  deriveWalletMaterial,
  encryptSecretParts,
  ensureSavedWalletMaterialOwner,
  getPlainWalletMaterial,
  isValidStoredWalletMaterial,
  linkingPubKeyHex,
  restoreWalletMaterialStored,
  saveWalletMaterial,
  serializeWalletMaterial,
  savedWalletMaterialOwnerId,
  walletMaterialLinkingKey,
  WalletMaterialProofMismatchError,
} from './keys';
import { walletMaterialOwnerId } from './storage/storedSecret';
import { parseJsonObject, stubLocalStorage } from './test-utils';

const MNEMONIC =
  'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
const OTHER_MNEMONIC =
  'legal winner thank year wave sausage worth useful legal winner thank yellow';
const MATERIAL_STORAGE_KEY = 'sattle_wallet_material_v2';
const PASSWORD = 'correct horse battery staple';

const materialHash = (serialized: string): string => bytesToHex(sha256(utf8ToBytes(serialized)));

const readRawMaterialRecord = (): Record<string, unknown> => {
  const raw = localStorage.getItem(MATERIAL_STORAGE_KEY);
  if (raw === null) throw new Error('expected a saved wallet-material record');
  return parseJsonObject(raw);
};

beforeEach(() => {
  stubLocalStorage();
});

describe('baseline: wallet material identity', () => {
  it('derives identity only from the linking key when the cash root changes', () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const other = deriveWalletMaterial(OTHER_MNEMONIC);
    const alteredRoot = { ...material, cashRootHex: other.cashRootHex };

    expect(walletMaterialOwnerId(alteredRoot)).toBe(walletMaterialOwnerId(material));
    expect(serializeWalletMaterial(alteredRoot)).not.toBe(serializeWalletMaterial(material));
  });
});

describe('saved wallet material commitment', () => {
  it('stores the canonical material commitment on plaintext and encrypted saves', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const expectedHash = materialHash(serializeWalletMaterial(material));

    await saveWalletMaterial(material);
    const plaintext = readRawMaterialRecord();
    await saveWalletMaterial(material, PASSWORD);
    const encrypted = readRawMaterialRecord();

    expect(plaintext.materialHash).toBe(expectedHash);
    expect(encrypted.materialHash).toBe(expectedHash);
  });

  it('rejects authenticated encrypted material when its commitment differs', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    await saveWalletMaterial(material, PASSWORD);
    localStorage.setItem(
      MATERIAL_STORAGE_KEY,
      JSON.stringify({ ...readRawMaterialRecord(), materialHash: '00'.repeat(32) }),
    );

    await expect(decryptSavedWalletMaterial(PASSWORD)).rejects.toBeInstanceOf(
      WalletMaterialProofMismatchError,
    );
  });

  it('rejects plaintext material when its commitment differs', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    await saveWalletMaterial(material);
    const before = JSON.stringify({ ...readRawMaterialRecord(), materialHash: '00'.repeat(32) });
    localStorage.setItem(MATERIAL_STORAGE_KEY, before);

    expect(getPlainWalletMaterial()).toBeNull();
    expect(localStorage.getItem(MATERIAL_STORAGE_KEY)).toBe(before);
  });

  it('refuses to stamp same-owner material with an altered cash root', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const other = deriveWalletMaterial(OTHER_MNEMONIC);
    await saveWalletMaterial(material, PASSWORD);

    expect(() =>
      ensureSavedWalletMaterialOwner({ ...material, cashRootHex: other.cashRootHex }),
    ).toThrow(WalletMaterialProofMismatchError);
  });

  it('requires exactly one lowercase 64-hex commitment at the storage boundary', () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const serialized = serializeWalletMaterial(material);
    const record = {
      enc: false,
      value: serialized,
      materialHash: materialHash(serialized),
      ownerId: walletMaterialOwnerId(material),
      version: 2,
    };

    expect(isValidStoredWalletMaterial(record)).toBe(true);
    expect(
      isValidStoredWalletMaterial({ ...record, materialHash: record.materialHash.toUpperCase() }),
    ).toBe(false);
    expect(
      isValidStoredWalletMaterial({
        enc: record.enc,
        value: record.value,
        ownerId: record.ownerId,
        version: record.version,
      }),
    ).toBe(false);
  });

  it('rejects malformed authenticated material after its correct commitment matches', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const malformed = JSON.stringify({ ...material, cashRootHex: '00'.repeat(64) });
    const parts = await encryptSecretParts(malformed, PASSWORD);
    localStorage.setItem(
      MATERIAL_STORAGE_KEY,
      JSON.stringify({
        enc: true,
        ...parts,
        materialHash: materialHash(malformed),
        ownerId: linkingPubKeyHex(walletMaterialLinkingKey(material)),
        version: 2,
      }),
    );

    await expect(decryptSavedWalletMaterial(PASSWORD)).rejects.toThrow('valid v2 wallet material');
  });

  it('preserves a verified restored commitment while discarding its owner claim', () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const serialized = serializeWalletMaterial(material);

    restoreWalletMaterialStored({
      enc: false,
      value: serialized,
      materialHash: materialHash(serialized),
      ownerId: linkingPubKeyHex(new Uint8Array(32).fill(9)),
      version: 2,
    });

    expect(readRawMaterialRecord()).toEqual({
      enc: false,
      value: serialized,
      materialHash: materialHash(serialized),
    });
    expect(getPlainWalletMaterial()).toEqual(material);
  });

  it('proves an encrypted restored commitment before owner stamping', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const serialized = serializeWalletMaterial(material);
    const parts = await encryptSecretParts(serialized, PASSWORD);
    restoreWalletMaterialStored({
      enc: true,
      ...parts,
      materialHash: materialHash(serialized),
      ownerId: linkingPubKeyHex(new Uint8Array(32).fill(9)),
      version: 2,
    });

    expect(savedWalletMaterialOwnerId()).toBeNull();
    const proven = await decryptSavedWalletMaterial(PASSWORD);
    ensureSavedWalletMaterialOwner(proven);

    expect(savedWalletMaterialOwnerId()).toBe(walletMaterialOwnerId(material));
  });

  it('rejects an unproven restored hash that contradicts encrypted material', async () => {
    const material = deriveWalletMaterial(MNEMONIC);
    const serialized = serializeWalletMaterial(material);
    const parts = await encryptSecretParts(serialized, PASSWORD);
    restoreWalletMaterialStored({
      enc: true,
      ...parts,
      materialHash: '00'.repeat(32),
      ownerId: walletMaterialOwnerId(material),
      version: 2,
    });

    await expect(decryptSavedWalletMaterial(PASSWORD)).rejects.toBeInstanceOf(
      WalletMaterialProofMismatchError,
    );
    expect(savedWalletMaterialOwnerId()).toBeNull();
  });
});