package causality;

// packages
import javax.swing.*;
import java.awt.*;
import java.util.*;

/**
 * <p>
 * This class is a JPanel that displays an instance of DSeparationFacts, along
 * with an (optional) Image.
 * </p><p>
 * Copyright 1999 by David Danks. All rights reserved.
 * </p>
 *
 * @see		DSeparationFacts
 * @version	1.0; Mar 20, 1999
 * @author	David Danks
 */

public class DSeparationPanel extends JPanel {

/////////////////// Class Variable ///////////////////
	private static final Font FONT = new Font("Serif", Font.PLAIN, 18);
	private static final int MARGIN = 10;
	private static final int LINE_WIDTH = 3;
	private static final int SPACE = 4;
	private static final int INSET = 4;	// constants for drawing the
	private static final int CENTER = 5;	// independence symbol
	private static final int BASE = 2*INSET+CENTER;
	private static final int DROP = 7;
	private static final String NO_FACTS_STRING = "No independencies.";
	private static final String NULL_IMAGE_STRING = "No image.";

/////////////////// Instance Variables ///////////////////
	private Image image;
	private DSeparationFacts dsf;
	private String[] facts;
//	private double scale = 1.0;

/**
 * Determines the d-separation facts for the given DiGraph.  Note: the
 * DSeparationPanel does not automatically pop up.
 * @param	dg	The DiGraph whose d-separation facts are requested
 * @param	im	An (optional) Image to display with the independencies
 */
	public DSeparationPanel(DiGraph dg, Image im) {
		this(new DSeparationFacts(dg), im);
	}

/**
 * Displays the given DSeparationFacts.  Note: the DSeparationPanel does not
 * automatically pop up.
 * @param	dsf	The DSeparationFacts to display
 * @param	im		An (optional) Image to display
 */
	public DSeparationPanel(DSeparationFacts dsf, Image im) {
		this.dsf = dsf;
		image = im;
		facts = dsf.getDSepFacts();
		setFont(FONT);
	}

/**
 * @return	The DSeparationFacts to be displayed
 */
	public DSeparationFacts getDSeparationFacts() { return dsf; }

/**
 * @return	The preferred size of the DSeparationPanel
 */
	public Dimension getPreferredSize() {
		FontMetrics fm = getFontMetrics(getFont());
		int width = 0;
		// space for line and gap around line (the line length is the panel width)
		int height = 3*LINE_WIDTH;
		// space for facts
		if (facts.length == 0) {
			height += fm.getHeight();
			width = Math.max(width, fm.stringWidth(NO_FACTS_STRING)+2*MARGIN);
		}
		else {
			height += (facts.length+1)*fm.getHeight();
			for (int i=0; i<facts.length; i++) {
// this isn't quite right, but...
			width = Math.max(width, 
				fm.stringWidth(facts[i])+2*MARGIN+2*BASE+2*SPACE);
			}
		}
		// space for image (do it in this order so we know how to scale)
		if (image == null) {
			height += fm.getHeight();
			width = Math.max(width, fm.stringWidth(NULL_IMAGE_STRING)+2*MARGIN);
		}
		else {
//			scale = (double)(((double)width-2*(double)MARGIN)/
//				(double)image.getWidth(this));
			width = Math.max(width, image.getWidth(this)+2*MARGIN);
			height += image.getHeight(this);
		}
		
		return new Dimension(width, height);
	}

/**
 * @return	The minimum size of the DSeparationPanel
 */
	public Dimension getMinimumSize() { return getPreferredSize(); }

/**
 * @return	<code>true</code> always, since the DSeparationPanel is opaque
	public boolean isOpaque() { return true; }
	
/**
 * Paints the entire DSeparationPanel: both the Image and the independencies.
 * @param	g	The Graphics context in which to paint the DSeparationPanel
 */
	public void paintComponent(Graphics g) { 
		FontMetrics fm = getFontMetrics(getFont());
		int xOff = 0;
		int yOff = 0;
/*
		// draw the background
		g.setColor(Color.white);
		g.drawRect(0, 0, getWidth()-1, getHeight()-1);
		g.setColor(Color.black);
*/		
		// draw the image (or null string)
		if (image != null) {
			g.drawImage(image, (getWidth()-image.getWidth(this))/2, 0, 
				image.getWidth(this), image.getHeight(this), this);
			yOff += image.getHeight(this);
		}
		else {
			g.drawString(NULL_IMAGE_STRING, MARGIN, yOff+fm.getHeight());
			yOff += fm.getHeight();
		}
		
		// draw the separating line
		yOff += LINE_WIDTH;
		for (int i=0; i<LINE_WIDTH; i++) {
			g.drawLine(0, yOff+i, getWidth(), yOff+i); }
		yOff += 2*LINE_WIDTH;
		
		// draw the facts (or null string)
		if (facts.length == 0) {
			g.drawString(NO_FACTS_STRING, MARGIN, yOff+fm.getAscent());
			return;
		}
		for (int i=0; i<facts.length; i++) {
			StringTokenizer st = new StringTokenizer(facts[i], "|");
			// first variable
			String token = st.nextToken();
			g.drawString(token, MARGIN, yOff+fm.getHeight());
			xOff = MARGIN+fm.stringWidth(token)+SPACE;
			// independence symbol
			g.drawLine(xOff, yOff+fm.getHeight(),		// draw base
				xOff+BASE, yOff+fm.getHeight());
			g.drawLine(xOff+INSET, yOff+DROP,			// and left line
				xOff+INSET, yOff+fm.getHeight());
			g.drawLine(xOff+INSET+CENTER, yOff+DROP,	// and right line
				xOff+INSET+CENTER, yOff+fm.getHeight());
			xOff += BASE+SPACE;
			// second variable
			token = st.nextToken();
			g.drawString(token, xOff, yOff+fm.getHeight());
			xOff += fm.stringWidth(token)+SPACE;
			// conditioning set, if there is one
			if (st.hasMoreTokens()) {
				token = st.nextToken();
				StringTokenizer con = new StringTokenizer(token, ",");
				token = "| ";
				while (con.hasMoreTokens()) token += con.nextToken()+", ";
				token = token.substring(0, token.length()-2);
				g.drawString(token, xOff, yOff+fm.getHeight());
			}
			yOff += fm.getHeight();
		}
	}
	
/**
 * This method filters the DSeparationFacts to ensure that only those 
 * variables in the filter are displayed.  If the filter is set to
 * <code>null</code>, then all of the DSeparationFacts are displayed.
 *
 * @param	filter	The filter listing the variables to be shown
 * @return	An array of filtered d-separation facts
 */
	private String[] filterFacts(String[] filter) {
		String[] fullFacts = dsf.getDSepFacts();
		if (filter == null) return fullFacts;
		int numRemoved = 0;
		FACTS: for (int i=0; i<fullFacts.length; i++) {
			StringTokenizer st = new StringTokenizer(fullFacts[i], "|");
			// check the first variable
			String token = st.nextToken();
			int j; for (j=0; j<filter.length; j++) {
				if (token.equals(filter[j])) break;
			}
			if (j == filter.length) {
				fullFacts[i] = null;
				numRemoved++;
				continue FACTS;
			}
			// check the second variable
			token = st.nextToken();
			for (j=0; j<filter.length; j++) {
				if (token.equals(filter[j])) break;
			}
			if (j == filter.length) {
				fullFacts[i] = null;
				numRemoved++;
				continue FACTS;
			}
			// if there are conditioners, check each of them
			if (st.hasMoreTokens()) {
				token = st.nextToken();
				StringTokenizer cond = new StringTokenizer(token, ",");
				while (cond.hasMoreTokens()) {
					token = cond.nextToken();
					for (j=0; j<filter.length; j++) {
						if (token.equals(filter[j])) break;
					}
					if (j == filter.length) {
						fullFacts[i] = null;
						numRemoved++;
						continue FACTS;
					}
				}
			}
		}
		// now create a new facts array (possibly of length 0)
		String[] filtered = new String[fullFacts.length-numRemoved];
		int filtIndex = 0;
		for (int i=0; i<fullFacts.length; i++) {
			if (fullFacts[i] != null) {
				filtered[filtIndex] = fullFacts[i];
				filtIndex++;
			}
		}
		return filtered;
	}
	
/**
 * This method (possibly) adds to the facts array.  Specifically, if 
 * X _||_ Y | Z, and all variables in Z are in locked, then it is also
 * true that X _||_ Y.
 *
 * @param	locked	The names of the locked variables
 */
	private void addLockFacts(String[] locked) {
		if (locked == null) return;
		if (locked.length == 0) return;
		Vector toAdd = new Vector();
		FACTS: for (int i=0; i<facts.length; i++) {
			StringTokenizer st = new StringTokenizer(facts[i], "|");
			String uncond = st.nextToken();
			uncond += "|"+st.nextToken()+"|";
			// if there are conditioners, check to see if all are locked
			if (st.hasMoreTokens()) {
				StringTokenizer cond = 
					new StringTokenizer(st.nextToken(), ",");
				while (cond.hasMoreTokens()) {
					String token = cond.nextToken();
					int j; for (j=0; j<locked.length; j++) {
						if (token.equals(locked[j])) break;
					}
					if (j == locked.length)	// unlocked conditioner
						continue FACTS;
				}
				// only gets here if all conditioners locked
				// check to see whether we already passed the unconditioned
				int j; for (j=0; j<i; j++)
					if (uncond.equals(facts[j])) continue FACTS;
				// if (j == i), then we haven't passed the unconditioned fact
				if (j == i) toAdd.addElement(uncond);
			}
			else {	// check if this unconditioned fact matches any toAdds 
				for (int j=toAdd.size()-1; j>=0; j--) {
					if (uncond.equals((String)toAdd.elementAt(j))) {
						toAdd.removeElementAt(j);
						continue FACTS;
					}
				}
			}
		}
		// if there aren't any facts to add, just return initialFacts
		if (toAdd.size() == 0) return;
		// now create a new facts array
		String[] added = new String[facts.length+toAdd.size()];
		System.arraycopy(facts, 0, added, 0, facts.length);
		for (int i=0; i<toAdd.size(); i++) {
			added[facts.length+i] = (String)toAdd.elementAt(i);
		}
		facts = added; added = null;
		return;
	}
	
/**
 * This allows us to set a filter that screens which variables from the
 * DSeparationFacts appear on the screen.
 *
 * @param	filter	The Strings that can appear on the screen
 */
	public void setFilter(String[] filter) {
		facts = filterFacts(filter);
		if (isShowing()) repaint();
	}
	
/**
 * This allows us to set which variables are locked, since this can affect
 * the DSeparation facts.  Specifically, if X _||_ Y | Z, and if all 
 * variables in Z are locked, then it is also true that X _||_ Y.
 *
 * @param	locked	The names of the locked variables
 */
	public void setLockedVariables(String[] locked) {
		addLockFacts(locked);
		if (isShowing()) repaint();
	}

/*
 * @return	A String representation of the DSeparationPanel
 *
	public String toString() {
		String ret = "";
		if (facts.length == 0) ret += "facts.length == 0; ";
		else ret += "facts != null; ";
		if (image == null) ret += "image == null";
		else ret += "image != null";
		return ret;
	}
*/
}