/*
 * Copyright 2019 gRPC authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

import * as assert from 'assert';
import * as http2 from 'http2';
import { range } from 'lodash';
import { Metadata, MetadataObject, MetadataValue } from '../src/metadata';

class TestMetadata extends Metadata {
  getInternalRepresentation() {
    return this.internalRepr;
  }

  static fromHttp2Headers(headers: http2.IncomingHttpHeaders): TestMetadata {
    const result = Metadata.fromHttp2Headers(headers) as TestMetadata;
    result.getInternalRepresentation =
      TestMetadata.prototype.getInternalRepresentation;
    return result;
  }
}

const validKeyChars = '0123456789abcdefghijklmnopqrstuvwxyz_-.';
const validNonBinValueChars = range(0x20, 0x7f)
  .map(code => String.fromCharCode(code))
  .join('');

describe('Metadata', () => {
  let metadata: TestMetadata;

  beforeEach(() => {
    metadata = new TestMetadata();
  });

  describe('set', () => {
    it('Only accepts string values for non "-bin" keys', () => {
      assert.throws(() => {
        metadata.set('key', Buffer.from('value'));
      });
      assert.doesNotThrow(() => {
        metadata.set('key', 'value');
      });
    });

    it('Only accepts Buffer values for "-bin" keys', () => {
      assert.throws(() => {
        metadata.set('key-bin', 'value');
      });
      assert.doesNotThrow(() => {
        metadata.set('key-bin', Buffer.from('value'));
      });
    });

    it('Rejects invalid keys', () => {
      assert.doesNotThrow(() => {
        metadata.set(validKeyChars, 'value');
      });
      assert.throws(() => {
        metadata.set('key$', 'value');
      }, /Error: Metadata key "key\$" contains illegal characters/);
      assert.throws(() => {
        metadata.set('', 'value');
      });
    });

    it('Rejects values with non-ASCII characters', () => {
      assert.doesNotThrow(() => {
        metadata.set('key', validNonBinValueChars);
      });
      assert.throws(() => {
        metadata.set('key', 'résumé');
      });
    });

    it('Saves values that can be retrieved', () => {
      metadata.set('key', 'value');
      assert.deepStrictEqual(metadata.get('key'), ['value']);
    });

    it('Overwrites previous values', () => {
      metadata.set('key', 'value1');
      metadata.set('key', 'value2');
      assert.deepStrictEqual(metadata.get('key'), ['value2']);
    });

    it('Normalizes keys', () => {
      metadata.set('Key', 'value1');
      assert.deepStrictEqual(metadata.get('key'), ['value1']);
      metadata.set('KEY', 'value2');
      assert.deepStrictEqual(metadata.get('key'), ['value2']);
    });
  });

  describe('add', () => {
    it('Only accepts string values for non "-bin" keys', () => {
      assert.throws(() => {
        metadata.add('key', Buffer.from('value'));
      });
      assert.doesNotThrow(() => {
        metadata.add('key', 'value');
      });
    });

    it('Only accepts Buffer values for "-bin" keys', () => {
      assert.throws(() => {
        metadata.add('key-bin', 'value');
      });
      assert.doesNotThrow(() => {
        metadata.add('key-bin', Buffer.from('value'));
      });
    });

    it('Rejects invalid keys', () => {
      assert.throws(() => {
        metadata.add('key$', 'value');
      });
      assert.throws(() => {
        metadata.add('', 'value');
      });
    });

    it('Saves values that can be retrieved', () => {
      metadata.add('key', 'value');
      assert.deepStrictEqual(metadata.get('key'), ['value']);
    });

    it('Combines with previous values', () => {
      metadata.add('key', 'value1');
      metadata.add('key', 'value2');
      assert.deepStrictEqual(metadata.get('key'), ['value1', 'value2']);
    });

    it('Normalizes keys', () => {
      metadata.add('Key', 'value1');
      assert.deepStrictEqual(metadata.get('key'), ['value1']);
      metadata.add('KEY', 'value2');
      assert.deepStrictEqual(metadata.get('key'), ['value1', 'value2']);
    });
  });

  describe('remove', () => {
    it('clears values from a key', () => {
      metadata.add('key', 'value');
      metadata.remove('key');
      assert.deepStrictEqual(metadata.get('key'), []);
    });

    it('Normalizes keys', () => {
      metadata.add('key', 'value');
      metadata.remove('KEY');
      assert.deepStrictEqual(metadata.get('key'), []);
    });
  });

  describe('get', () => {
    beforeEach(() => {
      metadata.add('key', 'value1');
      metadata.add('key', 'value2');
      metadata.add('key-bin', Buffer.from('value'));
    });

    it('gets all values associated with a key', () => {
      assert.deepStrictEqual(metadata.get('key'), ['value1', 'value2']);
    });

    it('Normalizes keys', () => {
      assert.deepStrictEqual(metadata.get('KEY'), ['value1', 'value2']);
    });

    it('returns an empty list for non-existent keys', () => {
      assert.deepStrictEqual(metadata.get('non-existent-key'), []);
    });

    it('returns Buffers for "-bin" keys', () => {
      assert.ok(metadata.get('key-bin')[0] instanceof Buffer);
    });
  });

  describe('getMap', () => {
    it('gets a map of keys to values', () => {
      metadata.add('key1', 'value1');
      metadata.add('Key2', 'value2');
      metadata.add('KEY3', 'value3a');
      metadata.add('KEY3', 'value3b');
      assert.deepStrictEqual(metadata.getMap(), {
        key1: 'value1',
        key2: 'value2',
        key3: 'value3a',
      });
    });
  });

  describe('clone', () => {
    it('retains values from the original', () => {
      metadata.add('key', 'value');
      const copy = metadata.clone();
      assert.deepStrictEqual(copy.get('key'), ['value']);
    });

    it('Does not see newly added values', () => {
      metadata.add('key', 'value1');
      const copy = metadata.clone();
      metadata.add('key', 'value2');
      assert.deepStrictEqual(copy.get('key'), ['value1']);
    });

    it('Does not add new values to the original', () => {
      metadata.add('key', 'value1');
      const copy = metadata.clone();
      copy.add('key', 'value2');
      assert.deepStrictEqual(metadata.get('key'), ['value1']);
    });

    it('Copy cannot modify binary values in the original', () => {
      const buf = Buffer.from('value-bin');
      metadata.add('key-bin', buf);
      const copy = metadata.clone();
      const copyBuf = copy.get('key-bin')[0] as Buffer;
      assert.deepStrictEqual(copyBuf, buf);
      copyBuf.fill(0);
      assert.notDeepStrictEqual(copyBuf, buf);
    });
  });

  describe('merge', () => {
    it('appends values from a given metadata object', () => {
      metadata.add('key1', 'value1');
      metadata.add('Key2', 'value2a');
      metadata.add('KEY3', 'value3a');
      metadata.add('key4', 'value4');
      const metadata2 = new TestMetadata();
      metadata2.add('KEY1', 'value1');
      metadata2.add('key2', 'value2b');
      metadata2.add('key3', 'value3b');
      metadata2.add('key5', 'value5a');
      metadata2.add('key5', 'value5b');
      const metadata2IR = metadata2.getInternalRepresentation();
      metadata.merge(metadata2);
      // Ensure metadata2 didn't change
      assert.deepStrictEqual(
        metadata2.getInternalRepresentation(),
        metadata2IR
      );
      assert.deepStrictEqual(metadata.get('key1'), ['value1', 'value1']);
      assert.deepStrictEqual(metadata.get('key2'), ['value2a', 'value2b']);
      assert.deepStrictEqual(metadata.get('key3'), ['value3a', 'value3b']);
      assert.deepStrictEqual(metadata.get('key4'), ['value4']);
      assert.deepStrictEqual(metadata.get('key5'), ['value5a', 'value5b']);
    });
  });

  describe('toHttp2Headers', () => {
    it('creates an OutgoingHttpHeaders object with expected values', () => {
      metadata.add('key1', 'value1');
      metadata.add('Key2', 'value2');
      metadata.add('KEY3', 'value3a');
      metadata.add('key3', 'value3b');
      metadata.add('key-bin', Buffer.from(range(0, 16)));
      metadata.add('key-bin', Buffer.from(range(16, 32)));
      metadata.add('key-bin', Buffer.from(range(0, 32)));
      const headers = metadata.toHttp2Headers();
      assert.deepStrictEqual(headers, {
        key1: ['value1'],
        key2: ['value2'],
        key3: ['value3a', 'value3b'],
        'key-bin': [
          'AAECAwQFBgcICQoLDA0ODw==',
          'EBESExQVFhcYGRobHB0eHw==',
          'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=',
        ],
      });
    });

    it('creates an empty header object from empty Metadata', () => {
      assert.deepStrictEqual(metadata.toHttp2Headers(), {});
    });
  });

  describe('fromHttp2Headers', () => {
    it('creates a Metadata object with expected values', () => {
      const headers = {
        key1: 'value1',
        key2: ['value2'],
        key3: ['value3a', 'value3b'],
        key4: ['part1, part2'],
        'key-bin': [
          'AAECAwQFBgcICQoLDA0ODw==',
          'EBESExQVFhcYGRobHB0eHw==',
          'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=',
        ],
      };
      const metadataFromHeaders = TestMetadata.fromHttp2Headers(headers);
      const internalRepr = metadataFromHeaders.getInternalRepresentation();
      const expected: MetadataObject = new Map<string, MetadataValue[]>([
        ['key1', ['value1']],
        ['key2', ['value2']],
        ['key3', ['value3a', 'value3b']],
        ['key4', ['part1, part2']],
        [
          'key-bin',
          [
            Buffer.from(range(0, 16)),
            Buffer.from(range(16, 32)),
            Buffer.from(range(0, 32)),
          ],
        ],
      ]);
      assert.deepStrictEqual(internalRepr, expected);
    });

    it('creates an empty Metadata object from empty headers', () => {
      const metadataFromHeaders = TestMetadata.fromHttp2Headers({});
      const internalRepr = metadataFromHeaders.getInternalRepresentation();
      assert.deepStrictEqual(internalRepr, new Map<string, MetadataValue[]>());
    });
  });
});