/*
 * FuzzyLogicModel.java
 *
 * Created on August 1, 2002, 9:00 PM
 */

package uk.ac.leeds.ccg.projects.MedAction.FuzzyInference;

/**
 * a fuzzy logic model is a complete container or framework for fuzzy inference model
 * it contains fuzzy variables and rule model.
 * @author  jianhui jin
 */
import java.util.*;
import uk.ac.leeds.ccg.geotools.*;
import uk.ac.leeds.ccg.andyt.grids.*;
import uk.ac.leeds.ccg.projects.MedAction.NeuralNetwork.Utilities;
import java.io.*;

public class FuzzyLogicModel implements java.io.Serializable{
    // input variable
    private FuzzyVariable[] inputFuzzyVariable=null;
    // output variable
    private FuzzyVariable outFuzzyVariable=null;
    // rule model contains all the rules
    private FuzzyRuleModel fuzzyRuleModel=null;
    // input data file names corresponding to the input variable
    private String[] inputFileName=null;
    // output file name corresponding to the output varaible
    private String outFileName=null;
    // probably a temporaly variable vector
    private Vector variableVector=new Vector();
    // this model's name
    private String name="";
    //private GridDataReaderAndWriter gridDataReaderAndWriter;
    
    /** Creates a new instance of FuzzyLogicModel */
    public FuzzyLogicModel() {
    }
    
    /**
     * construct a model from loaded serielizable parameter object
     * @param obs
     */
    public FuzzyLogicModel(Object[] obs){
        Object[][] varObs=(Object[][]) obs[0];
        String[] ruleStrings=(String[]) obs[1];
        FuzzyVariable[] vars=new FuzzyVariable[varObs.length];
        for(int i=0;i<vars.length;i++){
            vars[i]=new FuzzyVariable(varObs[i]);
        }
        FuzzyRuleModel ruleModel = new FuzzyRuleModel(vars);
        ruleModel.setFuzzyRule(ruleStrings);
        this.setAllFuzzyVariable(vars);
        this.setFuzzyRuleModel(ruleModel);
    }
    
    /**
     *
     * @param allVariable all variables, the final on in this array is output variable
     * @param ruleModel rule model
     */
    public FuzzyLogicModel(FuzzyVariable[] allVariable, FuzzyRuleModel ruleModel) {
        this.setAllFuzzyVariable(allVariable);
        this.setFuzzyRuleModel(ruleModel);
    }
    
    /**
     *
     * @param inVariable input fuzzy variable
     * @param out output fuzzy variable
     * @param ruleModel
     */
    public FuzzyLogicModel(FuzzyVariable[] inVariable,FuzzyVariable out, FuzzyRuleModel ruleModel) {
        this.setInputFuzzyVariable(inVariable);
        this.setOutFuzzyVariable(out);
        this.setFuzzyRuleModel(ruleModel);
    }
    
    /**
     *
     * @param allVariable all fuzzy variable, the final one is output variable
     * @param ruleModel rule model
     * @param inputFileName input file names
     * @param outFileName output file names
     */
    public FuzzyLogicModel(FuzzyVariable[] allVariable, FuzzyRuleModel ruleModel,String[] inputFileName,String outFileName) {
        this.setAllFuzzyVariable(allVariable);
        this.setInputFileName(inputFileName);
        this.setOutFileName(outFileName);
        //this.setGridDataReaderAndWriter(new GridDataReaderAndWriter(inputFileName,outFileName,GridDataReaderAndWriter.WRITEOUTFILE));
    }
    
    /**
     *
     * @param allVariable all fuzzy variable, the final one is output variable
     * @param ruleModel fuzzy rule model
     * @param allFileName all data file name, the final one is output file name
     */
    public FuzzyLogicModel(FuzzyVariable[] allVariable, FuzzyRuleModel ruleModel,String[] allFileName) {
        this.setAllFuzzyVariable(allVariable);
        this.setAllFileName(allFileName);
        this.setFuzzyRuleModel(ruleModel);
        //this.setGridDataReaderAndWriter(new GridDataReaderAndWriter(allFileName,GridDataReaderAndWriter.WRITEOUTFILE));
    }
    /**
     *
     * @param inVariable
     * @param out
     * @param ruleModel
     * @param allFileName
     */
    public FuzzyLogicModel(FuzzyVariable[] inVariable,FuzzyVariable out, FuzzyRuleModel ruleModel,String[] allFileName) {
        new FuzzyLogicModel(inVariable,out,ruleModel);
        this.setAllFileName(allFileName);
        //this.setGridDataReaderAndWriter(new GridDataReaderAndWriter(allFileName,GridDataReaderAndWriter.WRITEOUTFILE));
    }
    
