/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 org.apache.myfaces.tobago.model;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.swing.tree.TreeNode;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Stack;
  
  /**
   * Implementation for a {@link TreeNode} that represents the data model for a tree.
   */
  public class TreeNodeDataModel extends TreeDataModel {
  
    private static final Logger LOG = LoggerFactory.getLogger(TreeNodeDataModel.class);
  
    private TreeNode data;
    private int rowIndex = -1;
    private Map<Integer, Data> mapping;
    private Map<TreeNode, Integer> back;
    private boolean showRoot;
    private ExpandedState expandedState;
  
    /**
     * @param data          The tree data, which shall be wrapped.
     * @param showRoot      Is the root node visible.
     * @param expandedState Defines which nodes are expanded, (XXX should it be so?) a value of {@code null} means all.
     */
    public TreeNodeDataModel(TreeNode data, boolean showRoot, ExpandedState expandedState) {
      this.data = data;
      this.showRoot = showRoot;
      this.mapping = new HashMap<Integer, Data>();
      this.back = new HashMap<TreeNode, Integer>();
      this.expandedState = expandedState;
      reset();
    }
  
    @Override
    public void reset() {
      this.mapping.clear();
      this.back.clear();
      TreeNode current = data;
      for (int counter = back.size(); current != null; counter++) {
  
        mapping.put(counter, new Data(current));
        back.put(current, counter);
  
        // if the node has children and is expanded, go to the children
        if (current.getChildCount() > 0 && expandedState.isExpanded(current)) {
          current = current.getChildAt(0);
        } else {
          current = getNextNodeButNoChild(current);
        }
      }
    }
  
    @Override
    public void update(ExpandedState expandedState) {
      this.expandedState = expandedState;
      TreeNode current = data;
      int counter = back.size();
      while (current != null) {
  
        if (!back.containsKey(current)) {
          mapping.put(counter, new Data(current));
          back.put(current, counter);
          counter++;
        }
  
        // if the node has children and is expanded, go to the children
        if (current.getChildCount() > 0 && expandedState.isExpanded(current)) {
          current = current.getChildAt(0);
        } else {
          current = getNextNodeButNoChild(current);
        }
      }
   }
 
   private TreeNode getNextNodeButNoChild(TreeNode node) {
     TreeNode next;
     while (true) {
       next = nextSibling(node);
       if (next != null) {
         break;
       }
       node = node.getParent();
       if (node == null) {
         return null;
       }
 
     }
     return next;
   }
 
   private TreeNode nextSibling(TreeNode node) {
     TreeNode parent = node.getParent();
     if (parent == null) {
       return null;
     }
     for (int i = 0; i < parent.getChildCount() - 1; i++) {
       if (parent.getChildAt(i) == node) { // == is okay in this case
         return parent.getChildAt(i + 1);
       }
     }
     return null;
   }
 
   @Override
   public int getRowCount() {
     return mapping.size();
   }
 
   public TreeNode getRowData() {
     return mapping.get(rowIndex).getNode();
   }
 
   @Override
   public int getRowIndex() {
     return rowIndex;
   }
 
   @Override
   public int getLevel() {
     int count = -1;
     for (TreeNode node = getRowData(); node != null; node = node.getParent()) {
       count++;
     }
     return count;
   }
 
   @Override
   public TreePath getPath() {
     return new TreePath(getRowData());
   }
 
   @Override
   public boolean isFolder() {
     return !getRowData().isLeaf();
   }
 
   @Override
   public Object getWrappedData() {
     return data;
   }
 
   @Override
   public boolean isRowAvailable() {
     return 0 <= rowIndex && rowIndex < getRowCount();
   }
 
   @Override
   public void setRowIndex(int rowIndex) {
     this.rowIndex = rowIndex;
   }
 
   @Override
   public void setWrappedData(Object data) {
     this.data = (TreeNode) data;
   }
 
   @Override
   public boolean isRowVisible() {
     if (!isRowAvailable()) {
       return false;
     }
     final TreeNode start = getRowData();
     if (start.getParent() == null) {
       return showRoot;
     }
     TreeNode node = start.getParent();
     while (node != null) {
       final Data data = mapping.get(back.get(node));
       if (data.getNode().getParent() == null && !showRoot) {
         return true;
       }
       if (!expandedState.isExpanded(new TreePath(node))) {
         return false;
       }
       node = node.getParent();
     }
     return true;
   }
 
   public String getRowClientId() {
     if (isRowAvailable()) {
       return mapping.get(rowIndex).getClientId();
     } else {
       return null;
     }
   }
 
   public void setRowClientId(String clientId) {
     if (isRowAvailable()) {
       mapping.get(rowIndex).setClientId(clientId);
     } else {
       LOG.warn("No row index set: clientId='" + clientId + "'");
     }
   }
 
   public String getRowParentClientId() {
     if (isRowAvailable()) {
       final TreeNode parent = mapping.get(rowIndex).getNode().getParent();
       if (parent != null) {
         return mapping.get(back.get(parent)).getClientId();
       } else {
         return null;
       }
     } else {
       return null;
     }
   }
 
   public List<Integer> getRowIndicesOfChildren() {
     final TreeNode node = getRowData();
     final int n = node.getChildCount();
     final List<Integer> children = new ArrayList<Integer>(n);
     for (int i = 0; i < n; i++) {
       final Integer integer = back.get(node.getChildAt(i));
       if (integer != null) { // integer == null happens, when the node is not expanded
         children.add(integer); // XXX is this a good way to handle that case?
       }
     }
     return children;
   }
 
   @Override
   public List<Boolean> getJunctions() {
     TreeNode node = getRowData();
     final List<Boolean> junctions = new Stack<Boolean>();
     while (node != null) {
       junctions.add(hasNextSibling(node));
       node = node.getParent();
     }
     Collections.reverse(junctions);
     return junctions;
   }
 
   private boolean hasNextSibling(TreeNode node) {
     final TreeNode parent = node.getParent();
     return parent != null && parent.getChildAt(parent.getChildCount() - 1) != node;
   }
 
   /**
    * Here we cache some state information of the nodes, because we can't access the UITreeNode state of the other nodes
    * while rendering.
    */
   private static class Data {
 
     private TreeNode node;
     private String clientId;
 
     private Data(TreeNode node) {
       this.node = node;
     }
 
     public TreeNode getNode() {
       return node;
     }
 
     public String getClientId() {
       return clientId;
     }
 
     public void setClientId(String clientId) {
       this.clientId = clientId;
     }
   }
 }