import {
    KeySet,
    calculateThumbprint,
    KeyObjects,
    RSAKey,
    ECKey,
    OKP,
    ERRORS
} from './../src/core/jwk-utils';
import { KEY_FORMATS, KTYS, ALGORITHMS } from './../src/core/globals';
import { TD_KEY_PAIRS } from './data/key-pairs.testdata';
import nock from 'nock';

describe('JWK functions', function () {
    test('RSAKey functions', async () => {
        let kid: string = 'key_1';
        let publicJWK: KeyObjects.RSAPublicKeyObject = TD_KEY_PAIRS.rsa_1.publicJWK;
        let publicMinimalJWK = TD_KEY_PAIRS.rsa_1.publicMinimalJWK;
        let publicJWKThumbprint = TD_KEY_PAIRS.rsa_1.publicJWKThumbprint;
        let privateJWK: KeyObjects.RSAPrivateKeyObject = TD_KEY_PAIRS.rsa_1.privateJWK;
        let privateMinimalJWK = TD_KEY_PAIRS.rsa_1.privateMinimalJWK;
        let privatePem = TD_KEY_PAIRS.rsa_1.privatePem;
        let publicPem = TD_KEY_PAIRS.rsa_1.publicPem;

        let key = RSAKey.fromKey({
            key: publicPem,
            kid: kid,
            use: 'enc',
            alg: ALGORITHMS[ALGORITHMS.RS256],
            kty: KTYS[KTYS.RSA],
            format: KEY_FORMATS.PKCS8_PEM,
            isPrivate: false
        });
        expect(key.toJWK()).toMatchObject(publicJWK);
        let pem = key.exportKey(KEY_FORMATS.PKCS8_PEM);
        expect(pem.split('\n').join('')).toEqual(publicPem.split('\n').join(''));
        let minimalJWK = key.getMinimalJWK(false);
        expect(minimalJWK).toMatchObject(publicMinimalJWK);
        let thumbprint = calculateThumbprint(minimalJWK);
        expect(thumbprint).toEqual(publicJWKThumbprint);

        key = RSAKey.fromKey({
            key: privatePem,
            kid: kid,
            use: 'enc',
            alg: ALGORITHMS[ALGORITHMS.RS256],
            kty: KTYS[KTYS.RSA],
            format: KEY_FORMATS.PKCS1_PEM,
            isPrivate: true
        });
        expect(key.toJWK(true)).toMatchObject(privateJWK);
        pem = key.exportKey(KEY_FORMATS.PKCS1_PEM);
        expect(pem.split('\n').join('')).toEqual(privatePem.split('\n').join(''));
        minimalJWK = key.getMinimalJWK(true);
        expect(minimalJWK).toMatchObject(privateMinimalJWK);
    });
    test('ECKey functions', async () => {
        let kid: string = 'key_1';
        let publicJWK: KeyObjects.ECPublicKeyObject = TD_KEY_PAIRS.ec_1.publicJWK;
        let publicMinimalJWK = TD_KEY_PAIRS.ec_1.publicMinimalJWK;
        let publicJWKThumbprint = TD_KEY_PAIRS.ec_1.publicJWKThumbprint;
        let privateJWK: KeyObjects.ECPrivateKeyObject = TD_KEY_PAIRS.ec_1.privateJWK;
        let privateMinimalJWK = TD_KEY_PAIRS.ec_1.privateMinimalJWK;

        let key = ECKey.fromKey(privateJWK);
        let privateHex = key.exportKey(KEY_FORMATS.HEX);
        let retrievedJWK = ECKey.fromKey({
            key: privateHex,
            kid: kid,
            use: 'enc',
            alg: ALGORITHMS[ALGORITHMS.ES256K],
            kty: KTYS[KTYS.EC],
            format: KEY_FORMATS.HEX,
            isPrivate: true
        }).toJWK(true);
        expect(retrievedJWK).toMatchObject(privateJWK);

        let minimalJWK = key.getMinimalJWK(true);
        expect(minimalJWK).toMatchObject(privateMinimalJWK);

        key = ECKey.fromKey(publicJWK);
        let publicHex = key.exportKey(KEY_FORMATS.HEX);
        retrievedJWK = ECKey.fromKey({
            key: publicHex,
            kid: kid,
            use: 'enc',
            alg: ALGORITHMS[ALGORITHMS.ES256K],
            kty: KTYS[KTYS.EC],
            format: KEY_FORMATS.HEX,
            isPrivate: false
        }).toJWK();
        expect(retrievedJWK).toMatchObject(publicJWK);

        minimalJWK = key.getMinimalJWK(false);
        expect(minimalJWK).toMatchObject(publicMinimalJWK);
        let thumbprint = calculateThumbprint(minimalJWK);
        expect(thumbprint).toEqual(publicJWKThumbprint);
    });
    test('OKP functions', async () => {
        let kid: string = 'key_1';
        let publicJWK: KeyObjects.OKPPublicKeyObject = TD_KEY_PAIRS.okp_1.publicJWK;
        let publicMinimalJWK = TD_KEY_PAIRS.okp_1.publicMinimalJWK;
        let publicJWKThumbprint = TD_KEY_PAIRS.okp_1.publicJWKThumbprint;
        let privateJWK: KeyObjects.OKPPrivateKeyObject = TD_KEY_PAIRS.okp_1.privateJWK;
        let privateMinimalJWK = TD_KEY_PAIRS.okp_1.privateMinimalJWK;

        let key = OKP.fromKey(privateJWK);
        let privateBase58 = key.exportKey(KEY_FORMATS.BASE58);
        let retrievedJWK = OKP.fromKey({
            key: privateBase58,
            kid: kid,
            use: 'enc',
            alg: ALGORITHMS[ALGORITHMS.EdDSA],
            kty: KTYS[KTYS.OKP],
            format: KEY_FORMATS.BASE58,
            isPrivate: true
        }).toJWK(true);
        expect(retrievedJWK).toMatchObject(privateJWK);

        let minimalJWK = key.getMinimalJWK(true);
        expect(minimalJWK).toMatchObject(privateMinimalJWK);

        key = OKP.fromKey(publicJWK);
        let publicBase58 = key.exportKey(KEY_FORMATS.BASE58);
        retrievedJWK = OKP.fromKey({
            key: publicBase58,
            kid: kid,
            use: 'enc',
            alg: ALGORITHMS[ALGORITHMS.EdDSA],
            kty: KTYS[KTYS.OKP],
            format: KEY_FORMATS.BASE58,
            isPrivate: false
        }).toJWK();
        expect(retrievedJWK).toMatchObject(publicJWK);

        minimalJWK = key.getMinimalJWK(false);
        expect(minimalJWK).toMatchObject(publicMinimalJWK);
        let thumbprint = calculateThumbprint(minimalJWK);
        expect(thumbprint).toEqual(publicJWKThumbprint);
    });
});
describe('JWKS', function () {
    test('KeySet functions', async () => {
        let jwks = new KeySet();
        expect(jwks.size()).toEqual(0);

        const rsa1 = TD_KEY_PAIRS.rsa_2.publicJWK;
        const rsa2 = TD_KEY_PAIRS.rsa_3.publicJWK;
        const ec1 = TD_KEY_PAIRS.ec_2.publicJWK;
        const ec2 = TD_KEY_PAIRS.ec_3.publicJWK;
        const okp1 = TD_KEY_PAIRS.okp_2.publicJWK;
        const okp2 = TD_KEY_PAIRS.okp_3.publicJWK;

        const set = {
            keys: [rsa1, ec1, ec2, okp1]
        };

        jwks.setKeys(set.keys);
        expect(jwks.size()).toEqual(set.keys.length);

        jwks.addKey(rsa2);
        expect(jwks.size()).toEqual(5);

        jwks.addKey(okp2);
        expect(jwks.size()).toEqual(6);

        jwks.removeKey('rsa1');
        expect(jwks.size()).toEqual(5);

        let retrieved = jwks.getKey('ec1');
        expect(retrieved[0].toJWK(true)).toEqual(ec1);

        nock('http://localhost')
            .get('/keys')
            .reply(200, set)
            .get('/invalidUri')
            .reply(404, 'Not found');

        jwks = new KeySet();
        await jwks.setURI('http://localhost/keys');
        expect(jwks.size()).toEqual(set.keys.length);

        jwks = new KeySet();
        let jwksResolvePromise = jwks.setURI('http://localhost/invalidUri');
        await expect(jwksResolvePromise).rejects.toEqual(new Error(ERRORS.URI_ERROR));
    });
});