/**
@author  Scott Marshall
@author  University of Glasgow, MSc IT Project 2001
@author  Building an OnLine Course in Computing Fundamentals
*/

package ukacgla_3inputKMap;

import ukacgla_KMap.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.TableColumn;
import javax.swing.table.AbstractTableModel;
import javax.swing.SwingUtilities;
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;

public class Ex05_Frame extends KMap_Frame {

	Ex05_Random rand;
	private int noOfRows;
	private	int noOfCols;
	
	public Ex05_Frame(JApplet m, int n, int o, String[] c){
		super(m, n, o, c);
		columnNames = c;
		this.noOfRows = n;
		this.noOfCols = o;
		noOfOptions = 5;			//number of checkboxes
		mkUI();
	
	}


	/**
	Builds a new table model, calculates the answers, and redraws the panel on the screen. 
	*/
	protected void newTable() {
		 table.setModel(model = new KMapTableModel(columnNames));
		 model.proofReadTable();
		 buildAnswers();
		 mkCheckBoxPanel();
	 }

	 /**
	 Builds the answers for the K Map. One will be correct, the rest will be incorrect. 
	 */
	protected void buildAnswers() {
		  Vector oneCells = new Vector();	//Cells in this vector will result in a one
		  Vector zeroCells = new Vector();	//Cells in this vector will result in a zero
		  answers = new Vector();			//will hold all 4 minterms generated
		  		 
			/**
			Find expressions and place into correct vectors.
			Will get the row headers for x, column headers for y and column footers for z
			*/
		  for (int a=1; a<noOfRows-1; a++)	{	//rows
		  	for (int b=1; b<noOfCols; b++)	{	//cols
		  		Integer temp = (Integer) data[a][b];
		  		if (temp.intValue()==0)	
		 			zeroCells.add(new Cell( (String) model.getValueAt(a,0) , (String) model.getValueAt(0,b),
		 									(String) model.getValueAt(noOfRows-1,b),(a-1),(b-1)   ));
		  									//need to subtract one to give index array position
		 		
		  		else
		 			oneCells.add( new Cell( (String) model.getValueAt(a,0) , (String) model.getValueAt(0,b),
		 									(String) model.getValueAt(noOfRows-1,b),(a-1),(b-1)   ));	
		 									//need to subtract one to give index array position
		 		
		  	}

		  }
		 	
		 //build the correct minterm from all the terms in the oneCells vector
		 Minterm correct = new Minterm("Correct",2,4);
		 Iterator correctIt = oneCells.iterator();
		 while (correctIt.hasNext()){
		 	correct.add((Cell) correctIt.next());
		 }
	 
		 answers.add(correct);

		 /*
		 Build 4 incorrect minterms, using this sequence of cells
		 Case 0 : Correct, Incorrect, Correct
		 Case 1 : Incorrect, Correct, Incorrect		
		 Case 2 : Incorrect, Correct		
		 Case 3 : Incorrect, Incorrect, Correct, Correct		
		 */
		 for(int i=0; i<4; i++)
		 {
		 	Minterm wrong = new Minterm("Incorrect",2,4);
		 	//each time after the first use, check that the index is within bounds of the Vector
		 	int correctIndex = 0;
		 	int wrongIndex = 0;
		 	Cell temp1, temp2, temp3, temp4;
		 	
		 	switch (i)	{
		 		case (0) :
		 			//1st correct answer this run 
		 			temp1 = (Cell) oneCells.get(correctIndex);
		 			correctIndex++;
		 			wrong.add(temp1);					
		 			
		 			//1st incorrect answer this run
		 			temp2 = (Cell) zeroCells.get(wrongIndex);
		 			wrongIndex++;
		 			wrong.add(temp2);
		 			
		 			//2nd correct answer this run
		 			if (correctIndex==oneCells.size())
		 				correctIndex=0;
		 			temp3 = (Cell) oneCells.get(correctIndex);
		 			wrong.add(temp3);	
		 			break;				


		 		case (1) :
		 			//1st incorrect answer  this run
		 			if (wrongIndex==zeroCells.size())
		 				wrongIndex=0;
		 			temp1 = (Cell) zeroCells.get(wrongIndex);
		 			wrongIndex++;
		 			wrong.add(temp1);					
		 			
		 			//1st correct answer  this run
		 			if (correctIndex==oneCells.size())
		 				correctIndex=0;
		 			temp2 = (Cell) oneCells.get(correctIndex);
		 			correctIndex++;
		 			wrong.add(temp2);					
		
		 			//2nd incorrect answer this run
		 			if (wrongIndex==zeroCells.size())
		 				wrongIndex=0;
		 			temp3 = (Cell) zeroCells.get(wrongIndex);
		 			wrong.add(temp3);					
		 			break;

		 		case (2) :
		 			//1st incorrect anser  this run
		 			if (wrongIndex==zeroCells.size())
		 				wrongIndex=0;
		 			temp1 = (Cell) zeroCells.get(wrongIndex);
		 			wrongIndex++;
		 			wrong.add(temp1);					
		 			
		 			//1st correct answer  this run
		 			if (correctIndex==oneCells.size())
		 				correctIndex=0;
		 			temp2 = (Cell) oneCells.get(correctIndex);
		 			correctIndex++;
		 			wrong.add(temp2);	
		 			break;				


		 		case (3) :
		 			//1st incorrect answer  this run
		 			if (wrongIndex==zeroCells.size())
		 				wrongIndex=0;
		 			temp1 = (Cell) zeroCells.get(wrongIndex);
		 			wrongIndex++;
		 			wrong.add(temp1);					
		 			
		 			//2nd incorrect answer this run
		 			if (wrongIndex==zeroCells.size())
		 				wrongIndex=0;
		 			temp2 = (Cell) zeroCells.get(wrongIndex);
		 			wrong.add(temp2);					

		 			//1st correct answer this run 
		 			temp3 = (Cell) oneCells.get(correctIndex);
		 			correctIndex++;
		 			wrong.add(temp3);					
		 			
		 			//2nd correct answer this run
		 			if (correctIndex==oneCells.size())
		 				correctIndex=0;
		 			temp4 = (Cell) oneCells.get(correctIndex);
		 			wrong.add(temp4);	
		 			break;				
		 		}
		 			
		 	//add minterm to Vector
		 	answers.add(wrong);
		 }
		 
		 
		 //simplify all terms in the vector
		 Minterm temp;
		 for(int j=0; j<answers.size(); j++){
		 	temp = (Minterm) answers.get(j);
		 	temp.simplify();
		 }
		 
		 //randomise the answers vector, using the method in the Ex05_Random class
		 answers = rand.randomise(answers);
		 
		 }//ends checkAnswers
		