    /**
     *
     * @param inVariable
     * @param out
     * @param ruleModel
     * @param inputFileName
     * @param outFileName
     */
    public FuzzyLogicModel(FuzzyVariable[] inVariable,FuzzyVariable out, FuzzyRuleModel ruleModel,String[] inputFileName,String outFileName) {
        new FuzzyLogicModel(inVariable,out,ruleModel);
        this.setInputFileName(inputFileName);
        this.setOutFileName(outFileName);
        //this.setGridDataReaderAndWriter(new GridDataReaderAndWriter(inputFileName,outFileName,GridDataReaderAndWriter.WRITEOUTFILE));
    }
    
    /**
     *
     * @param fuzzyLogicModelName
     * @param inVariableName
     * @param outVariableName
     */
    public FuzzyLogicModel( String fuzzyLogicModelName, String[] inVariableName, String outVariableName ) {
        FuzzyVariable[] ins = new FuzzyVariable[ inVariableName.length ];
        FuzzyVariable out = new FuzzyVariable( outVariableName );
        for ( int i = 0; i < ins.length; i ++ ) {
            ins[ i ] = new FuzzyVariable( inVariableName[ i ] );
        }
        setInputFuzzyVariable( ins );
        setOutFuzzyVariable( out );
        setFuzzyRuleModel( new FuzzyRuleModel( ins, out ) );
        getFuzzyRuleModel().setName( fuzzyLogicModelName + "RuleModel" );
        setName( fuzzyLogicModelName );
    }
    
    /**
     * model name
     * @param name
     */
    public void setName(String name){
        this.name=name;
    }
    /**
     *
     * @return model name
     */
    public String getName(){
        return this.name;
    }
    
    /**
     *
     * @param in input files' names
     */
    public void setInputFileName(String[] in){
        inputFileName=new String[in.length];
        for(int i=0;i<in.length;i++) {
            inputFileName[i]=in[i];
        }
    }
    
    /**
     *
     * @param out output file name
     */
    public void setOutFileName(String out){
        outFileName=out;
    }
    
    
    /**
     *
     * @param all all files names, the final one is output file name
     */
    public void setAllFileName(String[] all){
        inputFileName=new String[all.length-1];
        for(int i=0;i<inputFileName.length;i++) {
            inputFileName[i]=all[i];
        }
        outFileName=all[all.length-1];
        // this.setGridDataReaderAndWriter(new GridDataReaderAndWriter(this.getAllFileName(),GridDataReaderAndWriter.WRITEOUTFILE));
    }
    
    
    /**
     *
     * @return all input data file names
     */
    public String[] getInputFileName(){
        return this.inputFileName;
    }
    
    
    /**
     *
     * @return output file name
     */
    public String getOutFileName(){
        return this.outFileName;
    }
    
    
    /**
     *
     * @return all file names, the final one is output file name
     */
    public String[] getAllFileName(){
        if(inputFileName==null||outFileName==null)
        {return null;}
        else{
            String[] all=new String[inputFileName.length+1];
            for(int i=0;i<inputFileName.length;i++) {
                all[i]=inputFileName[i];
            }
            all[all.length-1]=outFileName;
            return all;
        }
    }
    
    
    /**
     *
     * @param ruleModel rule model
     */
    public void setFuzzyRuleModel(FuzzyRuleModel ruleModel){
        this.fuzzyRuleModel=ruleModel;
    }
    
    /**
     *
     * @return fuzzy rule model
     */
    public FuzzyRuleModel getFuzzyRuleModel(){
        return this.fuzzyRuleModel;
    }
    
    /**
     *
     * @return all fuzzy variables, the final one is output fuzzy variables
     */
    public FuzzyVariable[] getAllFuzzyVariable(){
        if(inputFuzzyVariable==null||outFuzzyVariable==null)
        {return null;}
        else{
            FuzzyVariable[] all=new FuzzyVariable[inputFuzzyVariable.length+1];
            for(int i=0;i<inputFuzzyVariable.length;i++) {
                all[i]=inputFuzzyVariable[i];
            }
            all[all.length-1]=outFuzzyVariable;
            return all;
        }
    }
    
