/*
 * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package jdk.internal.net.http.hpack;

import jdk.internal.net.http.hpack.SimpleHeaderTable.HeaderField;
import org.testng.annotations.Test;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import static org.testng.Assert.assertEquals;
import static org.testng.AssertJUnit.assertTrue;

public class HeaderTableTest extends SimpleHeaderTableTest {

    @Override
    protected HeaderTable createHeaderTable(int maxSize) {
        return new HeaderTable(maxSize, HPACK.getLogger());
    }

    @Test
    public void staticData() {
        HeaderTable table = createHeaderTable(0);
        Map<Integer, HeaderField> staticHeaderFields = createStaticEntries();

        Map<String, Set<Integer>> indexes = new HashMap<>();

        for (Map.Entry<Integer, HeaderField> e : staticHeaderFields.entrySet()) {
            Integer idx = e.getKey();
            String name = e.getValue().name;
            indexes.merge(name, Set.of(idx), (v1, v2) -> {
                HashSet<Integer> s = new HashSet<>();
                s.addAll(v1);
                s.addAll(v2);
                return s;
            });
        }

        staticHeaderFields.forEach((key, expectedHeaderField) -> {
            // lookup
            HeaderField actualHeaderField = table.get(key);
            assertEquals(actualHeaderField.name, expectedHeaderField.name);
            assertEquals(actualHeaderField.value, expectedHeaderField.value);

            // reverse lookup (name, value)
            String hName = expectedHeaderField.name;
            String hValue = expectedHeaderField.value;
            int expectedIndex = key;
            int actualIndex = table.indexOf(hName, hValue);

            assertEquals(actualIndex, expectedIndex);

            // reverse lookup (name)
            Set<Integer> expectedIndexes = indexes.get(hName);
            int actualMinimalIndex = table.indexOf(hName, "blah-blah");

            assertTrue(expectedIndexes.contains(-actualMinimalIndex));
        });
    }

    @Test
    public void lowerIndexPriority() {
        HeaderTable table = createHeaderTable(256);
        int oldLength = table.length();
        table.put("bender", "rodriguez");
        table.put("bender", "rodriguez");
        table.put("bender", "rodriguez");

        assertEquals(table.length(), oldLength + 3); // more like an assumption
        int i = table.indexOf("bender", "rodriguez");
        assertEquals(i, oldLength + 1);
    }

    @Test
    public void indexesAreNotLost2() {
        HeaderTable table = createHeaderTable(256);
        int oldLength = table.length();
        table.put("bender", "rodriguez");
        assertEquals(table.indexOf("bender", "rodriguez"), oldLength + 1);
        table.put("bender", "rodriguez");
        assertEquals(table.indexOf("bender", "rodriguez"), oldLength + 1);
        table.evictEntry();
        assertEquals(table.indexOf("bender", "rodriguez"), oldLength + 1);
        table.evictEntry();
        assertEquals(table.indexOf("bender", "rodriguez"), 0);
    }

    @Test
    public void lowerIndexPriority2() {
        HeaderTable table = createHeaderTable(256);
        int oldLength = table.length();
        int idx = rnd.nextInt(oldLength) + 1;
        HeaderField f = table.get(idx);
        table.put(f.name, f.value);
        assertEquals(table.length(), oldLength + 1);
        int i = table.indexOf(f.name, f.value);
        assertEquals(i, idx);
    }

    @Test
    public void indexOf() {
        // Let's put a series of header fields
        int NUM_HEADERS = 32;
        HeaderTable table =
                createHeaderTable((32 + 4) * NUM_HEADERS);
        //                          ^   ^
        //             entry overhead   symbols per entry (max 2x2 digits)
        for (int i = 1; i <= NUM_HEADERS; i++) {
            String s = String.valueOf(i);
            table.put(s, s);
        }
        // and verify indexOf (reverse lookup) returns correct indexes for
        // full lookup
        for (int j = 1; j <= NUM_HEADERS; j++) {
            String s = String.valueOf(j);
            int actualIndex = table.indexOf(s, s);
            int expectedIndex = STATIC_TABLE_LENGTH + NUM_HEADERS - j + 1;
            assertEquals(actualIndex, expectedIndex);
        }
        // as well as for just a name lookup
        for (int j = 1; j <= NUM_HEADERS; j++) {
            String s = String.valueOf(j);
            int actualIndex = table.indexOf(s, "blah");
            int expectedIndex = -(STATIC_TABLE_LENGTH + NUM_HEADERS - j + 1);
            assertEquals(actualIndex, expectedIndex);
        }
        // lookup for non-existent name returns 0
        assertEquals(table.indexOf("chupacabra", "1"), 0);
    }
}