import javax.swing.*;
import javax.swing.table.*;
import javax.swing.JScrollPane;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.JOptionPane;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.net.*;
import java.lang.reflect.*;

public class RuleTable2 {
  private boolean DEBUG = true;
  JScrollPane scrollPane;
  private XKnowledgeBase kb;
  private RuleTableModel tableModel;
  private Vector data = new Vector();
  public JTable table;
  private JSplitPane panel;
  private JComboBox tf = new JComboBox();
  private JComboBox conditionBox = new JComboBox();
  private JComboBox typeBox = new JComboBox();

  private ParameterChoiceTable pct;

    public RuleTable2(String k) {
System.out.println("k:"+k);
    //create the table model
    tableModel = new RuleTableModel();

    //create a new JTable.
	if(k.equals("nullString")){
		//RuleBodyGet rbgg=new RuleBodyGet();
		String [][] rbg=new String [0][0];
		//int sze=rbgg.noRows;
		//rbg=rbgg.bodies;
		//int i=0;
		String [] cnames={"NOT", "Condition Type", "Condition"};
		table=new JTable(rbg, cnames);
	table.setPreferredScrollableViewportSize(new Dimension(50,70));
	table.setRowHeight(32);
	}
	else{ RuleBodyGet2 rbgg=new RuleBodyGet2(k);
		String [][] rbg=new String [rbgg.noRows][3];
		rbg=rbgg.bodies;
	int x=0;
	//System.out.println("noRows:"+rbgg.noRows);
	while(x<rbgg.noRows){
	//System.out.println("rbg:"+rbg[x][0]);
	//System.out.println("rbg:"+rbg[x][1]);
	//System.out.println("rbg:"+rbg[x][2]);
	x++;}
		int i=0;
		String [] cnames={"NOT", "Condition Type", "Condition"};
		table=new JTable(rbg, cnames);
	table.setPreferredScrollableViewportSize(new Dimension(50,70));
	table.setRowHeight(32);
	}
    
    //Create the scroll pane and add the table to it.
    scrollPane = new JScrollPane(table);
    String[] sp = {"property", "parameter", "complex"};
	setUpNegated(table.getColumnModel().getColumn(0));
    setUpTypeColumn(table.getColumnModel().getColumn(1), sp);
    setUpConditionColumn(table.getColumnModel().getColumn(2), sp);
    
    panel = new JSplitPane(JSplitPane.VERTICAL_SPLIT, scrollPane,
                           null);
  }

  /**
   *
   * Returns the panel containing the primary and secondary windows for defining parameters
   */
  public JSplitPane getSplitPane() {
    return panel;
  }


  /**
     * Adds a list of parameterChoices to a combobox.  User can either choose from the list, or write his own.
     */
    public void setUpConditionColumn(TableColumn conditionColumn,
                                     String[] conditions) {

      //Set up the editor for the condition cells.
      conditionBox.setEditable(true);

      for (int i = 0; i < conditions.length; i++) {

        conditionBox.addItem(conditions[i]);

      }

      conditionColumn.setCellEditor(new DefaultCellEditor(conditionBox));

      //Set up tool tips for the condition cells.
      DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
      renderer.setToolTipText(
          "Click to select a condition for the condition (e.g., property, parameter, etc).");
      conditionColumn.setCellRenderer(renderer);

      //Set up tool tip for the condition column header.
      TableCellRenderer headerRenderer = conditionColumn.getHeaderRenderer();
      if (headerRenderer instanceof DefaultTableCellRenderer) {
        ( (DefaultTableCellRenderer) headerRenderer).setToolTipText(
            "Click the condition to see a list of choices");
      }
    }



  /**
    * Add names of valid condition types to a combobox.
    */
   public void setUpTypeColumn(TableColumn typeColumn, String[] types) {
     //Set up the editor for the type cells.

     for (int i = 0; i < types.length; i++) {

       typeBox.addItem(types[i]);

     }

     typeColumn.setCellEditor(new DefaultCellEditor(typeBox));

     //Set up tool tips for the type cells.
     DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
     renderer.setToolTipText(
         "Click to select a type for the condition (e.g., property, parameter, etc).");
     typeColumn.setCellRenderer(renderer);

     //Set up tool tip for the type column header.
     TableCellRenderer headerRenderer = typeColumn.getHeaderRenderer();
     if (headerRenderer instanceof DefaultTableCellRenderer) {
       ( (DefaultTableCellRenderer) headerRenderer).setToolTipText(
           "Click the type to see a list of choices");
     }
   }
	public void setUpNegated(TableColumn cColumn){
		cColumn.setCellEditor(new DefaultCellEditor(tf));
		tf.setEditable(true);
		tf.addItem("true");
		tf.addItem("false");
		DefaultTableCellRenderer renderer=new DefaultTableCellRenderer();
		renderer.setToolTipText("Click to select a Boolean value for negated.");
		cColumn.setCellRenderer(renderer);
		TableCellRenderer headerRenderer=cColumn.getHeaderRenderer();
		if(headerRenderer instanceof DefaultTableCellRenderer){
			((DefaultTableCellRenderer) headerRenderer).setToolTipText("Click to see a list of choices");
		}
	}
   public void setTypes(String[] types) {

     for (int i = 0; i < types.length; i++) {

       typeBox.addItem(types[i]);

     }}


