/* -------------------------------------------------------------------------- */
/*                                                                            */
/*                         ARM DATA GENERATOR MODEL                           */
/*                               Frans Coenen                                 */
/*                            Wednesday 6 May 2006                            */
/*                     Revissions: Tuesday 6 February 2007                    */
/*                                                                            */
/* -------------------------------------------------------------------------- */

/* ARM data generator GUI model for ARM experiments. */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.io.*;
import java.util.*;

public class GeneratorModel extends JFrame {

    /* ------ FIELDS ------ */

    // CONSTANTS
    /* None */

    // DATA STRUCTURES
    /** Density array. */
    private double[] densityArray = null;
    /** 2-D array to hold data. */
    private short[][] dataArray = null;
    /** 2-D arrau to hold temporary data. */
    private short[][] tempDataArray = null;

    // OTHER FIELDS
    /** Number of columns. */
    private int numberOfColumns = 0;
    /** Number of rows. */
    private int numberOfRows = 0;
    /** Density. */
    private int density = 0;
    /** Number of "1"s generated. */
    private int attributeCounter = 0;  
    /** Output directory file name. */
    private String outputDirectoryName = null;
    /** File stem fo r iamge file name. */
    private String fileStem = null;
    /** Output data file name. */
    private String outputFileName = null;
    /** Instance of PrintWriter class */
    private PrintWriter fileOutput;

    // SETTINGS
    /** 2-D Array of batch mode parameter values. <P>First dimension ordered as
    follows: (a) Number of columns, (b) Number of rows and (c) Density.
    Second dimension ordered as follows: (a) start, (b) end and
    (c) step. */
    private int[][] batchValues = {{100,101,10},{10000,10001,10},{5,50,5}};

    /* --------------------------------------------------- */
    /*                                                     */
    /*                    CONSTRUCTORS                     */
    /*                                                     */
    /* --------------------------------------------------- */

    /** Zero argument constructor. */

    public GeneratorModel() {
	}

    /* ---------------------------------------------- */
    /*                                                */
    /*                    METHODS                     */
    /*                                                */
    /* ---------------------------------------------- */

    /** Commences the process of generating the ARM data with a maximum of
    100 attempts to get the desired density.
    @param textArea instance of class JTextArea for output.         */

    public void generateData(JTextArea textArea) {
	double newDensity = 0.0;
	double tempDensity = 1000.0;
        double min = ((double) density) - 0.5;
	double max = ((double) density) + 0.5;
//System.out.println("min = " + min + ", max = " + max);

        // Commence generation (up to 10 goes).
	int index=0;
        for(;index<10;index++) {
	    // Dimension data array
	    dataArray = new short[numberOfRows][numberOfColumns];
	    // Create density array
	    setDensityArray();
	    // Set attribute counter (counts number of 1s)
	    attributeCounter=0;
	    // Generate a data set
	    newDensity = generateData2();
//System.out.println("(" + index + ") newDensity = " + newDensity);
	    // Test accuracy
	    if (newDensity>=min && newDensity<=max) {
//System.out.println("BREAK");
	        break;
	        }
            else {
                double diff1 = Math.abs(density-newDensity);
                double diff2 = Math.abs(density-tempDensity);
//System.out.println("diff1 = " + diff1 + ", diff2 = " + diff2);
                if (diff1<diff2) {
                    tempDataArray = dataArray;
                    tempDensity   = newDensity;
                    }
                }
            }

        // Check if end of loop was reached
        if (index==10) {
            dataArray  = tempDataArray;
            newDensity = tempDensity;
//System.out.println("Index = " + index + ", newDensity = " + newDensity);
            }

        // Output statistics
        textArea.append("Attributes = " + attributeCounter + ", Actual density = " +
                          (twoDecPlaces(newDensity)) + "%\n" + "Storage = " +
                                          (attributeCounter*4) + " Bytes\n");
	}

    /** Generates a data set.
    @return the actual density as opposed to the desired density (dhould be about
    the same).    */

    public double generateData2() {
        // Loop through rows
    	for(int rowIndex=0;rowIndex<dataArray.length;) {
            // Loop through columns
    	    for(int colIndex=0;colIndex<dataArray[rowIndex].length;colIndex++) {
	        dataArray[rowIndex][colIndex] = (short) getRandom(colIndex);
	    	}
	    if (checkRow(dataArray[rowIndex])) rowIndex++;
	    }

	// End
	double density = ((double) (attributeCounter*100)) /
                                      ((double) (numberOfColumns*numberOfRows));
        return(density);
	}

