/*
 * Copyright 2010 Google Inc.
 * 
 * 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.gwt.user.cellview.client;

import com.google.gwt.cell.client.AbstractCell;
import com.google.gwt.cell.client.TextCell;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.view.client.ListDataProvider;
import com.google.gwt.view.client.TreeViewModel;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Tests for {@link CellTree}.
 */
public class CellTreeTest extends AbstractCellTreeTestBase {

  public CellTreeTest() {
    super(false);
  }

  public void testRefreshEmptyNode() {
    // An empty data provider.
    final ListDataProvider<String> provider = new ListDataProvider<String>();
    TreeViewModel model = new TreeViewModel() {
      @Override
      public NodeInfo<?> getNodeInfo(Object value) {
        TextCell cell = new TextCell();
        return new DefaultNodeInfo<String>(provider, cell);
      }

      @Override
      public boolean isLeaf(Object value) {
        return false;
      }
    };

    // Create the tree.
    CellTree tree = createAbstractCellTree(model, null);
    tree.rootNode.listView.presenter.flush();

    // Refresh the empty list.
    provider.refresh();
    provider.flush();
    tree.rootNode.listView.presenter.flush();
  }

  /**
   * Test that CellTree handles rendering the same content, but with a different
   * underlying value.
   */
  public void testRenderSameContent() {
    final AbstractCell<Integer> intCell = new AbstractCell<Integer>() {
      @Override
      public void render(Context context, Integer value, SafeHtmlBuilder sb) {
        sb.append(value % 10); // Render the units digit only.
      }
    };

    // Create a data provider for the root node.
    final ListDataProvider<Integer> root = new ListDataProvider<Integer>();
    for (int i = 0; i < 9; i++) {
      root.getList().add(i);
    }

    TreeViewModel model = new TreeViewModel() {
      @Override
      public NodeInfo<?> getNodeInfo(Object value) {
        if (value == null) {
          // Return the root node.
          return new DefaultNodeInfo<Integer>(root, intCell);
        } else {
          // Return a child node.
          return new DefaultNodeInfo<String>(new ListDataProvider<String>(), new TextCell());
        }
      }

      @Override
      public boolean isLeaf(Object value) {
        return false;
      }
    };

    CellTree tree = createAbstractCellTree(model, null);
    RootPanel.get().add(tree);
    tree.rootNode.listView.presenter.flush();

    // Open the first child.
    TreeNode rootNode = tree.getRootTreeNode();
    assertEquals(1, rootNode.getChildValue(1));
    TreeNode child1 = rootNode.setChildOpen(1, true);
    assertFalse(child1.isDestroyed());
    assertTrue(rootNode.isChildOpen(1));

    // Replace all values in the list.
    List<Integer> oldData = root.getList();
    List<Integer> newData = new ArrayList<Integer>();
    for (int l : oldData) {
      newData.add(l + 100); // renders the same as the current value.
    }
    root.setList(newData);
    root.flush();
    tree.rootNode.listView.presenter.flush();

    // Child1 is closed and destroyed.
    assertFalse(rootNode.isChildOpen(1));
    assertTrue(child1.isDestroyed());

    RootPanel.get().remove(tree);
  }