	/**
	Builds the table to display the K Map, and the model to hold the data.
	After initial instantiation, the newTable() method should be called.
	The method builds a new table, proofreads for all 0's or 1's, then builds the Minterms. 
	*/
	protected JPanel mkTable() {

		table = new JTable(model = new KMapTableModel(columnNames));
		model.proofReadTable();			//ensures table will not be exclusively 0's or 1's.
		buildAnswers();					//builds vector containing the options to be displayed
		
	    table.setPreferredScrollableViewportSize(new Dimension(200, 70));
		table.setCellSelectionEnabled(false);

		TableColumn column = null;
		for (int i = 0; i < noOfCols; i++) {
		    column = table.getColumnModel().getColumn(i);
				column.setPreferredWidth(40);
				column.setResizable(false);
									
		}
	

	    //Create the scroll pane and add the table to it. 
	    JScrollPane scrollPane = new JScrollPane(table);
		JPanel temp = new JPanel();
		temp.add(scrollPane);
		return temp;
	 }


	 /**
	 Returns a JPanel containing the JCheckBox buttons.
	 The checkBox array is set using the contents of the answers Vector
	 */
	 protected JPanel mkButtonPanel(){
	 	JPanel temp = new JPanel(new GridLayout(noOfOptions,1,10,0));	
	 	checkBox = new JCheckBox[noOfOptions];
	 	listener = new cbListener();			
	
	 	for (int i = 0; i<noOfOptions; i++){
		 	JPanel tempPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
		 	tempPanel.add(Box.createRigidArea(new Dimension(20,0)));
		 	JLabel index = new JLabel("Option " + (i+1));
		 	tempPanel.add(index);

		 	Minterm minterm = (Minterm) answers.get(i);
		 	checkBox[i] = mkChkButton(tempPanel, minterm.getMinterm(), minterm.getCorrect() ,false);
		 	temp.add(tempPanel);
	 	}
	 	return temp;
	 }


	//-------------------------- INNER CLASSES----------------------------

	//-------------------------- TABLE MODEL -----------------------------


	protected class KMapTableModel extends MyTableModel {

		/**
		An array of random numbers is generated using the Ex05_Random object.
		This array is used to fill the 2D table model with 0's or 1's. 
		*/		
		public KMapTableModel(String[] c ){
			super(c);
			noOfRows = 4;
			noOfCols = 5;

			data = new Object[noOfRows][noOfCols];	//data for table model
			rand = new Ex05_Random(8);				//number of cells with random numbers needed

			//set titles
			data[0][0] = " ";			
			data[0][1] = "!y";
			data[0][2] = "y";	
			data[0][3] = "y";
			data[0][4] = "!y";				
			data[1][0] = "!x";
			data[2][0] = "x";
			data[3][0] = " ";			
			data[3][1] = "!z";
			data[3][2] = "!z";	
			data[3][3] = "z";
			data[3][4] = "z";				
			
					

			int count = 0;									//keeps track of position in random number array
			for (int a=1; a<noOfRows-1; a++)	{
				for (int b=1; b<noOfCols; b++)	{
					data[a][b] = new Integer(rand.getRandom(count));
					count++;
				}
			}

		}


		/**
		Ensures that the table will not be made exclusively of ones or zeros
		Check each cell in turn. Increment counter for each 0 or 1 found.
		Use no of rows-1 to avoid including the last row of titles.
		*/
		public void proofReadTable(){
	    	int ones = 0;
	    	int zero = 0;
	    	
			for (int a=1; a<noOfRows-1; a++)	{
	    		for (int b=1; b<noOfCols; b++)	{
	    			Integer temp = (Integer) data[a][b];
	    			if (temp.intValue()==0)
	    				zero++;
	    			else
	    				ones++;
	    		}
	    	}
	    	
	    	if (zero == 0){
	    		newTable();
			}				
	    	
	    	if (ones == 0){
	    		newTable();
	    	}				
	    	
	    }//ends proofReadTable
		
	}//ends KMapTableModel


	//-------------------------- CHECK BOX LISTENER-----------------------

		private class cbListener extends checkBoxListener{

	}//ends check Box Listener





}//ends class