package siuying.gm.app.gmailer4j.model;

import java.util.*;
import java.util.logging.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import siuying.gm.*;

/**
 * A tree model represent a tree that can cotains 3 views
 * represent "Standard Box", "Labels" and "Searches"
 * @author siuying
 * @version 0.1
 */
public class MailboxTreeModel implements TreeModel{
  private Logger logger = Logger.getAnonymousLogger();
  public static final String [] boxRoots = {
      "Mailbox",
      "Label",
      "Search"
  };
  public static final String[] STD_BOX_KEY = {"stdbox.inbox",
      "stdbox.starred",
      "stdbox.sent",
      "stdbox.all",
      "stdbox.spam",
      "stdbox.trash"};

  private ArrayList treeModelListeners = new ArrayList();

  private ArrayList[] nodes;
  public static final int LIST_STANDARD = 0;
  public static final int LIST_LABEL = 1;
  public static final int LIST_SEARCH = 2;
  private int currentRoot;

  public MailboxTreeModel() {
    currentRoot = 0;
    nodes = new ArrayList[3];

    for (int i=0; i<nodes.length; i++){
      nodes[i] = new ArrayList();
    }

    for (int i=0; i<GMConstants.BOX_NAMES.length; i++){
      BoxNode node = new BoxNode(GMConstants.BOX_NAMES[i], 0);
      nodes[LIST_STANDARD].add(node);
    }

  }

  /**
   * getRoot
   *
   * @return Object
   */
  public Object getRoot() {
    return boxRoots[currentRoot];
  }

  /**
   * getChildCount
   *
   * @param parent Object
   * @return int
   */
  public int getChildCount(Object parent) {
    if (boxRoots[LIST_STANDARD].equals(parent) ||
        boxRoots[LIST_LABEL].equals(parent) ||
        boxRoots[LIST_SEARCH].equals(parent) ){
      for (int i = 0; i < boxRoots.length; i++) {
        if (parent.equals(boxRoots[i]))
          return nodes[i].size();
      }
    }

    return 0;
  }

  /**
   * isLeaf
   *
   * @param node Object
   * @return boolean
   */
  public boolean isLeaf(Object node) {
    return false;
  }

  /**
   * addTreeModelListener
   *
   * @param l TreeModelListener
   */
  public void addTreeModelListener(TreeModelListener l) {
    treeModelListeners.add(l);
  }

  /**
   * removeTreeModelListener
   *
   * @param l TreeModelListener
   */
  public void removeTreeModelListener(TreeModelListener l) {
    treeModelListeners.remove(l);
  }


  /**
   * getChild
   *
   * @param parent Object
   * @param index int
   * @return Object
   */
  public Object getChild(Object parent, int index) {
    int parentidx = 0;

    if (boxRoots[LIST_STANDARD].equals(parent) ){
      parentidx = LIST_STANDARD;
    }else if (boxRoots[LIST_LABEL].equals(parent)){
      parentidx = LIST_LABEL;
    }else if (boxRoots[LIST_SEARCH].equals(parent)){
      parentidx = LIST_SEARCH;
    }else{
      return null;
    }
    return nodes[parentidx].get(index);
  }

  /**
   * getIndexOfChild
   *
   * @param parent Object
   * @param child Object
   * @return int
   */
  public int getIndexOfChild(Object parent, Object child) {
    int parentidx = 0;

    if (boxRoots[LIST_STANDARD].equals(parent) ){
      parentidx = LIST_STANDARD;
    }else if (boxRoots[LIST_LABEL].equals(parent)){
      parentidx = LIST_LABEL;
    }else if (boxRoots[LIST_SEARCH].equals(parent)){
      parentidx = LIST_SEARCH;
    }else{
      return -1;
    }

    if (nodes[parentidx].contains(child)){
      for(int i=0; i<nodes[parentidx].size(); i++){
        if (nodes[parentidx].get(i).equals(child))
          return i;
      }
    }

    return -1;
  }

  /**
   * valueForPathChanged
   *
   * @param path TreePath
   * @param newValue Object
   */
  public void valueForPathChanged(TreePath path, Object newValue) {
  }

  public int getCurrentRoot() {
    return currentRoot;
  }

  public void setCurrentRoot(int current) {
    int old = this.currentRoot;
    this.currentRoot = current;
    fireTreeStructureChanged(boxRoots[old]);
  }

