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


package ukacgla_2inputKMap;

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

public class Ex02_Frame extends KMap_Frame {

	Ex02_Random rand;
	private int noOfRows;
	private	int noOfCols;

	public Ex02_Frame(JApplet m, int n, int o, String[] c){
		super(m, n, o, c);
		columnNames = c;
		this.noOfRows = n;
		this.noOfCols = o;
		noOfOptions = 4;			//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
		 Cell cell;
			 	 
		 //find expressions and place into correct vectors
		 for (int a=1; a<noOfRows; 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),(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),(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
		Set up minterm as a 2x2 block, need to subtract one from both here
		*/
		Minterm correct = new Minterm("Correct",noOfRows-1,  noOfCols-1);
		Iterator correctIt = oneCells.iterator();
		while (correctIt.hasNext())
		{
			Cell tempCell = (Cell) correctIt.next();
			correct.add(tempCell);
		}
		
		answers.add(correct);

		//build 3 incorrect minterms, each of 3 cells
		for(int i=0; i<3; i++)
		{
			/**
			Set up minterm as a 2x2 block, need to subtract one from rows and cols  here
			*/
			Minterm wrong = new Minterm("Incorrect",noOfRows-1, noOfCols-1);
			
			//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;
			
			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;				
			
			}		
					
			//add minterm to Vector
			answers.add(wrong);
		}
		

		//simplify the first three terms in the vector, and trim() the 4th one
		Minterm temp;
		for(int j=0; j<answers.size(); j++){
			temp = (Minterm) answers.get(j);
			temp.simplify();					
		}
		temp = (Minterm) answers.get(3);
		temp.trim();
	
		//randomise the answers vector, using the method in the Ex02_Random class
		answers = rand.randomise(answers);
	
	}//ends buildAnswers

	

	/**
	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 Ex02_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 = 3;
			noOfCols = 3;

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

			data[0][0] = " ";			
			data[0][1] = "!y";
			data[0][2] = "y";			
			data[1][0] = "!x";
			data[2][0] = "x";		

			int count = 0;									//keeps track of position in random number array
			for (int a=1; a<noOfRows; 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.
		*/
		public  void proofReadTable(){
	    	int ones = 0;
	    	int zero = 0;
	    	
			for (int a=1; a<noOfRows; 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	

	}



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

		private class cbListener extends checkBoxListener{

	}//ends check Box Listener





}//ends class