/*
 * Copyright (C) 2008 The Guava 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.
 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.collect.Table.Cell;
import com.google.common.collect.testing.MapInterfaceTest;
import com.google.common.collect.testing.SampleElements;
import com.google.common.collect.testing.TestSetGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.Feature;

import junit.framework.TestCase;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;

/**
 * Collection tests for {@link Table} implementations.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible(emulated = true)
public class TableCollectionTest extends TestCase {

  private static final Feature<?>[] COLLECTION_FEATURES = {
    CollectionSize.ANY,
    CollectionFeature.ALLOWS_NULL_QUERIES
  };

  private static final Feature<?>[] COLLECTION_FEATURES_ORDER = {
    CollectionSize.ANY,
    CollectionFeature.KNOWN_ORDER,
    CollectionFeature.ALLOWS_NULL_QUERIES
  };

  private static final Feature<?>[] COLLECTION_FEATURES_REMOVE = {
    CollectionSize.ANY,
    CollectionFeature.SUPPORTS_REMOVE,
    CollectionFeature.ALLOWS_NULL_QUERIES
  };

  private static final Feature<?>[] COLLECTION_FEATURES_REMOVE_ORDER = {
    CollectionSize.ANY,
    CollectionFeature.KNOWN_ORDER,
    CollectionFeature.SUPPORTS_REMOVE,
    CollectionFeature.ALLOWS_NULL_QUERIES
  };

  private static void populateForRowKeySet(
      Table<String, Integer, Character> table, String[] elements) {
    for (String row : elements) {
      table.put(row, 1, 'a');
      table.put(row, 2, 'b');
    }
  }

  private static void populateForColumnKeySet(
      Table<Integer, String, Character> table, String[] elements) {
    for (String column : elements) {
      table.put(1, column, 'a');
      table.put(2, column, 'b');
    }
  }

  private static void populateForValues(
      Table<Integer, Character, String> table, String[] elements) {
    for (int i = 0; i < elements.length; i++) {
      table.put(i, 'a', elements[i]);
    }
  }

  private static abstract class TestCellSetGenerator
      implements TestSetGenerator<Cell<String, Integer, Character>> {
    @Override
    public SampleElements<Cell<String, Integer, Character>> samples() {
      return new SampleElements<Cell<String, Integer, Character>>(
          Tables.immutableCell("bar", 1, 'a'),
          Tables.immutableCell("bar", 2, 'b'),
          Tables.immutableCell("foo", 3, 'c'),
          Tables.immutableCell("bar", 1, 'b'),
          Tables.immutableCell("cat", 2, 'b'));
    }

    @Override
    public Set<Cell<String, Integer, Character>> create(
        Object... elements) {
      Table<String, Integer, Character> table = createTable();
      for (Object element : elements) {
        @SuppressWarnings("unchecked")
        Cell<String, Integer, Character> cell
            = (Cell<String, Integer, Character>) element;
        table.put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
      }
      return table.cellSet();
    }

    abstract Table<String, Integer, Character> createTable();

    @Override
    @SuppressWarnings("unchecked")
    public Cell<String, Integer, Character>[] createArray(int length) {
      return (Cell<String, Integer, Character>[]) new Cell<?, ?, ?>[length];
    }

    @Override
    public List<Cell<String, Integer, Character>> order(
        List<Cell<String, Integer, Character>> insertionOrder) {
      return insertionOrder;
    }
  }

  private static abstract class MapTests
      extends MapInterfaceTest<String, Integer> {

    MapTests(boolean allowsNullValues, boolean supportsPut, boolean supportsRemove,
        boolean supportsClear, boolean supportsIteratorRemove) {
      super(false, allowsNullValues, supportsPut, supportsRemove, supportsClear,
          supportsIteratorRemove);
    }

    @Override protected String getKeyNotInPopulatedMap() {
      return "four";
    }

    @Override protected Integer getValueNotInPopulatedMap() {
      return 4;
    }
  }

  private static abstract class RowTests extends MapTests {
    RowTests(boolean allowsNullValues, boolean supportsPut, boolean supportsRemove,
        boolean supportsClear, boolean supportsIteratorRemove) {
      super(allowsNullValues, supportsPut, supportsRemove, supportsClear,
          supportsIteratorRemove);
    }

    abstract Table<Character, String, Integer> makeTable();

    @Override protected Map<String, Integer> makeEmptyMap() {
      return makeTable().row('a');
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      Table<Character, String, Integer> table = makeTable();
      table.put('a', "one", 1);
      table.put('a', "two", 2);
      table.put('a', "three", 3);
      table.put('b', "four", 4);
      return table.row('a');
    }
  }

  public static class HashRowTests extends RowTests {
    public HashRowTests() {
      super(false, true, true, true, true);
    }

    @Override Table<Character, String, Integer> makeTable() {
      return HashBasedTable.create();
    }
  }

  public static class TreeRowTests extends RowTests {
    public TreeRowTests() {
      super(false, true, true, true, true);
    }

    @Override Table<Character, String, Integer> makeTable() {
      return TreeBasedTable.create();
    }
  }

  public static class TransposeRowTests extends RowTests {
    public TransposeRowTests() {
      super(false, true, true, true, false);
    }

    @Override Table<Character, String, Integer> makeTable() {
      Table<String, Character, Integer> original = TreeBasedTable.create();
      return Tables.transpose(original);
    }
  }

  private static final Function<Integer, Integer> DIVIDE_BY_2
      = new Function<Integer, Integer>() {
        @Override public Integer apply(Integer input) {
          return (input == null) ? null : input / 2;
        }
  };

  public static class TransformValueRowTests extends RowTests {
    public TransformValueRowTests() {
      super(false, false, true, true, true);
    }

    @Override Table<Character, String, Integer> makeTable() {
      Table<Character, String, Integer> table = HashBasedTable.create();
      return Tables.transformValues(table, DIVIDE_BY_2);
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      Table<Character, String, Integer> table = HashBasedTable.create();
      table.put('a', "one", 2);
      table.put('a', "two", 4);
      table.put('a', "three", 6);
      table.put('b', "four", 8);
      return Tables.transformValues(table, DIVIDE_BY_2).row('a');
    }
  }

  public static class UnmodifiableHashRowTests extends RowTests {
    public UnmodifiableHashRowTests() {
      super(false, false, false, false, false);
    }

    @Override Table<Character, String, Integer> makeTable() {
      Table<Character, String, Integer> table = HashBasedTable.create();
      return Tables.unmodifiableTable(table);
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      Table<Character, String, Integer> table = HashBasedTable.create();
      table.put('a', "one", 1);
      table.put('a', "two", 2);
      table.put('a', "three", 3);
      table.put('b', "four", 4);
      return Tables.unmodifiableTable(table).row('a');
    }
  }

  public static class UnmodifiableTreeRowTests extends RowTests {
    public UnmodifiableTreeRowTests() {
      super(false, false, false, false, false);
    }

    @Override Table<Character, String, Integer> makeTable() {
      RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
      return Tables.unmodifiableRowSortedTable(table);
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
      table.put('a', "one", 1);
      table.put('a', "two", 2);
      table.put('a', "three", 3);
      table.put('b', "four", 4);
      return Tables.unmodifiableRowSortedTable(table).row('a');
    }
  }

  private static abstract class ColumnTests extends MapTests {
    ColumnTests(boolean allowsNullValues, boolean supportsPut, boolean supportsRemove,
        boolean supportsClear, boolean supportsIteratorRemove) {
      super(allowsNullValues, supportsPut, supportsRemove, supportsClear,
          supportsIteratorRemove);
    }

    abstract Table<String, Character, Integer> makeTable();

    @Override protected Map<String, Integer> makeEmptyMap() {
      return makeTable().column('a');
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      Table<String, Character, Integer> table = makeTable();
      table.put("one", 'a', 1);
      table.put("two", 'a', 2);
      table.put("three", 'a', 3);
      table.put("four", 'b', 4);
      return table.column('a');
    }
  }

  public static class HashColumnTests extends ColumnTests {
    public HashColumnTests() {
      super(false, true, true, true, false);
    }

    @Override Table<String, Character, Integer> makeTable() {
      return HashBasedTable.create();
    }
  }

  public static class TreeColumnTests extends ColumnTests {
    public TreeColumnTests() {
      super(false, true, true, true, false);
    }

    @Override Table<String, Character, Integer> makeTable() {
      return TreeBasedTable.create();
    }
  }

  public static class TransposeColumnTests extends ColumnTests {
    public TransposeColumnTests() {
      super(false, true, true, true, true);
    }

    @Override Table<String, Character, Integer> makeTable() {
      Table<Character, String, Integer> original = TreeBasedTable.create();
      return Tables.transpose(original);
    }
  }

  public static class TransformValueColumnTests extends ColumnTests {
    public TransformValueColumnTests() {
      super(false, false, true, true, false);
    }

    @Override Table<String, Character, Integer> makeTable() {
      Table<String, Character, Integer> table = HashBasedTable.create();
      return Tables.transformValues(table, DIVIDE_BY_2);
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      Table<String, Character, Integer> table = HashBasedTable.create();
      table.put("one", 'a', 1);
      table.put("two", 'a', 2);
      table.put("three", 'a', 3);
      table.put("four", 'b', 4);
      return Tables.transformValues(table, DIVIDE_BY_2).column('a');
    }
  }

  public static class UnmodifiableHashColumnTests extends ColumnTests {
    public UnmodifiableHashColumnTests() {
      super(false, false, false, false, false);
    }

    @Override Table<String, Character, Integer> makeTable() {
      Table<String, Character, Integer> table = HashBasedTable.create();
      return Tables.unmodifiableTable(table);
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      Table<String, Character, Integer> table = HashBasedTable.create();
      table.put("one", 'a', 1);
      table.put("two", 'a', 2);
      table.put("three", 'a', 3);
      table.put("four", 'b', 4);
      return Tables.unmodifiableTable(table).column('a');
    }
  }

  public static class UnmodifiableTreeColumnTests extends ColumnTests {
    public UnmodifiableTreeColumnTests() {
      super(false, false, false, false, false);
    }

    @Override Table<String, Character, Integer> makeTable() {
      RowSortedTable<String, Character, Integer> table = TreeBasedTable.create();
      return Tables.unmodifiableRowSortedTable(table);
    }

    @Override protected Map<String, Integer> makePopulatedMap() {
      RowSortedTable<String, Character, Integer> table = TreeBasedTable.create();
      table.put("one", 'a', 1);
      table.put("two", 'a', 2);
      table.put("three", 'a', 3);
      table.put("four", 'b', 4);
      return Tables.unmodifiableRowSortedTable(table).column('a');
    }
  }

  private static abstract class MapMapTests
      extends MapInterfaceTest<String, Map<Integer, Character>> {

    MapMapTests(boolean allowsNullValues, boolean supportsRemove,
        boolean supportsClear, boolean supportsIteratorRemove) {
      super(false, allowsNullValues, false, supportsRemove, supportsClear,
          supportsIteratorRemove);
    }

    @Override protected String getKeyNotInPopulatedMap() {
      return "cat";
    }

    @Override protected Map<Integer, Character> getValueNotInPopulatedMap() {
      return ImmutableMap.of();
    }

    /**
     * The version of this test supplied by {@link MapInterfaceTest} fails for
     * this particular map implementation, because {@code map.get()} returns a
     * view collection that changes in the course of a call to {@code remove()}.
     * Thus, the expectation doesn't hold that {@code map.remove(x)} returns the
     * same value which {@code map.get(x)} did immediately beforehand.
     */
    @Override public void testRemove() {
      final Map<String, Map<Integer, Character>> map;
      final String keyToRemove;
      try {
        map = makePopulatedMap();
      } catch (UnsupportedOperationException e) {
        return;
      }
      keyToRemove = map.keySet().iterator().next();
      if (supportsRemove) {
        int initialSize = map.size();
        map.get(keyToRemove);
        map.remove(keyToRemove);
        // This line doesn't hold - see the Javadoc comments above.
        // assertEquals(expectedValue, oldValue);
        assertFalse(map.containsKey(keyToRemove));
        assertEquals(initialSize - 1, map.size());
      } else {
        try {
          map.remove(keyToRemove);
          fail("Expected UnsupportedOperationException.");
        } catch (UnsupportedOperationException e) {
          // Expected.
        }
      }
      assertInvariants(map);
    }
  }

  private static abstract class RowMapTests extends MapMapTests {
    RowMapTests(boolean allowsNullValues, boolean supportsRemove,
        boolean supportsClear, boolean supportsIteratorRemove) {
      super(allowsNullValues, supportsRemove, supportsClear,
          supportsIteratorRemove);
    }

    abstract Table<String, Integer, Character> makeTable();

    @Override protected Map<String, Map<Integer, Character>>
        makePopulatedMap() {
      Table<String, Integer, Character> table = makeTable();
      populateTable(table);
      return table.rowMap();
    }

    void populateTable(Table<String, Integer, Character> table) {
      table.put("foo", 1, 'a');
      table.put("bar", 1, 'b');
      table.put("foo", 3, 'c');
    }

    @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().rowMap();
    }
  }

  public static class HashRowMapTests extends RowMapTests {
    public HashRowMapTests() {
      super(false, true, true, true);
    }

    @Override Table<String, Integer, Character> makeTable() {
      return HashBasedTable.create();
    }
  }

  public static class TreeRowMapTests extends RowMapTests {
    public TreeRowMapTests() {
      super(false, true, true, true);
    }

    @Override Table<String, Integer, Character> makeTable() {
      return TreeBasedTable.create();
    }
  }

  public static class TreeRowMapHeadMapTests extends RowMapTests {
    public TreeRowMapHeadMapTests() {
      super(false, true, true, true);
    }

    @Override TreeBasedTable<String, Integer, Character> makeTable() {
      TreeBasedTable<String, Integer, Character> table =
          TreeBasedTable.create();
      table.put("z", 1, 'a');
      return table;
    }

    @Override protected Map<String, Map<Integer, Character>>
        makePopulatedMap() {
      TreeBasedTable<String, Integer, Character> table = makeTable();
      populateTable(table);
      return table.rowMap().headMap("x");
    }

    @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().rowMap().headMap("x");
    }

    @Override protected String getKeyNotInPopulatedMap() {
      return "z";
    }
  }

  public static class TreeRowMapTailMapTests extends RowMapTests {
    public TreeRowMapTailMapTests() {
      super(false, true, true, true);
    }

    @Override TreeBasedTable<String, Integer, Character> makeTable() {
      TreeBasedTable<String, Integer, Character> table =
          TreeBasedTable.create();
      table.put("a", 1, 'a');
      return table;
    }

    @Override protected Map<String, Map<Integer, Character>>
        makePopulatedMap() {
      TreeBasedTable<String, Integer, Character> table = makeTable();
      populateTable(table);
      return table.rowMap().tailMap("b");
    }

    @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().rowMap().tailMap("b");
    }

    @Override protected String getKeyNotInPopulatedMap() {
      return "a";
    }
  }

  public static class TreeRowMapSubMapTests extends RowMapTests {
    public TreeRowMapSubMapTests() {
      super(false, true, true, true);
    }

    @Override TreeBasedTable<String, Integer, Character> makeTable() {
      TreeBasedTable<String, Integer, Character> table =
          TreeBasedTable.create();
      table.put("a", 1, 'a');
      table.put("z", 1, 'a');
      return table;
    }

    @Override protected Map<String, Map<Integer, Character>>
        makePopulatedMap() {
      TreeBasedTable<String, Integer, Character> table = makeTable();
      populateTable(table);
      return table.rowMap().subMap("b", "x");
    }

    @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().rowMap().subMap("b", "x");
    }

    @Override protected String getKeyNotInPopulatedMap() {
      return "z";
    }
  }

  private static final Function<String, Character> FIRST_CHARACTER =
      new Function<String, Character>() {
        @Override
        public Character apply(String input) {
          return input == null ? null : input.charAt(0);
        }
      };

  public static class TransformValueRowMapTests extends RowMapTests {
    public TransformValueRowMapTests() {
      super(false, true, true, true);
    }

    @Override Table<String, Integer, Character> makeTable() {
      Table<String, Integer, String> original = HashBasedTable.create();
      return Tables.transformValues(original, FIRST_CHARACTER);
    }

    @Override
    protected Map<String, Map<Integer, Character>> makePopulatedMap() {
      Table<String, Integer, String> table = HashBasedTable.create();
      table.put("foo", 1, "apple");
      table.put("bar", 1, "banana");
      table.put("foo", 3, "cat");
      return Tables.transformValues(table, FIRST_CHARACTER).rowMap();
    }
  }

  public static class UnmodifiableHashRowMapTests extends RowMapTests {
    public UnmodifiableHashRowMapTests() {
      super(false, false, false, false);
    }

    @Override Table<String, Integer, Character> makeTable() {
      Table<String, Integer, Character> original = HashBasedTable.create();
      return Tables.unmodifiableTable(original);
    }

    @Override
    protected Map<String, Map<Integer, Character>> makePopulatedMap() {
      Table<String, Integer, Character> table = HashBasedTable.create();
      table.put("foo", 1, 'a');
      table.put("bar", 1, 'b');
      table.put("foo", 3, 'c');
      return Tables.unmodifiableTable(table).rowMap();
    }
  }

  public static class UnmodifiableTreeRowMapTests extends RowMapTests {
    public UnmodifiableTreeRowMapTests() {
      super(false, false, false, false);
    }

    @Override RowSortedTable<String, Integer, Character> makeTable() {
      RowSortedTable<String, Integer, Character> original = TreeBasedTable.create();
      return Tables.unmodifiableRowSortedTable(original);
    }

    @Override
    protected SortedMap<String, Map<Integer, Character>> makePopulatedMap() {
      RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
      table.put("foo", 1, 'a');
      table.put("bar", 1, 'b');
      table.put("foo", 3, 'c');
      return Tables.unmodifiableRowSortedTable(table).rowMap();
    }
  }

  private static abstract class ColumnMapTests extends MapMapTests {
    ColumnMapTests(boolean allowsNullValues, boolean supportsRemove,
        boolean supportsClear, boolean supportsIteratorRemove) {
      super(allowsNullValues, supportsRemove, supportsClear,
          supportsIteratorRemove);
    }

    abstract Table<Integer, String, Character> makeTable();

    @Override protected Map<String, Map<Integer, Character>>
        makePopulatedMap() {
      Table<Integer, String, Character> table = makeTable();
      table.put(1, "foo", 'a');
      table.put(1, "bar", 'b');
      table.put(3, "foo", 'c');
      return table.columnMap();
    }

    @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().columnMap();
    }
  }

  public static class HashColumnMapTests extends ColumnMapTests {
    public HashColumnMapTests() {
      super(false, true, true, false);
    }

    @Override Table<Integer, String, Character> makeTable() {
      return HashBasedTable.create();
    }
  }

  public static class TreeColumnMapTests extends ColumnMapTests {
    public TreeColumnMapTests() {
      super(false, true, true, false);
    }

    @Override Table<Integer, String, Character> makeTable() {
      return TreeBasedTable.create();
    }
  }

  public static class TransformValueColumnMapTests extends ColumnMapTests {
    public TransformValueColumnMapTests() {
      super(false, true, true, false);
    }

    @Override Table<Integer, String, Character> makeTable() {
      Table<Integer, String, String> original = HashBasedTable.create();
      return Tables.transformValues(original, FIRST_CHARACTER);
    }

    @Override
    protected Map<String, Map<Integer, Character>> makePopulatedMap() {
      Table<Integer, String, String> table = HashBasedTable.create();
      table.put(1, "foo", "apple");
      table.put(1, "bar", "banana");
      table.put(3, "foo", "cat");
      return Tables.transformValues(table, FIRST_CHARACTER).columnMap();
    }
  }

  public static class UnmodifiableHashColumnMapTests extends ColumnMapTests {
    public UnmodifiableHashColumnMapTests() {
      super(false, false, false, false);
    }

    @Override Table<Integer, String, Character> makeTable() {
      Table<Integer, String, Character> original = HashBasedTable.create();
      return Tables.unmodifiableTable(original);
    }

    @Override
    protected Map<String, Map<Integer, Character>> makePopulatedMap() {
      Table<Integer, String, Character> table = HashBasedTable.create();
      table.put(1, "foo", 'a');
      table.put(1, "bar", 'b');
      table.put(3, "foo", 'c');
      return Tables.unmodifiableTable(table).columnMap();
    }
  }

  public static class UnmodifiableTreeColumnMapTests extends ColumnMapTests {
    public UnmodifiableTreeColumnMapTests() {
      super(false, false, false, false);
    }

    @Override Table<Integer, String, Character> makeTable() {
      RowSortedTable<Integer, String, Character> original = TreeBasedTable.create();
      return Tables.unmodifiableRowSortedTable(original);
    }

    @Override
    protected Map<String, Map<Integer, Character>> makePopulatedMap() {
      RowSortedTable<Integer, String, Character> table = TreeBasedTable.create();
      table.put(1, "foo", 'a');
      table.put(1, "bar", 'b');
      table.put(3, "foo", 'c');
      return Tables.unmodifiableRowSortedTable(table).columnMap();
    }
  }
}