/*
 * Copyright (C) Sapphirecode - All Rights Reserved
 * This file is part of Auth-Server-Helper which is released under MIT.
 * See file 'LICENSE' for full license details.
 * Created by Timo Hocker <timo@scode.ovh>, August 2022
 */

/* eslint-disable dot-notation */

import { blacklist } from '../../lib';
import ks from '../../lib/KeyStore';
import { Redis } from '../../lib/Redis';
import { generate_token_id } from '../../lib/token_id';
import { clock_finalize, clock_setup } from '../Helper';

const frame = 3600;
const redis_url = process.env.TEST_REDIS_URL || 'redis://localhost';
const redis = new Redis;
redis.connect (redis_url);

// eslint-disable-next-line max-lines-per-function
describe ('redis', () => {
  const token1 = generate_token_id (new Date (Date.now () + 3600000));
  const token2 = generate_token_id (new Date (Date.now () + 3600000));
  const token3 = generate_token_id (new Date (Date.now () + 3600000));

  beforeAll (async () => {
    ks.reset_instance ();
    ks.sync_redis (redis_url);
    await blacklist.clear ();
    blacklist.sync_redis (redis_url);
    clock_setup ();
  });

  let iat1 = 0;
  let iat2 = 0;
  let k1 = '';
  let k2 = '';
  let i1 = '';
  let i2 = '';

  afterAll (() => clock_finalize ());

  it ('should generate two keys', async () => {
    iat1 = (new Date)
      .getTime () / 1000;
    await ks.get_sign_key (iat1, frame);
    k1 = await ks.get_key (iat1);

    jasmine.clock ()
      .tick (frame * 1000);

    iat2 = (new Date)
      .getTime () / 1000;
    await ks.get_sign_key (iat2, frame);
    k2 = await ks.get_key (iat2);
    // eslint-disable-next-line dot-notation
    i1 = ks['get_index'] (iat1);
    // eslint-disable-next-line dot-notation
    i2 = ks['get_index'] (iat2);
  });

  it ('should have two keys in redis', async () => {
    expect (JSON.parse (await redis['_redis']
      ?.get (`keystore_${i1}`) as string).key)
      .toEqual (k1);
    expect (JSON.parse (await redis['_redis']
      ?.get (`keystore_${i2}`) as string).key)
      .toEqual (k2);
  });

  it ('should read two keys with a new instance', async () => {
    const old_instance = ks.instance_id;
    ks.reset_instance ();
    expectAsync (ks.get_key (iat1, old_instance))
      .toBeRejectedWithError ('key could not be found');
    expectAsync (ks.get_key (iat1, old_instance))
      .toBeRejectedWithError ('key could not be found');

    ks.sync_redis (redis_url);
    expect (await ks.get_key (iat1, old_instance))
      .toEqual (k1);
    expect (await ks.get_key (iat2, old_instance))
      .toEqual (k2);
  });

  it ('should add two keys to the blacklist', async () => {
    await blacklist.add_signature (token1);
    await blacklist.add_signature (token2);
  });

  it ('should have two keys in redis blacklist', async () => {
    expect ((await redis['_redis']?.exists (`blacklist_${token1}`)) === 1)
      .toBeTrue ();
    expect ((await redis['_redis']?.exists (`blacklist_${token2}`)) === 1)
      .toBeTrue ();
    expect ((await redis['_redis']?.exists (`blacklist_${token3}`)) === 1)
      .toBeFalse ();
  });

  it ('should read keys from redis', async () => {
    blacklist['_signatures'].splice (0, blacklist['_signatures'].length);
    expect (await blacklist.is_valid (token1))
      .toBeFalse ();
    expect (await blacklist.is_valid (token2))
      .toBeFalse ();
    expect (await blacklist.is_valid (token3))
      .toBeTrue ();
  });
});