  /**
   * Return the ScrollPane containing the parameters Table
   *
   */
  public JScrollPane getScrollPane() {
    return scrollPane;
  }

  /**
   * Register an XKnowledgeBase with the table.
   * The data of the table will be The parameters Vector of KB
   */
  public void addKB(XKnowledgeBase k) {
    kb = k;
    // for debugging;

    Rule r = (Rule)k.rules.get(0);

    data = r.quick_conditions;

    // System.out.println(table.getRowHeight());
    table.setRowHeight(32);
  }

  /**
   * clears the table and adds the parameters from the KB to the table.
   */
  public void fillRows() {
   // tableModel.clear();
    //Vector v = kb.parameters;

    //for (int i = 0; i < v.size(); i++) {
    //  Parameter e = (Parameter) v.get(i);
     // tableModel.add(e);
   // }

  }

  /**
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   *
   */

  class RuleTableModel
      extends AbstractTableModel {
    final String[] columnNames = {
        "NOT",
        "Condition Type",
        "Condition"};

//    Icon bug = new ImageIcon("copy16.gif");

  //  public void add(Rule row) {
    //  data.add(row);
    //}

    /**
     * Deletes the contents of the table (and kb parameters!).
     */

    public void clear() {
      data.clear();
    }

    /**
     * Returns the number of columns in the table (in this case 5).
     */
    public int getColumnCount() {
      return columnNames.length;
    }

    /**
     * Returns the number of rows in the table.
     */
    public int getRowCount() {
      return data.size();
    }

    /**
     * Returns the name of a column at position col
     */
    public String getColumnName(int col) {
      return columnNames[col];
    }

    /**
     *
     public Object getValueAt(int row, int col) {
      Object[] o = (Object[])data.get(row);
      return o[col];
         }
     */
    public Object getValueAt(int row, int col) {

     Condition p = (Condition) data.get(row);
        String s = p.getBaseType();

      if (col == 0) {
        return new Boolean(p.negated);
      }
      if (col == 1) {
        return s;
      }
      if (col == 2) {

        if(s.equals("property")) return p.prop_name;
        if(s.equals("parameter")) return p.parm_name;
        if(s.equals("complex")) return p.complex_name;
      }


        return "ERROR!  The Column is out of bounds for the parameter Table!";

    }

    /*
     * JTable uses this method to determine the default renderer/
     * editor for each cell.  If we didn't implement this method,
     * then the last column would contain text ("true"/"false"),
     * rather than a check box.
     */
    public Class getColumnClass(int c) {
      return getValueAt(0, c).getClass();
    }

    /*
     * Don't need to implement this method unless your table's
     * editable.
     */
    public boolean isCellEditable(int row, int col) {
      //Note that the data/cell address is constant,
      //no matter where the cell appears onscreen.

      return true;
    }

    public void setValueAt(Object value, int row, int col) {

      Condition p = (Condition) data.get(row);
      String s = p.getBaseType();
      if (DEBUG) {
        System.out.println("Old value:  " + p);
      }

      if (col == 0) {
        Boolean b = (Boolean)value;
        p.negated = b.booleanValue();
      }
      if (col == 1) {
        p.setBaseType((String)value);
      }
      if (col == 2) {

        if(s.equals("property")) p.prop_name = (String) value;
        if(s.equals("parameter"))  p.parm_name= (String)value;
        if(s.equals("complex"))  p.complex_name= (String)value;

      }

      fireTableCellUpdated(row, col);
      /*
                   if (DEBUG) {
                       System.out.println("New value of data:");
                       printDebugData();
                   }
       */

      if (DEBUG) {

      }

    }

  }



  public static void main(String[] args) {

  }
}