import { assert, assertEquals, assertExists } from 'https://deno.land/std@0.198.0/assert/mod.ts';

import { isoBase64URL, isoUint8Array } from '../helpers/iso/index.ts';

import { generateAuthenticationOptions } from './generateAuthenticationOptions.ts';

const challengeString = 'dG90YWxseXJhbmRvbXZhbHVl';
const challengeBuffer = isoBase64URL.toBuffer(challengeString);

Deno.test('should generate credential request options suitable for sending via JSON', async () => {
  const options = await generateAuthenticationOptions({
    allowCredentials: [
      {
        id: isoUint8Array.fromASCIIString('1234'),
        type: 'public-key',
        transports: ['usb', 'nfc'],
      },
      {
        id: isoUint8Array.fromASCIIString('5678'),
        type: 'public-key',
        transports: ['internal'],
      },
    ],
    timeout: 1,
    challenge: challengeBuffer,
  });

  assertEquals(options, {
    // base64url-encoded
    challenge: challengeString,
    allowCredentials: [
      {
        id: 'MTIzNA',
        type: 'public-key',
        transports: ['usb', 'nfc'],
      },
      {
        id: 'NTY3OA',
        type: 'public-key',
        transports: ['internal'],
      },
    ],
    timeout: 1,
    userVerification: 'preferred',
    extensions: undefined,
    rpId: undefined,
  });
});

Deno.test('defaults to 60 seconds if no timeout is specified', async () => {
  const options = await generateAuthenticationOptions({
    challenge: challengeBuffer,
    allowCredentials: [
      { id: isoUint8Array.fromASCIIString('1234'), type: 'public-key' },
      { id: isoUint8Array.fromASCIIString('5678'), type: 'public-key' },
    ],
  });

  assertEquals(options.timeout, 60000);
});

Deno.test('should set userVerification to "preferred" if not specified', async () => {
  const options = await generateAuthenticationOptions({
    challenge: challengeBuffer,
    allowCredentials: [
      { id: isoUint8Array.fromASCIIString('1234'), type: 'public-key' },
      { id: isoUint8Array.fromASCIIString('5678'), type: 'public-key' },
    ],
  });

  assertEquals(options.userVerification, 'preferred');
});

Deno.test('should not set allowCredentials if not specified', async () => {
  const options = await generateAuthenticationOptions({ rpID: 'test' });

  assertEquals(options.allowCredentials, undefined);
});

Deno.test('should generate without params', async () => {
  const options = await generateAuthenticationOptions();
  const { challenge, ...otherFields } = options;
  assertEquals(otherFields, {
    allowCredentials: undefined,
    extensions: undefined,
    rpId: undefined,
    timeout: 60000,
    userVerification: 'preferred',
  });
  assertEquals(typeof challenge, 'string');
});

Deno.test('should set userVerification if specified', async () => {
  const options = await generateAuthenticationOptions({
    challenge: challengeBuffer,
    allowCredentials: [
      { id: isoUint8Array.fromASCIIString('1234'), type: 'public-key' },
      { id: isoUint8Array.fromASCIIString('5678'), type: 'public-key' },
    ],
    userVerification: 'required',
  });

  assertEquals(options.userVerification, 'required');
});

Deno.test('should set extensions if specified', async () => {
  const options = await generateAuthenticationOptions({
    challenge: challengeBuffer,
    allowCredentials: [
      { id: isoUint8Array.fromASCIIString('1234'), type: 'public-key' },
      { id: isoUint8Array.fromASCIIString('5678'), type: 'public-key' },
    ],
    extensions: { appid: 'simplewebauthn' },
  });

  assertEquals(options.extensions, { appid: 'simplewebauthn' });
});

Deno.test('should generate a challenge if one is not provided', async () => {
  const opts = {
    allowCredentials: [
      { id: isoUint8Array.fromASCIIString('1234'), type: 'public-key' },
      { id: isoUint8Array.fromASCIIString('5678'), type: 'public-key' },
    ],
  };

  // @ts-ignore 2345
  const options = await generateAuthenticationOptions(opts);

  // Assert basic properties of the challenge
  assert(options.challenge.length >= 16);
  assert(isoBase64URL.isBase64url(options.challenge));
});

Deno.test('should set rpId if specified', async () => {
  const rpID = 'simplewebauthn.dev';

  const opts = await generateAuthenticationOptions({
    allowCredentials: [],
    rpID,
  });

  assertExists(opts.rpId);
  assertEquals(opts.rpId, rpID);
});