/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun
 * Microsystems, Inc. All Rights Reserved.
 */
package org.netbeans.tax;

import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.LinkedList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
//import java.beans.PropertyChangeListener;
//import java.beans.PropertyChangeEvent;

/**
 *
 * @author  Libor Kramolis
 * @version 0.1
 */
public class TreeNamedObjectMap extends TreeObjectList {
    
    /** */
    private Map map;  // index to underlaying list -- lazy initialized by getMap()
    
    /** */
    private KeyListener keyListener; // lazy initialized by getKeyListener()
    
    
    //
    // init
    //
    
    /**
     * Creates new TreeNamedObjectMap.
     */
    protected TreeNamedObjectMap (ContentManager contentManager) {
        super (contentManager);
        
        this.map         = null;
        this.keyListener = null;
    }
    
    /** Creates new TreeNamedObjectMap -- copy constructor. */
    protected TreeNamedObjectMap (TreeNamedObjectMap namedObjectMap) {
        super (namedObjectMap);
    }
    
    
    //
    // itself
    //
    
    
    /**
     */
    private KeyListener getKeyListener () {
        if ( this.keyListener == null ) {
            this.keyListener = new KeyListener ();
        }
        return keyListener;
    }
    
    
    //
    // Map
    //
    
    /**
     */
    private Map getMap () {
        if ( this.map == null ) {
            this.map = new HashMap (3);
        }
        return map;
    }
    
    /**
     */
    private void mapClear () {
        Iterator it = getMap ().values ().iterator ();
        while (it.hasNext ()) {
            NamedObject namedObject = (NamedObject)it.next ();
            namedObject.setKeyListener (null);
            //            namedObject.removePropertyChangeListener (namedObject.mapKeyPropertyName(), getKeyListener());
        }
        getMap ().clear ();
    }
    
    /**
     */
    private Object mapPut (NamedObject namedObject) {
        Object obj = getMap ().put (namedObject.mapKey (), namedObject);
        namedObject.setKeyListener (getKeyListener ());
        //        namedObject.addPropertyChangeListener (namedObject.mapKeyPropertyName(), getKeyListener());
        
        return obj;
    }
    
    /**
     */
    private Object mapRemove (NamedObject namedObject) {
        Object obj = getMap ().remove (namedObject.mapKey ());
        namedObject.setKeyListener (null);
        //        namedObject.removePropertyChangeListener (namedObject.mapKeyPropertyName(), getKeyListener());
        
        return obj;
    }
    
    
    //
    // from TreeObject
    //
    
    /**
     */
    public Object clone () {
        return new TreeNamedObjectMap (this);
    }
    
    /**
     */
    public boolean equals (Object object, boolean deep) {
        if (!!! super.equals (object, deep))
            return false;
        
        TreeNamedObjectMap peer = (TreeNamedObjectMap) object;
        
        if ( this.getMap ().size () != peer.getMap ().size () )
            return false;
        
        Iterator thisIt = this.getMap ().keySet ().iterator ();
        Iterator peerIt = peer.getMap ().keySet ().iterator ();
        while ( thisIt.hasNext () ) {
            Object thisNext = thisIt.next ();
            Object peerNext = peerIt.next ();
            if (!!! Util.equals (thisNext, peerNext))
                return false;
            if (!!! Util.equals (this.getMap ().get (thisNext), peer.getMap ().get (peerNext)))
                return false;
        }
        
        return true;
    }
    
    /*
     * Update index to underlaying list.
     * @see #findMergeCandidate
     */
    public void merge (TreeObject treeObject) throws CannotMergeException {
        mapClear ();
        
        super.merge (treeObject);
    }
    
    /*
     * Suitable is a member with equalent mapKey.
     */
    protected int findMergeCandidate (final TreeObject original, final TreeObject[] candidates) {
        if ((original instanceof NamedObject) == false)
            return -1;
        
        for (int i = 0; i