  /**
   * Test that replacing a subset of children updates both the TreeNode value
   * and the underlying DOM correctly.
   */
  public void testReplaceChildren() {
    CellTree cellTree = (CellTree) tree;
    TreeNode root = cellTree.getRootTreeNode();

    // Open a couple of child nodes.
    TreeNode a = root.setChildOpen(0, true);
    TreeNode b = root.setChildOpen(1, true);
    assertEquals("a", a.getValue());
    assertEquals("ab", a.getChildValue(1));
    assertEquals("b", b.getValue());
    assertEquals("bc", b.getChildValue(2));

    // Replace "b" with a "new" value.
    model.getRootDataProvider().getList().set(1, "new");
    model.getRootDataProvider().flush();
    assertFalse(a.isDestroyed());
    assertTrue(b.isDestroyed());
    TreeNode newNode = root.setChildOpen(1, true);
    assertEquals("a", a.getValue());
    assertEquals("ab", a.getChildValue(1));
    assertEquals("new", newNode.getValue());
    assertEquals("newc", newNode.getChildValue(2));

    // Check the underlying DOM values.
    CellTreeNodeView<?> aImpl = cellTree.rootNode.getChildNode(0);
    CellTreeNodeView<?> newNodeImpl = cellTree.rootNode.getChildNode(1);
    assertEquals("a", aImpl.getCellParent().getInnerText());
    assertEquals(10, aImpl.ensureChildContainer().getChildCount());
    assertEquals("new", newNodeImpl.getCellParent().getInnerText());
  }

  public void testAriaSelectedAndExpanded() {
    CellTree cellTree = (CellTree) tree;
    TreeNode root = cellTree.getRootTreeNode();

    TreeNode newNode = root.setChildOpen(1, true);
    cellTree.rootNode.getChildNode(1).setSelected(true);
    model.getRootDataProvider().refresh();
    model.getRootDataProvider().flush();
    root.setChildOpen(1, true);
    CellTreeNodeView<?> newNodeImpl = cellTree.rootNode.getChildNode(1);
    assertEquals("true", newNodeImpl.getElement().getAttribute("aria-selected"));
    // Check aria-expanded on open
    assertEquals("true", newNodeImpl.getElement().getAttribute("aria-expanded"));

    // Check aria-expanded on close
    root.setChildOpen(1, false);
    newNodeImpl = cellTree.rootNode.getChildNode(1);
    assertEquals("false", newNodeImpl.getElement().getAttribute("aria-expanded"));

    cellTree.rootNode.getChildNode(1).setSelected(false);
    model.getRootDataProvider().refresh();
    model.getRootDataProvider().flush();
    root.setChildOpen(1, true);
    newNodeImpl = cellTree.rootNode.getChildNode(1);
    assertEquals("false", newNodeImpl.getElement().getAttribute("aria-selected"));
  }

  public void testSetDefaultNodeSize() {
    CellTree cellTree = (CellTree) tree;
    TreeNode root = cellTree.getRootTreeNode();
    assertEquals(10, root.getChildCount());

    TreeNode b = root.setChildOpen(1, true);
    assertEquals(10, b.getChildCount());

    // Change the default size.
    cellTree.setDefaultNodeSize(5);
    assertEquals(5, cellTree.getDefaultNodeSize());
    assertEquals(10, b.getChildCount());
    TreeNode d = root.setChildOpen(3, true);
    assertEquals(5, d.getChildCount());
  }