    /**
     *
     * @param all all fuzzy variables, the final one is output fuzzy variables
     */
    public void setAllFuzzyVariable(FuzzyVariable[] all){
        this.inputFuzzyVariable=new FuzzyVariable[all.length-1];
        for(int i=0;i<all.length-1;i++)
        {    this.inputFuzzyVariable[i]=all[i];}
        
        this.outFuzzyVariable=all[all.length-1];
        
    }
    /**
     *
     * @param out output variable
     */
    public void setOutFuzzyVariable(FuzzyVariable out){
        outFuzzyVariable=out;
    }
    /**
     *
     * @param inVariables input variables
     */
    public void setInputFuzzyVariable(FuzzyVariable[] inVariables){
        inputFuzzyVariable=new FuzzyVariable[inVariables.length];
        for(int i=0;i<inVariables.length;i++)
        {inputFuzzyVariable[i]=inVariables[i];}
    }
    
    /**
     *
     * @param fVariable add this variable in
     */
    public void setInputFuzzyVariable(FuzzyVariable fVariable){
        variableVector=new Vector();
        // assign all old variable to the new vector
        if(inputFuzzyVariable!=null){
            for(int i=0;i<inputFuzzyVariable.length;i++) {
                variableVector.add(inputFuzzyVariable[i]);
            }
        }
        // add new variable
        variableVector.add(fVariable);
        Object[] temp= variableVector.toArray();
        inputFuzzyVariable=new FuzzyVariable[temp.length];
        for(int i=0;i<temp.length;i++) {
            inputFuzzyVariable[i] = (FuzzyVariable) temp[i];
        }
    }
    
    // input one array data from all variable input files, to get one output.
    // run one set of inputs
    private double runWithOneData(double[] inputValue, double noDataValue, FuzzyRuleModel ruleModel, FuzzyVariable[] inVar, FuzzyVariable outVar){
        if( inputValue.length != inVar.length ) { return noDataValue; }
        boolean nodata = false;
        // check whether this array data are nodatavalue
        for( int i = 0; i < inputValue.length; i++ ) {
            if( inputValue[ i ] == noDataValue ) { nodata = true; break; }
        }
        // if it is not run model, otherwise assign nodata value to the fire array
        if( !nodata ) {
            FuzzificationResult[] inputFuzzificationResult = new FuzzificationResult[ inputValue.length ];
            // put it in each fuzzy variable and get the fuzzification result for each value from
            // their corresponding fuzzy varaible membership function.
            for( int i = 0; i < inputValue.length; i ++ ) {
                inputFuzzificationResult[ i ] = inVar[ i ].getFuzzificationResult( inputValue[ i ] );
            }
            // put fuzzification result into rulemodel to get fuzzy inference result which is
            // also a fuzzification result
            FuzzificationResult fuzzyInferenceResult = ruleModel.getFuzzyInferenceResult( inputFuzzificationResult );
            // defuzzification, get single fire value
            return ruleModel.defuzzify(fuzzyInferenceResult,outVar);
            
        }
        else{
            return noDataValue;
        }
        
    }
    