    /** Creates the density array */

    private void setDensityArray(){
        densityArray = new double[numberOfColumns];
	int random;

	// Loop through columns
        for (int index=0;index<numberOfColumns;index++) {
            random = (int) ((Math.random())*100);
	    if (density == 50) densityArray[index] = (double) random;
	    else {
	        if (density < 50) densityArray[index] =
                                        random*(density/50.0);
	        else densityArray[index] =
                          random + ((100.0-random)*(density-50.0)/50.0);
	        }
	    }
//outputDistribArray();
	}

    /* GENERATE RANDOM */

    /** Generates a randon number taking intio considferation the
    density array.
    @param colNumber the current column number.
    @returm the reultiong tandom number (0 or 1). */

    private int getRandom(int colNumber) {

	// Calculate number, start by generating a number between 0 & 99
	double ranNum = ((Math.random())*100);

	// Apply the column density to this number
	if (ranNum <= densityArray[colNumber]) {
	    attributeCounter++;
	    return(1);
	    }
	else return(0);
	}

    /* CHECK ROW */

    /** Checks if record contains at least one '1'.
    @return true if at least one `1' character and false otherwise. */

    private boolean checkRow(short[] row) {
        boolean rowOK = true;

        // Loop throufgh array looking for `1' character
        for(int index=0;index<row.length;index++) {
	    if (row[index] == 1) return(rowOK );
	    }

	// All zero array return false
	return(!rowOK );
	}

    /** Starts batch data generation process to produce a sequence of files.
    @param textArea instance of class JTextArea for output.         */

    public void generateBatchData(JTextArea textArea) {
        // Get directory name
        if (getDirectoryName(textArea)) {
            if (getFileStem(textArea)) generateBatchData2(textArea);
            }
        }

    /** Continues batch data generation process to produve a sequence of files.
    @param textArea instance of class JTextArea for output.         */

    public void generateBatchData2(JTextArea textArea) {
        int counter = 1;

        // Loop
        for (int numCols=batchValues[0][0];numCols<batchValues[0][1];
                                            numCols=numCols+batchValues[0][2]) {
            for (int numRows=batchValues[1][0];numRows<batchValues[1][1];
                                            numRows=numRows+batchValues[1][2]) {
                for (int densVal=batchValues[2][0];densVal<batchValues[2][1];
                                            densVal=densVal+batchValues[2][2]) {
                    // Set parameters
                    numberOfColumns = numCols;
                    numberOfRows    = numRows;
                    density         = densVal;
                    textArea.append("[" + counter + "] # columns = " +
                                numberOfColumns + ", # rows = " + numberOfRows +
                                              ", density = " + density + "%\n");
                    // Generate
                    generateData(textArea);
                    // File
                    saveARMdata(counter,textArea);
                    // Repeat
                    counter++;
                    }
                }
            }
        }

    /* --------------------------------------------------- */
    /*                                                     */
    /*                    FILE METHODS                     */
    /*                                                     */
    /* --------------------------------------------------- */

    /** Allows user to input a directory in which to store files generated in
    batch mode.
    @param textArea The instance of the JTextArea class required for output.
    @return true if obtained an appropriatye directory name, false otherwise. */

    private boolean getDirectoryName(JTextArea textArea) {
	// Display file dialog box
	JFileChooser fileChooser = new JFileChooser();
	fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
	int result = fileChooser.showOpenDialog(this);

	// If cancel button selected return
	if (result == JFileChooser.CANCEL_OPTION) return(false);

	// Obtain selected file
	File outputDir = fileChooser.getSelectedFile();
        outputDirectoryName = outputDir.getPath();

	// Dispaly error if invalid
        if (outputDir.isDirectory()) {
            textArea.append("Directory name =  " + outputDirectoryName + "\n");
            return(true);
            }
        else {
	    JOptionPane.showMessageDialog(this,"Error: " +
                        outputDirectoryName + " is an invalid Directory name",
		         "Invalid Directory name.",JOptionPane.ERROR_MESSAGE);
	    return(false);
	    }
	}

    /** Allows user to input the file stem for the image base.
    @param textArea The instance of the JTextArea class required for output.
    @return true if OK to proceed, false if input cancelled. */

    private boolean getFileStem(JTextArea textArea) {
        fileStem = JOptionPane.showInputDialog("Enter desired file stem:");
        if (fileStem == null) return(false);
	else {
            textArea.append("File stem = " + fileStem + "\n");
	    return(true);
	    }
	}