  public void testAriaAttributes() {
    CellTree cellTree = (CellTree) tree;
    TreeNode rootNode = cellTree.getRootTreeNode();

    // Open a child node.
    TreeNode aNode = rootNode.setChildOpen(0, true);

    // Check role="tree"
    assertEquals("tree", cellTree.rootNode.getElement().getAttribute("role"));

    // Check 1st level
    CellTreeNodeView<?> aView = cellTree.rootNode.getChildNode(0);
    CellTreeNodeView<?> bView = cellTree.rootNode.getChildNode(1);

    // Check treeitem role, level, posinset, and setsize
    assertEquals("treeitem", aView.getElement().getAttribute("role"));
    assertEquals("1", aView.getElement().getAttribute("aria-level"));
    assertEquals("1", aView.getElement().getAttribute("aria-posinset"));
    assertEquals("10", aView.getElement().getAttribute("aria-setsize"));

    assertEquals("treeitem", bView.getElement().getAttribute("role"));
    assertEquals("1", bView.getElement().getAttribute("aria-level"));
    assertEquals("2", bView.getElement().getAttribute("aria-posinset"));
    assertEquals("10", bView.getElement().getAttribute("aria-setsize"));

    // Check 2nd level
    assertTrue(aNode.getChildCount() != 0);
    assertEquals(aNode, aView.getTreeNode());
    assertTrue(aView.getChildCount() != 0);
    CellTreeNodeView<?> aViewChild = aView.getChildNode(0);

    // Check treeitem role, level, posinset, and setsize
    assertEquals("treeitem", aViewChild.getElement().getAttribute("role"));
    assertEquals("2", aViewChild.getElement().getAttribute("aria-level"));
    assertEquals("1", aViewChild.getElement().getAttribute("aria-posinset"));
    assertEquals("10", aViewChild.getElement().getAttribute("aria-setsize"));

    // Check aria-expanded
    assertEquals("true", aView.getElement().getAttribute("aria-expanded"));
    assertEquals("false", aViewChild.getElement().getAttribute("aria-expanded"));
    while (!aNode.isChildLeaf(0)) {
      aNode = aNode.setChildOpen(0, true);
      aView = aView.getChildNode(0);
    }
    assertEquals(aNode, aView.getTreeNode());
    assertEquals("", aView.getChildNode(0).getElement().getAttribute("aria-expanded"));

    // Change default size and check aria-setsize and aria-posinset
    cellTree.setDefaultNodeSize(5);
    TreeNode cNode = rootNode.setChildOpen(3, true);
    CellTreeNodeView<?> cView = cellTree.rootNode.getChildNode(3);
    assertEquals(5, cNode.getChildCount());

    CellTreeNodeView<?> cViewChildFirst = cView.getChildNode(0);
    assertEquals("1", cViewChildFirst.getElement().getAttribute("aria-posinset"));
    assertEquals("5", cViewChildFirst.getElement().getAttribute("aria-setsize"));

    CellTreeNodeView<?> cViewChildLast = cView.getChildNode(cView.getChildCount() - 1);
    assertEquals("5", cViewChildLast.getElement().getAttribute("aria-posinset"));
    assertEquals("5", cViewChildLast.getElement().getAttribute("aria-setsize"));
  }

  public void testExplicitKeyboardSelection() {
    CellTree cellTree = (CellTree) tree;
    TreeNode root = cellTree.getRootTreeNode();

    final String cellTreeKeyboardSelectedItemStyleName =
        cellTree.getStyle().cellTreeKeyboardSelectedItem();

    // Navigate through tree to level 4 nodes.
    TreeNode l1Node = root.setChildOpen(0, true); // a
    CellTreeNodeView<?> l1View = cellTree.rootNode.getChildNode(0);
    TreeNode l2Node = l1Node.setChildOpen(0, true); // aa
    CellTreeNodeView<?> l2View = l1View.getChildNode(0);
    TreeNode l3Node = l2Node.setChildOpen(0, true); // aaa
    CellTreeNodeView<?> l3View = l2View.getChildNode(0);

    ((CellTreeNodeView.TreeNodeImpl) l3Node).flush();
    CellTreeNodeView<?> l4View = l3View.getChildNode(0);
    // l4Node is leaf, cannot get a reference via setChildOpen except via non-public nodeView
    TreeNode l4Node = l4View.getTreeNode(); // aaaa

    // Set keyboard selected node to a subtree node, l3Node = first child of l2Node
    cellTree.setKeyboardSelectedTreeNode(l2Node, 0, true);
    assertEquals(l3View, cellTree.getKeyboardSelectedNode());
    assertEquals(l3Node, cellTree.getKeyboardSelectedTreeNode());
    assertTrue(CellTreeNodeView.getSelectionElement(l3View.getElement()).getClassName()
        .indexOf(cellTreeKeyboardSelectedItemStyleName) >= 0);

    // Set keyboard selected node to a leaf node.
    cellTree.setKeyboardSelectedTreeNode(l3Node, 0, true);
    assertEquals(l4View, cellTree.getKeyboardSelectedNode());
    assertEquals(l4Node, cellTree.getKeyboardSelectedTreeNode());
    assertTrue(CellTreeNodeView.getSelectionElement(l4View.getElement()).getClassName()
        .indexOf(cellTreeKeyboardSelectedItemStyleName) >= 0);

    l1Node.setChildOpen(0, false); // close l2node
    ((CellTreeNodeView.TreeNodeImpl) l1Node).flush();

    // Try to select a leaf node in closed subtree
    try {
      cellTree.setKeyboardSelectedTreeNode(l3Node, 0, true);
      fail("should have thrown");
    } catch (IllegalStateException e) {
      assertEquals("TreeNode no longer exists.", e.getMessage());
    }

    // Try to select a subtree node in closed subtree
    try {
      cellTree.setKeyboardSelectedTreeNode(l2Node, 0, true);
      fail("should have thrown");
    } catch (IllegalStateException e) {
      assertEquals("TreeNode no longer exists.", e.getMessage());
    }

    // Still ok to select closed subtree node
    cellTree.setKeyboardSelectedTreeNode(l1Node, 0, true);

    // Create another tree of same structure
    CellTree anotherTree = createAbstractCellTree(model, root.getValue());
    l1Node = anotherTree.getRootTreeNode().setChildOpen(0, true); // a
    ((CellTreeNodeView.TreeNodeImpl) l1Node).flush();

    // Now l1Node refers to a subtree node in anotherTree
    // Select in the same cell tree is ok
    anotherTree.setKeyboardSelectedTreeNode(l1Node, 0, true);

    // Select in a different tree will throw exception.
    try {
      cellTree.setKeyboardSelectedTreeNode(l1Node, 0, true);
      fail("should have thrown");
    } catch (IllegalArgumentException e) {
      assertEquals("The tree node does not belong to the tree.", e.getMessage());
    }
  }

