package hep.aida.ref.plotter;

import hep.aida.IBaseStyle;
import java.lang.ref.WeakReference;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
    
public abstract class BaseStyle  extends WeakStyleListener implements IBaseStyle {
    private Hashtable internalParameterHash = new Hashtable();
    private Hashtable parameterHash = new Hashtable();
        
    private Hashtable baseStyles = new Hashtable();
    
    private List parentList = new ArrayList();

    private String name = "plotter";
    
    /**
     * Create a BaseStyle without a parent.
     * The parent, if ever available, can be set via the setParent method.
     *
     */
    protected BaseStyle () {
        super();
        initializeBaseStyle();
        addParameter( new BooleanStyleParameter(Style.IS_VISIBLE, true) );
    }
    
    /**
     * Create a clone of a BaseStyle.
     * @param style The BaseStyle to be cloned.
     *
     */
    protected BaseStyle ( BaseStyle style ) {
        this();
        copyStyle( this, style );
       
        List pl = style.parentList();
        this.setParentList(pl);
     }
    
    private void copyStyle( BaseStyle newStyle, BaseStyle oldStyle ) {
        Collection pars = oldStyle.parameters();
        Iterator iter = pars.iterator();
        while( iter.hasNext() ) {
            AbstractStyleParameter oldPar = (AbstractStyleParameter) iter.next();
            String[] av = oldPar.allowedValues();
            
            if ( ! oldPar.isParameterValueSet() ) 
                newStyle.setParameter(oldPar.name());
            else 
                newStyle.setParameter( oldPar.name(), oldPar.parameterValue(), av);
        }
        String[] names = newStyle.baseStyleNames();
        for ( int i = 0; i < names.length; i++ )
            copyStyle( newStyle.baseStyle( names[i] ), oldStyle.baseStyle( names[i] ) );
    }

    /**
     * Initialize the BaseStyle.
     * This method has to be overwritten by all Style that has to add parameters or
     * internal BaseStyles.
     *
     */
    protected abstract void initializeBaseStyle();
    
    
    /**
     * Set the name of this BaseStyle.
     * @param name The name.
     *
     */
    protected void setName( String name )  {
        this.name = name;
    }
    
    /**
     * Get the name of this BaseStyle.
     * @return The name of the BaseStyle.
     *
     */
    public String name() {
        return name;
    }
    
    /**
     * @return The type of the style.
     */
    public Class type() {
        return this.getClass().getInterfaces()[0];
    }
        
    /**
     * @return A sub style, knowing its name.
     */
    public IBaseStyle child(String name) {
        return (IBaseStyle) baseStyles.get( name );
    }
    
    /**
     * @return The array of sub styles.
     */
    public IBaseStyle[] children() {
        IBaseStyle[] children = new IBaseStyle[baseStyles.size()];
        Set keys = baseStyles.keySet();
        Iterator i = keys.iterator();
        int count = 0;
        while( i.hasNext() )
            children[count++] = (IBaseStyle) baseStyles.get(i.next());
        return children;
    }
    
    /**
     * Set isVisible of the data.
     */
    public boolean setVisible(boolean visible) {
        return setParameter(Style.IS_VISIBLE, String.valueOf(visible) );
    }
    
    /**
     * Get isVisible of the data.
     * return The isVisible of the data.
     */
    public boolean isVisible() {
        String isVisible = parameterValue(Style.IS_VISIBLE);
        return Boolean.valueOf(isVisible).booleanValue();
    }
    
    /**
     * Set the parent for this BaseStyle.
     * @param style The parent for this BaseStyle.
     *
     */
    public void setParent( IBaseStyle style ) {
        if (style == null) return;
        ArrayList list = new ArrayList(1);
        list.add(style);
        setParentList(list);
    }
    
    /**
     * First remove current parents (if present), then add new parents
     * from the list. If list == null || list.size() == 0, 
     * just remove current parents.
     */
    public void setParentList( List list ) {
        if (parentList != null && parentList.size() > 0) {
            int size = parentList.size();
            Object[] tmpArray = parentList.toArray();            
            for (int i=0; i 0) {
            for (int i=0; isetParentList(null)
     */
    public void removeParent( IBaseStyle style ) {
        removeParent(style, true);
    }    
    void removeParent( IBaseStyle style, boolean sendNotification ) {
        if (style instanceof BaseStyle)
            ((BaseStyle) style).removeStyleListener(this);
        if (!isMyParent(style)) return;
        parentList.remove(style);
        
        // remove parent children recursively
        IBaseStyle[] parentChildren = style.children();
        for (int i=0; i