    /** Saves the data set to file store.
    @param number the current bumber of the data in the batch.
    @param textArea The instance of the JTextArea class required for output. */

    private void saveARMdata(int number, JTextArea textArea) {
        outputFileName = outputDirectoryName + "/" + fileStem + number +
                         ".N" + numberOfColumns + ".D" + numberOfRows + ".dat";

        if (openOutputFile()) {
	    try {
                outputToFile(textArea);
                // End by closing file
	        fileOutput.close();
		}
            catch (IOException ioException) {
	    	JOptionPane.showMessageDialog(this,"Error Writing to File",
			 "Error",JOptionPane.ERROR_MESSAGE);
                textArea.append("Operation cancelled!\n");
                }
            }
        }

    /* OUTPUT TO FILE */

    /** Writes generated ARM data to file.
    @param textArea The instance of the JTextArea class required for output. */

    private void outputToFile(JTextArea textArea) throws IOException {
        // Initial output
	textArea.append("File name = " + outputFileName + "\n");

        // Loop through rows
        for(int rowIndex=0;rowIndex<dataArray.length;rowIndex++) {
            // Loop through elements in row
            for(int colIndex=0;colIndex<dataArray[rowIndex].length;colIndex++) {
                if (dataArray[rowIndex][colIndex]==1) {
                    if (colIndex!=0) fileOutput.write(" ");
                    fileOutput.print(new Integer(colIndex+1).toString());
                    }
                }
            // End row
            fileOutput.write("\n");
            }
        }

    /* OPEN OUTPUT FILE */
    /** Opens the output file for the generated ARM data set .
    @return true if file succesfully opened, and false otherwise. */

    private boolean openOutputFile() {
        try {
	    fileOutput = new PrintWriter(new FileWriter(outputFileName));
	    return(true);
	    }
	catch(IOException ioException) {
	    JOptionPane.showMessageDialog(this,"Error opening File",
			 "Error",JOptionPane.ERROR_MESSAGE);
      	    return(false);
	    }
	}

    /* -------------------------------------------------- */
    /*                                                    */
    /*                    SET METHODS                     */
    /*                                                    */
    /* -------------------------------------------------- */

    /** Sets the value for the number of columns field.
    @param newNumCols the new value. */

    public void setNumCols(int newNumCols) {
        numberOfColumns = newNumCols;
        }

    /** Sets the value for the number of rows field.
    @param newNumRows the new value. */

    public void setNumRows(int newNumRows) {
        numberOfRows = newNumRows;
        }
    
    /** Sets the value for the density field.
    @param newNumRows the new value. */

    public void setDistrib(int newDistrib) {
        density = newDistrib;
        }        

    /** Set batch mode values with the given array of values.
    @param the given value array. */

    public void setBatchValues(int[][] valueList) {
        // Copy values
        for (int index1=0;index1<valueList.length;index1++) {  
            for (int index2=0;index2<valueList[index1].length;index2++) {
                batchValues[index1][index2] = valueList[index1][index2];
                }
            }
        }

    /* -------------------------------------------------- */
    /*                                                    */
    /*                    GET METHODS                     */
    /*                                                    */
    /* -------------------------------------------------- */

    /** Gets the value for the number of columns field.
    @return the value for the number of columns field. */

    public int getNumCols() {
        return(numberOfColumns);
        }

    /** Gets the value for the number of rows field.
    @return the value for the number of rows field. */

    public int getNumRows() {
        return(numberOfRows);
        }
    
    /** Gets the value for the density field.
    @return the value for the density field. */

    public int getDistrib() {
        return(density);
        }

    /** Gets the reference to the density array.
    @return the reference for the density array. */

    public double[] getDistribArrayRef() {
        return(densityArray);
        }

    /** Gets the reference to the ARM data array.
    @return the reference for the ARM data array. */

    public short[][] getARMdataRef() {
        return(dataArray);
        }              

    /** Gets the current batch mode values array.
    @return the requested value array. */
    public int[][] getBatchValues() {
        return(batchValues);
        }
        
    /* -------------------------------------------- */
    /*                                              */
    /*                     UTILITIES                */ 
    /*                                              */
    /* -------------------------------------------- */
    
    /** Converts decimal number to two decimal places.
    @param decNum the given decimal number.
    @return the decimal number to two dec places. */

    private double twoDecPlaces(double decNum) {
        int number       = (int) ((decNum*1000.0) + 0.5);

        // Return
        return(((double) number)/1000.0);
        }
    }