  public void testKeyboardNavigationForUpAndDownKeys() {
    CellTree cellTree = (CellTree) tree;
    TreeNode root = cellTree.getRootTreeNode();

    // Open nodes: a and aj
    TreeNode l1Node = root.setChildOpen(0, true); // a
    assertEquals("a", l1Node.getValue());
    TreeNode l2Node = l1Node.setChildOpen(9, true); // aj
    assertEquals("aj", l2Node.getValue());
    // To force tree structure changes (internal flush()).
    assertEquals(10, l2Node.getChildCount());

    // CellTree structure with node 'a' and 'aj' opened.
    List<String> expectedNavigationPath = Arrays.asList("a",
        "aa", "ab", "ac", "ad", "ae", "af", "ag", "ah", "ai", "aj",
        "aja", "ajb", "ajc", "ajd", "aje", "ajf", "ajg", "ajh", "aji", "ajj",
        "b", "c", "d", "e", "f", "g", "h", "i", "j");

    // Default KeyboardSelected is at "a"
    assertEquals("a", cellTree.getKeyboardSelectedTreeNode().getValue());

    int steps = expectedNavigationPath.size() - 1;
    assertEquals(expectedNavigationPath, repeatKeyInTree(cellTree, KeyCodes.KEY_DOWN, steps));

    Collections.reverse(expectedNavigationPath);
    assertEquals(expectedNavigationPath, repeatKeyInTree(cellTree, KeyCodes.KEY_UP, steps));
  }

  /**
   * Repeats a keystroke in the CellTree that contains string values.
   * @return the nodes selected before starting and after each keystroke.
   */
  private List<String> repeatKeyInTree(CellTree cellTree, int keyCode, int keyCount) {
    List<String> values = new ArrayList<String>();
    values.add((String) cellTree.getKeyboardSelectedTreeNode().getValue());
    for (int i = 0; i < keyCount; i++) {
      cellTree.handleKeyNavigation(keyCode);
      values.add((String) cellTree.getKeyboardSelectedTreeNode().getValue());
    }
    return values;
  }

  @Override
  protected <T> CellTree createAbstractCellTree(TreeViewModel model, T rootValue) {
    return new CellTree(model, rootValue);
  }
}