package causation.lab;

// packages
import javax.swing.*;
import javax.swing.event.*;
import java.beans.*;

// custom classes
import causation.lab.WBVariableModelInterface;
import causation.lab.Randomizer;

/**
 * <p>
 * This is the underlying model for WBVariables.  It maintains information about:
 * <ol>
 * <li>The WBVariable name
 * <li>The possible WBVariable values
 * <li>Whether the WBVariable is locked
 * <li>What value the WBVariable is currently "set" to
 * <li>The Randomizer attached to the WBVariable
 * </ol>
 * </p><p>
 * The following <code>PropertyChangeEvent</code>s are fired by this class:
 * <ul>
 * <li>("locked", Boolean oldState, Boolean newState)
 * <ul><li>Values not always different</ul>
 * <li>("name", String oldName, String newName)
 *	<ul><li>Values not always different</ul>
 * <li>("allvalues", null, null)
 * <li>("value"+index, String oldValue, String newValue)
 *	<ul><li>Values not always different</li>
 * <li>("activevalue", String oldValue, String newValue)
 *	<ul><li>Values not always different</ul>
 * <li>("randomized", Boolean oldState, Boolean newState)
 * <ul><li>Values not always different</ul>
 * </ul>
 * </p><p>
 * NOTE: this class should really just be tetrad.model.Variable (pkg?).
 * That would make a lot of other pieces easier to code.  However, this
 * code was written before Tetrad IV was started, and so I had to write
 * my own WBVariableModel class.  Perhaps someday this code can be updated
 * to use tetrad.model.Variable.
 * </p><p>
 * Copyright 1999 by David Danks. All rights reserved.
 * </p>
 *
 * @see	WBVariable
 *	@see	WBVariableModelInterface
 * @version	0.9	Mar 2, 1999
 *	@author	David Danks
 */
public class WBVariableModel implements WBVariableModelInterface {

/////////////////// Instance Variables ///////////////////
	// does the work of firing PCEs for us
	protected EventListenerList listenerList = new EventListenerList();
	