    /**
     * run this model by data for grids
     *
     * @param inputGrid 
     * @param tempGridFileDirectory
     * @throws Exception
     * @return
     */
    public AbstractGrid2DSquareCellDouble runFuzzyLogicModel( AbstractGrid2DSquareCellDouble[] inputGrid, String tempGridFileDirectory) throws Exception {
        if( ( this.getFuzzyRuleModel() == null ) || ( this.getAllFuzzyVariable()== null ) || ( inputGrid == null ) || ( inputGrid.length != this.getInputFuzzyVariable().length ) ) {
            
            throw new Exception( "Problem in possible variables or rule model or data missing. Or may be: " + "InputNumber in InputGrid is " + this.getInputFuzzyVariable().length + " but now inputis " + inputGrid.length );
        }
        
        Grid2DSquareCellDoubleFactory f;
        Grid2DSquareCellDoubleFileFactory ff;
        AbstractGrid2DSquareCellDouble fireGrid = null;
        int inputLength = inputGrid[0].getNcols() * inputGrid[0].getNrows();
//        Utilities u = new Utilities();
        // initialising an empty fireGrid with the same extent of the input Grids
        try{
            System.out.println( "trying to initialising fireGrid in memory..." );
            f = new Grid2DSquareCellDoubleFactory();
            fireGrid = f.createGrid2DSquareCellDouble( inputGrid[0] );
            System.out.println( "...done" );
        } catch ( java.lang.OutOfMemoryError e ) {
            System.out.println( e + " initialising fireGrid as file..." );
            ff = new Grid2DSquareCellDoubleFileFactory();
//            ff.setFile( u.makeTemporaryFile(  tempGridFileDirectory ) );
            fireGrid = ff.createGrid2DSquareCellDouble( inputGrid[0] );
            System.out.println( "...done" );
        }
        
        FuzzyRuleModel ruleModel=this.getFuzzyRuleModel();
        FuzzyVariable[] inVar=this.getInputFuzzyVariable();
        FuzzyVariable outVar=this.getOutputFuzzyVariable();
        
        double[] max = new double[inputGrid.length];
        double[] min = new double[inputGrid.length];
        double[] noDataValue = new double[inputGrid.length];
        
        for( int i = 0; i < inputGrid.length; i++ ){
            
            max[i] = inputGrid[i].getGridStatistics().getMax();
            min[i] = inputGrid[i].getGridStatistics().getMin();
            noDataValue[i] = inputGrid[i].getNoDataValue();
            
        }
        // put all the data in the loop and run model
        double[] inputValue = new double[ inputGrid.length ];
        for( int i = 0; i < inputLength; i ++ ) {
            
            for( int j = 0; j < inputGrid.length; j ++) {
                inputValue[ j ] = inputGrid[j].getCell( i );
                inputValue[ j ] = Utilities.getRerangedValue( inputValue[j] , max[j] , min[j] , noDataValue[j] );
            }
            
            fireGrid.setCell( i, runWithOneData( inputValue, noDataValue[0], ruleModel , inVar , outVar ) );
            
            if( i%10000 == 0 )System.out.println( i + 1 + " done, be patient please");
        }
        
        return fireGrid;
        
    }
    
    
    /**
     *
     * @throws Exception
     */
    public void runFuzzyLogicModel() throws Exception {
        if(this.getFuzzyRuleModel()==null||this.getAllFuzzyVariable()==null||this.getAllFileName()==null)
        { throw new Exception( "Problem in possible variables or rule model or data missing. " ); }
        FuzzyRuleModel ruleModel=this.getFuzzyRuleModel();
        FuzzyVariable[] inVar=this.getInputFuzzyVariable();
        FuzzyVariable outVar=this.getOutputFuzzyVariable();
        //GridDataReaderAndWriter readerAndWriter=this.getGridDataReaderAndWriter();
        String[] allInputFileName=this.getInputFileName();
        double[][] allDataIni=new double[allInputFileName.length][];
        // read one data file, get those parameters: number of column and rows to initialise the
        // fire array. and get the no data value
        AbstractGrid2DSquareCellDouble temp = new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( new File( allInputFileName[ 0 ] ) );
        double[] fire=new double[temp.getNcols()*temp.getNrows()];
        double noDataValue = temp.getNoDataValue();
        
        // read all the input data into array
        for(int i=0;i<allInputFileName.length;i++)
        {allDataIni[i] = this.readGridToArray(allInputFileName[i]);}
        // convert the array to another array for input into the model#
        // basically, covert the i and j in contrast;
        double[][] allDataForInput = new double[fire.length][allDataIni.length];
        for( int i = 0; i < fire.length; i ++ ) {
            for( int j = 0; j < allInputFileName.length; j ++ ) {
                allDataForInput[i][j]=allDataIni[j][i];
            }
        }
        // assign null to the older data array variable, so
        // it will loss the reference to the data array. the call
        // garbage collection. release memory
        allDataIni = null;
        System.gc();
        
        // put all the data in the loop and run model
        for( int i = 0; i < fire.length; i++ ) {
            // read data array from all grids in the same id.
            double[] inputValue = allDataForInput[ i ];
            fire[ i ] = this.runWithOneData( inputValue, noDataValue, ruleModel , inVar , outVar );
            if( i%10000 == 0 )System.out.println( i + 1 + " done, be patient please");
        }
        
        this.fireOut( fire, new File( this.getOutFileName() ) );
    }
    
    
    /**
     *
     * @param parent
     */
    public void runFuzzyLogicModel(java.awt.Container parent) {
        if(this.getFuzzyRuleModel()==null||this.getAllFuzzyVariable()==null||this.getAllFileName()==null)
        {javax.swing.JOptionPane.showMessageDialog(parent,"check whether variable or model or data is ready or ok");return;}
        FuzzyRuleModel ruleModel=this.getFuzzyRuleModel();
        FuzzyVariable[] inVar=this.getInputFuzzyVariable();
        FuzzyVariable outVar=this.getOutputFuzzyVariable();
        //GridDataReaderAndWriter readerAndWriter=this.getGridDataReaderAndWriter();
        String[] allInputFileName=this.getInputFileName();
        double[][] allDataIni=new double[allInputFileName.length][];
        // read one data file, get those parameters: number of column and rows to initialise the
        // fire array. and get the no data value
        AbstractGrid2DSquareCellDouble temp = new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( new File( allInputFileName[ 0 ] ) );
        double[] fire = new double[ temp.getNcols() * temp.getNrows() ];
        double noDataValue = temp.getNoDataValue();
        
        // read all the input data into array
        for ( int i = 0; i < allInputFileName.length; i ++ ) {
            allDataIni[ i ] = this.readGridToArray( allInputFileName[ i ] );
        }
        // convert the array to another array for input into the model#
        // basically, covert the i and j in contrast;
        double[][] allDataForInput = new double[fire.length][allDataIni.length];
        for(int i=0;i<fire.length;i++) {
            for(int j=0;j<allInputFileName.length;j++) {
                allDataForInput[i][j]=allDataIni[j][i];
            }
        }
        // assign null to the older data array variable, so
        // it will loss the reference to the data array. the call
        // garbage collection. release memory
        allDataIni = null;
        System.gc();
        
        // put all the data in the loop and run model
        for( int i = 0; i < fire.length; i++ ) {
            // read data array from all grids in the same id.
            double[] inputValue = allDataForInput[ i ];
            fire[ i ] = this.runWithOneData( inputValue, noDataValue, ruleModel , inVar , outVar );
            if( i%10000 == 0 )System.out.println( i + 1 + " done, be patient please");
        }
        
        this.fireOut( fire, new File( this.getOutFileName() ) );
        
    }
    
