package lawyer;

import java.awt.*;
import java.util.*;

/**
 * <p>This class creates and maintains the Panel for the display of the brief
 * for the lesson.  Once a BriefPanel has been created and added to a 
 * Container, you simply use <code>displayPage(int page)</code> to do all of 
 * the painting.</p>
 *
 * @author  David Danks
 * @version 1.0; July 24, 1998
 * @see	LessonManager
 */
public class BriefPanel extends Panel {

    /** @serial */
    protected String[][] text;

    /** @serial */
    protected String[][][] options;

    /** @serial */
    protected int width;

    /** @serial */
    protected int height;

    /** @serial */
    protected int MARGIN = 20;

    /** @serial */
    protected int INSET = 5;

    /** @serial */
    protected Checkbox[] opts;

    /** @serial */
    protected FontMetrics fm;

    /** @serial */
    protected int TOP = 35;

    /** @serial */
    protected int current;

/**
 * This constructor does all of the text wrapping for the given height and
 * width, and sets up the constant display characteristics.
 *
 * @param   text    An array of arrays of Strings to be displayed, in the form
 *		    String[page_of_text][line_of_text].
 * @param   options A three-dimensional array of Strings for the options, in 
 *		    the form String[page_of_options][choice][line_of_choice].
 *		    The choices should begin at index 1.
 * @param   f	    The font in which the text should be displayed.
 * @param   maxWidth	The maximum available width for the Panel
 * @param   maxHeight	The maximum available height for the Panel
 */
    public BriefPanel(String[][] text, String[][][] options, Font f, 
	int maxWidth, int maxHeight) {
	setFont(f);
	fm = getFontMetrics(getFont());
	width = maxWidth;
	height = maxHeight;
	this.text = wrapText(text);
	this.options = wrapOptions(options);
	// now do the page setup
	setLayout(null);
	setBackground(Color.yellow);
    }
    
/**
 * Puts the checkboxes in the right place on the page, and then calls repaint
 * to add the lines and surrounding text.
 *
 * @param   page    The page number to be displayed (starting at 0)
 */
    public void displayPage(int page) {
	removeAll();
	current = page;
	CheckboxGroup cbg = new CheckboxGroup();
	opts = new Checkbox[options[page].length];
	int yOff = TOP + (text[page].length+1)*fm.getHeight();
	for (int i=0; i<opts.length; i++) {
	    opts[i] = new Checkbox(options[page][i][0], false, cbg);
	    opts[i].setBackground(Color.yellow);
	    add(opts[i]);
	    opts[i].setBounds(MARGIN+1, yOff,
		fm.stringWidth(options[page][i][0])+40, fm.getHeight()-3);
	    yOff += options[page][i].length*fm.getHeight();
	}
	repaint();
    }
    
/**
 * Draws the lines to simulate legal paper, and draws the (not on a Checkbox
 * line) text.
 */
    public void paint(Graphics g) {
	// draw the horizontal lines
	g.setColor(Color.blue);
	for (int i=TOP; i<height; i += fm.getHeight()) {
	    g.drawLine(0, i, width, i); }
	// draw the vertical lines
	g.setColor(Color.red);
	g.drawLine(MARGIN, 0, MARGIN, height);
	g.drawLine(MARGIN-2, 0, MARGIN-2, height);
	// draw the text
	g.setColor(Color.black);
	for (int i=0; i<text[current].length; i++) {
	    g.drawString(text[current][i], MARGIN+INSET,
		TOP+(i+1)*fm.getHeight()-1); }
	// and then draw the other options text
	int yOff = TOP+(text[current].length+1)*fm.getHeight();
	for (int i=0; i<options[current].length; i++) {
	    yOff += fm.getHeight();
	    for (int j=1; j<options[current][i].length; j++) {
		g.drawString(options[current][i][j], MARGIN+INSET,
		    yOff + fm.getHeight()-1);
		yOff += fm.getHeight();
	    }
	}
    }
    
/**
 * @return  The index of the selected Checkbox, if there is one; -1, otherwise.
 */
    public int getSelectedIndex() {
	for (int i=0; i<opts.length; i++) {
	    if (opts[i].getState()) return i+1; }
	return -1;
    }
    
/**
 * Wraps the text in the brief paragraphs to fit the Panel width.
 *
 * @param   src	The source text to be wrapped
 * @return	The wrapped text
 */
    private String[][] wrapText(String[][] src) {
	int length = width - MARGIN - 2*INSET;
	String[][] wrap = new String[src.length][100];
	// first wrap the strings
	for (int i=0; i<src.length; i++) {
	    int num = 0;
	    boolean firstOpen = true;
	    for (int j=0; j<src[i].length; j++) {
		StringTokenizer st = new StringTokenizer(src[i][j]);
		if (firstOpen) {
		    if (st.hasMoreTokens()) {
			wrap[i][num] = st.nextToken(); firstOpen = false; }
		    else continue; }		    
		if (src[i][j].equals("")) { 
		    num++; wrap[i][num] = ""; 
		    num++; firstOpen = true; }
		while (st.hasMoreTokens()) {
		    String next = st.nextToken();
		    if (fm.stringWidth(wrap[i][num]+" "+next) < length) {
			wrap[i][num] += " "+next; }
		    else { num++; wrap[i][num] = next; }
		}
	    }
	}
	// now pare down the array
	String[][] ret = new String[wrap.length][];
	for (int i=0; i<ret.length; i++) {
	    int j; for (j=0; j<wrap[i].length; j++) {
		if (wrap[i][j] == null) break; }
	    ret[i] = new String[j];
	    System.arraycopy(wrap[i], 0, ret[i], 0, j);
	}
	return ret;
    }
    
/**
 * Wraps the brief options to fit the Panel width.
 *
 * @param   src	The source options to be wrapped
 * @return	The wrapped options
 */
    private String[][][] wrapOptions(String[][][] src) {
	int length = width - MARGIN - 2*INSET;
	String[][][] wrap = new String[src.length][][];
	// first wrap the strings
	for (int p=0; p<src.length; p++) {
	    wrap[p] = new String[src[p].length-1][100];
	    for (int i=1; i<src[p].length; i++) {
		int num = 0;
		boolean firstOpen = true;
		for (int j=0; j<src[p][i].length; j++) {
		    StringTokenizer st = new StringTokenizer(src[p][i][j]);
		    if (firstOpen) {
			if (st.hasMoreTokens()) {
			    wrap[p][i-1][num] = st.nextToken(); 
			    firstOpen = false; }
			else continue; }
		    while (st.hasMoreTokens()) {
			String next = st.nextToken();
			if (fm.stringWidth(wrap[p][i-1][num]+" "+next) <
			    length) {
			    wrap[p][i-1][num] += " "+next; }
			else { num++; wrap[p][i-1][num] = next; } 
		    }
		}
	    }
	}
	// now pare down the array
	String[][][] ret = new String[wrap.length][][];
	for (int p=0; p<ret.length; p++) {
	    ret[p] = new String[wrap[p].length][];
	    for (int i=0; i<ret[p].length; i++) {
		int j; for (j=0; j<wrap[p][i].length; j++) {
		    if (wrap[p][i][j] == null) break; }
		ret[p][i] = new String[j];
		System.arraycopy(wrap[p][i], 0, ret[p][i], 0, j);
	    }
	}
	return ret;
    }
    
/**
 * @return  A Dimension object with the size it wants to have
 */
    public Dimension getPreferredSize() {
	return new Dimension(width+1, height+1); }
/**
 * @return  A Dimension object with the size it has to have
 */
    public Dimension getMinimumSize() {
	return new Dimension(width+1, height+1); }
	
}