	private boolean locked = false;
	private String name = "";
	private String[] values = null;
	private int activeIndex = -1;
	private Randomizer randomizer = null;

/////////////////// Constructors ///////////////////	
/** 
 * Null constructor.  Creates an unlocked WBVariableModel with blank name, 
 * one blank value, no active value, and no randomizer.
 */
	public WBVariableModel() {
		this("", new String[]{""}, null, false, null);
	}
/**
 * Creates an unlocked WBVariableModel with given name, one blank value, no 
 * active value, and no randomizer.
 * @param	name	The WBVariable name
 */
 	public WBVariableModel(String name) {
		this(name, new String[]{""}, null, false, null);
	}
/**
 * Creates an unlocked WBVariableModel with blank name, given values, no 
 * active value, and no randomizer.
 * @param	values	The possible WBVariable values
 */
	public WBVariableModel(String[] values) {
		this("", values, null, false, null);
	}
/**
 * Creates an unlocked WBVariableModel with given name and values, no active
 * value, and no randomizer.
 * @param	name		The WBVariable name
 * @param	values	The possible WBVariable values
 */
	public WBVariableModel(String name, String[] values) {
		this(name, values, null, false, null);
	}
/**
 * Creates an unlocked WBVariableModel with blank name, given values and 
 * active value, and no randomizer.
 * @param	values		The possible WBVariable values
 * @param	activeValue	The value the WBVariable is "set" to
 */
	public WBVariableModel(String[] values, String activeValue) {
		this("", values, activeValue, false, null);
	}
/**
 * Creates an unlocked WBVariableModel with given name, values, active value, and no
 * randomizer.
 * @param	name			The WBVariable name
 * @param	values		The possible WBVariable values
 * @param	activeValue	The value the WBVariable is "set" to
 */
	public WBVariableModel(String name, String[] values, String activeValue) {
		this(name, values, activeValue, false, null);
	}
/**
 * Creates an unlocked WBVariableModel with given name, values, randomizer, and no 
 * active value.
 * @param	name	The WBVariable name
 * @param	values	The possible WBVariable values
 * @param	randomizer	The associated Randomizer
 */
	public WBVariableModel(String name, String[] values, Randomizer randomizer) {
		this(name, values, null, false, randomizer);
	}
/**
 * Creates a WBVariableModel with given name, values, active value, lock 
 * state, and randomizer.  All other constructors call this one.
 * @param	name			The WBVariable name
 * @param	values		The possible WBVariable values
 * @param	activeValue	The value the WBVariable is "set" to
 * @param	locked		Whether the WBVariable is locked
 * @param	randomizer	The Randomizer associated with this WBVariable
 */
	public WBVariableModel(String name, String[] values, String activeValue,
		boolean locked, Randomizer randomizer) {
		this.name = name;
		this.values = values;
		this.locked = locked;
		this.randomizer = randomizer;
		int i; for (i=0; i<values.length; i++) {
			if (values[i].equals(activeValue)) break;
		}
		activeIndex = (i == values.length) ? -1 : i;
	}
	
/////////////////// Methods ///////////////////
/**
 * @return	Whether the WBVariable is locked
 */
	public boolean isLocked() { return locked; }
/**
 * @param	b	The new value of locked
 */
	public synchronized void setLocked(boolean b) {
		firePropertyChange("locked", new Boolean(locked), new Boolean(b));
		locked = b;
	}
/**
 * @return	Whether the WBVariable is randomized
 */
	public boolean isRandomized() { return (randomizer != null); }
/**
 * @return	The Randomizer associated with this WBVariable
 */
	public Randomizer getRandomizer() { return randomizer; }
/**
 * @param	The Randomizer to associate with this WBVariable, or <code>null</code>,
 * 		to remove the randomizer
 */
	public void setRandomizer(Randomizer newRandom) {
		Boolean old = new Boolean((randomizer != null));
		randomizer = newRandom;
		firePropertyChange("randomized", old, new Boolean((randomizer != null)));
	}
/**
 * @return	The WBVariable name
 */	
	public String getName() { return name; }
/**
 * @param	newName	The new name for the WBVariable
 */
	public synchronized void setName(String newName) {
		 if (newName == null)	// don't allow null; make it ""
			newName = "";
		firePropertyChange("name", name, newName);
		name = newName;
	}
/**
 * @return	The possible values for the WBVariable
 */
	public String[] getValues() { return values; }
/**
 * @param	index	The index of the desired value name
 * @return	The <code>index</code>-th possible value of the WBVariable
 */
	public String getValue(int index) { return values[index]; }
/**
 * @param	newValues	The new set of possible values for the WBVariable.
 */
	public synchronized void setValues(String[] newValues) {
		if (newValues == null)	// don't allow null; make it almost empty
			newValues = new String[]{""};
		for (int i=0; i<newValues.length; i++) {	// make sure no values are null
			if (newValues[i] == null) newValues[i] = "";
		}
		firePropertyChange("allvalues", null, null);
		values = newValues;
	}
/**
 * @param	newValue	The new String for the <code>index</code>-th value
 * @param	index		The index of the value to change
 */
	public synchronized void setValue(String newValue, int index) {
		// NOTE: we let the ArrayIndexOutOfBoundsException go through
		if (newValue == null)	// don't allow null; make it empty
			newValue = "";
		firePropertyChange("value"+index, values[index], newValue);
		values[index] = newValue;
	}
/**
 * @return	The current active value, if there is one, 
 *				<code>null</code>, otherwise.
 */
	public String getActiveValue() {
		if (activeIndex == -1) return null;
		else return values[activeIndex];
	}
/**
 * @return	The index of the current active value, if there is one, 
 *				<code>-1</code>, otherwise.
 */
	public int getActiveValueIndex() { return activeIndex; }
/**
 * @param	The new value for the active value (possibly <code>null</code>).
 */ 
	public synchronized void setActiveValue(String newValue) {
		if (newValue == null) {
			int oldIndex = activeIndex;
			activeIndex = -1;
			firePropertyChange("activevalue", values[oldIndex], null);
			return;
		}
		int i; for (i=0; i<values.length; i++) {
			if (newValue.equals(values[i])) break;
		}
		int oldIndex = activeIndex;
		activeIndex = (i == values.length) ? -1 : i;
		String oldVal = (oldIndex == -1) ? null : values[oldIndex];
		String newVal = (activeIndex == -1) ? null : values[activeIndex];
		firePropertyChange("activevalue", oldVal, newVal);
	}
/**
 * @param	l	The PropertChangeListener to add for this WBVariableModel
 */
	public void addPropertyChangeListener(PropertyChangeListener l) {
		listenerList.add(PropertyChangeListener.class, l);
	}
/**
 * @param	l	The PropertChangeListener to remove for this WBVariableModel
 */
	public void removePropertyChangeListener(PropertyChangeListener l) {
		listenerList.remove(PropertyChangeListener.class, l);
	}
/**
 * Send out a PropertyChangeEvent with the given parameters to all registered
 * PropertyChangeListeners
 * @param	propName	The name of the changed property
 * @param	oldVal	The old value of the changed property
 * @param	newVal	The new value of the changed property
 */
	protected void firePropertyChange(String propName, Object oldVal,
		Object newVal) {
		PropertyChangeEvent pce = new PropertyChangeEvent(this, propName,
			oldVal, newVal);
		Object[] listeners = listenerList.getListenerList();
		for (int i=listeners.length-2; i >=0; i -= 2) {
			if (listeners[i] == PropertyChangeListener.class) 
					((PropertyChangeListener)listeners[i+1]).propertyChange(pce);
		}
	}

/** 
 * @return	A String encoding the name, values, active value, and whether the
 * 			WBVariable is locked
 */
	public String toString() {
		String vals = "name="+name;
		for (int i=0; i<values.length; i++) {
			vals += ",values["+String.valueOf(i)+"]="+values[i];
		}
		vals += ",activeValue="+getActiveValue()+",locked="+String.valueOf(locked);
		return getClass().getName()+"["+vals+"]";
	}

}