    /**
     *
     * @return all input variables
     */
    public FuzzyVariable[] getInputFuzzyVariable() {
        return this.inputFuzzyVariable;
    }
    
    /**
     *
     * @return output variable
     */
    public FuzzyVariable getOutputFuzzyVariable(){
        return this.outFuzzyVariable;
    }
    
    /**
     * read a grid into a double[]
     * @param fileName 
     * @return
     */
    public static double[] readGridToArray(String fileName){
        AbstractGrid2DSquareCellDouble grid= new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( new File( fileName ) );
        int pixelNumber=grid.getNcols() * grid.getNrows();
        double[] temp=new double[pixelNumber];
        for(int i=0;i<pixelNumber;i++) {
            temp[i]=grid.getCell(i);
        }
        return temp;
    }
    // save out firs
    private void fireOut(double[] fire,File fireFile){
        String[] allFileName=this.getAllFileName();
        AbstractGrid2DSquareCellDouble grid= new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( new File( allFileName[ 0 ] ) );
        AbstractGrid2DSquareCellDouble fireGrid= new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( grid.getNrows(),grid.getNcols(),grid.getXllcorner(),grid.getYllcorner(),grid.getCellsize(),grid.getNoDataValue() );
        
        for(int i=0;i<fire.length;i++){
            fireGrid.setCell(i,fire[i]);
        }
        
        Grid2DSquareCellDoubleExchange.toAsciiFile( fireGrid, fireFile );
        
    }
    
    /**
     * to Object to be serielised and saved out
     * @return
     */
    public Object[] toObject(){
        FuzzyVariable[] vars = this.getAllFuzzyVariable();
        FuzzyRuleModel rm = this.getFuzzyRuleModel();
        Object[] ob=new Object[2];
        Object[][] variableObs=new Object[vars.length][];
        for(int i=0;i<vars.length;i++){
            variableObs[i] = vars[i].toObject();
        }
        ob[0] = variableObs;
        ob[1] = rm.toStringArray();
        return ob;
    }
    
    /**
     * to String, to a ascii file
     * @return
     */
    public String toString() {
        FuzzyVariable[] vars = getInputFuzzyVariable();
        String des = "The Model, " + getName() + ", has " + vars.length + " input variables and one output variables which are: /n/r";
        if ( vars == null || vars.length == 0 ) { return " the model is totally empty, shame on the guy made it."; }
        for ( int i = 0; i < vars.length - 1; i ++ ) {
            des = des + vars[ i ].toString();
        }
        des = des + "\n\r" + "The output variable is: \n\r"
        + vars[ vars.length - 1 ].toString() + "\n\r"
        + getFuzzyRuleModel().toString();
        return des;
    }
}