  /**
   * Update standbox content from gminfo TreeMap
   * @param stdbox TreeMap
   * @todo assume no delete occurs, it will not remove disappeared nodes, this should be fixed
   */
  public void updateStdBox(TreeMap stdbox){
    boolean structurechanged = false;
    try{
      for (int i = 0; i < STD_BOX_KEY.length; i++) {
        String key = STD_BOX_KEY[i];

        // the numberic string store in gminfo
        String numberStr = (String) stdbox.get(key);

        BoxNode node = (BoxNode)nodes[LIST_STANDARD].get(i);

        if (node != null) {
          int number = 0;
          if (numberStr == null){
            number = 0;
          }else{
            number = Integer.parseInt(numberStr);
          }

          if (number != node.getNumber()) {
            node.setNumber(number);
            fireTreeNodesChanged(node);
          }

        } else if (numberStr != null) {
          logger.warning("Missing standard box data: " + key);
        } else {
          // add a missing node
          nodes[LIST_STANDARD].add(new BoxNode(GMConstants.BOX_NAMES[i], 0));
          structurechanged = true;
        }

      }

    }catch(ClassCastException e){
      logger.warning("Error while cast the incoming label, they are not mapping of String -> String" + e);
    }catch(NumberFormatException e){
      logger.warning("" + e);
    }

    if (structurechanged)
      fireTreeStructureChanged(boxRoots[LIST_STANDARD]);
  }

  /**
   * Update/add labels from the input labels data
   * @param labels TreeMap
   * @todo assume no delete occurs, it will not remove disappeared nodes, this should be fixed
   */
  public void updateLabel(TreeMap labels){
    boolean structurechanged = false;
    try{
      Set keySet = labels.keySet();

      for (Iterator iter = keySet.iterator(); iter.hasNext();) {
        int existedLabel = -1;
        String name = (String)iter.next();
        String numberStr = (String) labels.get(name);

        for (int i=0; i<nodes[LIST_LABEL].size(); i++){
          BoxNode node =(BoxNode)nodes[LIST_LABEL].get(i);
          if (node.getName().equals(name)){
            // the label is in the list
            existedLabel = i;
            break;
          }
        }

        if ( existedLabel > -1 ){
          BoxNode theNode = (BoxNode)nodes[LIST_LABEL].get(existedLabel);
          int number = Integer.parseInt(numberStr);
          if (theNode.getNumber() != number){
            theNode.setNumber(number);
            fireTreeNodesChanged(theNode);
          }
        }else{
          // label not existed
          nodes[LIST_LABEL].add(new BoxNode(name, Integer.parseInt(numberStr)));
          structurechanged = true;
        }
      }
    }catch(Exception e){
      logger.warning("Error while cast the incoming label, they are not mapping of String -> String");
    }

    if (structurechanged)
      fireTreeStructureChanged(boxRoots[LIST_LABEL]);
  }
  
  public void updateSearches(TreeMap searches){
    boolean structurechanged = false;
    try{
      Set keySet = searches.keySet();

      for (Iterator iter = keySet.iterator(); iter.hasNext();) {
        int existedSearch = -1;
        String name = (String)iter.next();
        Integer numberStr = (Integer) searches.get(name);

        for (int i=0; i<nodes[LIST_SEARCH].size(); i++){
          BoxNode node =(BoxNode)nodes[LIST_SEARCH].get(i);
          if (node.getName().equals(name)){
            // the search is in the list
            existedSearch = i;
            break;
          }
        }

        if ( existedSearch > -1 ){
          BoxNode theNode = (BoxNode)nodes[LIST_SEARCH].get(existedSearch);
          int number = numberStr.intValue();
          if (theNode.getNumber() != number){
            theNode.setNumber(number);
            fireTreeNodesChanged(theNode);
          }
        }else{
          // search not existed
          nodes[LIST_SEARCH].add( new BoxNode(name, numberStr.intValue()) );
          structurechanged = true;
        }
      }
    }catch(Exception e){
      logger.warning("Error while cast the incoming searches, they are not mapping of String -> String");
    }

    if (structurechanged)
      fireTreeStructureChanged(boxRoots[LIST_SEARCH]);
  }
  
  protected void fireTreeStructureChanged(Object root) {
      int len = treeModelListeners.size();
      TreeModelEvent e = new TreeModelEvent(this,
                                            new Object[] {root});
      for (int i = 0; i < len; i++) {
          ((TreeModelListener)treeModelListeners.get(i)).
                  treeStructureChanged(e);
      }
  }

  protected void fireTreeNodesInserted(Object root) {
      int len = treeModelListeners.size();
      TreeModelEvent e = new TreeModelEvent(this,
                                            new Object[] {root});
      for (int i = 0; i < len; i++) {
          ((TreeModelListener)treeModelListeners.get(i)).treeNodesInserted(e);
      }
  }

  protected void fireTreeNodesRemoved(Object root) {
      int len = treeModelListeners.size();
      TreeModelEvent e = new TreeModelEvent(this,
                                            new Object[] {root});
      for (int i = 0; i < len; i++) {
          ((TreeModelListener)treeModelListeners.get(i)).treeNodesRemoved(e);
      }
  }

  protected void fireTreeNodesChanged(Object root) {
      int len = treeModelListeners.size();
      TreeModelEvent e = new TreeModelEvent(this,
                                            new Object[] {root});
      for (int i = 0; i < len; i++) {
          ((TreeModelListener)treeModelListeners.get(i)).treeNodesChanged(e);
      }
  }

  public String toString(){
    return "Boxes: " + nodes[LIST_STANDARD].toString() +
        "; Labels" + nodes[LIST_LABEL].toString() +
        "; Searches " + nodes[LIST_SEARCH].toString();

  }

}