/*
 * FuzzyRuleModel.java
 *
 * Created on July 5, 2002, 8:43 PM
 */

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

/**
 * a rule model contain all the rules for a fuzzy logic model
 * but also have fuzzyvariables as members, but it is just a reference, when set 
 * fuzzy variables in, it won't create another copy of them, just a reference.
 *
 * the rule model's main job is to process fuzzification and defuzzification.
 *
 * @author  jianhui jin
 */
import java.util.*;
import uk.ac.leeds.ccg.geotools.*;
import java.io.Serializable;
public class FuzzyRuleModel implements Serializable{
    
    // defuzzified centroid, final result
    public static  GeoPoint defuzzifiedCentroid;
    // defuzzified polygons, for late computing final result
    public static GeoPolygon[] defuzzifiedPolygons;
    // for test
    private FuzzyRule[] fuzzyRules=null;
    private String[] outMemberName=null;
    private double[] outMemberDegree=null;
    private Vector ruleVector=new Vector();
    
    
    // 
    private FuzzificationResult fuzzyInferenceResult=null;
    // all input fuzzy variable
    private FuzzyVariable[] fuzzyVariables=null;
    // output variable
    private FuzzyVariable outVariable=null;
    // defined operator names
    public final String[] operatorName = {"AND","OR","OR NOT","AND NOT"};
    // this model's name
    private String name;
    
    /** Creates a new instance of FuzzyRuleModel */
    public FuzzyRuleModel(String name) {
        this.name = name;
    }
    
    /**
     *
     * @param ins input variables
     * @param out output variables
     */    
    public FuzzyRuleModel(FuzzyVariable[] ins, FuzzyVariable out) {
        this.fuzzyVariables=ins;
        this.outVariable=out;
        
    }
    
    /**
     * all variables, the final one is output variables
     * @param allVariable
     */    
    public FuzzyRuleModel(FuzzyVariable[] allVariable) {
        this.fuzzyVariables=new FuzzyVariable[allVariable.length-1];
        for(int i=0;i<this.fuzzyVariables.length;i++) {
            this.fuzzyVariables[i]=allVariable[i];
        }
        
        this.outVariable=allVariable[allVariable.length-1];
    }
    
    /**
     *
     * @param modelName this model's name
     * @param ins input variable
     * @param out output variable
     * @param ruleStrings all the rule strings @see setFuzzyRule(String[] ruleStrings)
     */    
    public FuzzyRuleModel(String modelName,FuzzyVariable[] ins, FuzzyVariable out,String[] ruleStrings) {
        this.setFuzzyVariable(ins);
        this.setOutVariable(out);
        this.setName(modelName);
        this.setFuzzyRule(ruleStrings);
        
    }
    
    /**
     * set all rule string, the string could get from FuzzyRule class
     * @param ruleStrings
     */    
    public void setFuzzyRule(String[] ruleStrings){
        if ( ( ruleStrings == null ) || ( ruleStrings.length == 0 ) ) { return; }
        FuzzyRule[] rules = new FuzzyRule[ ruleStrings.length ];
        
        for(int i=0;i<rules.length;i++){
            Vector memVec=new Vector();
            Vector varVec=new Vector();
            Vector opeVec=new Vector();
            String outMember=null;
            int confidence=1;
            
            StringTokenizer st=new StringTokenizer(ruleStrings[i]);
            String temp = st.nextToken(";");
            int count=0;
            while(st.hasMoreTokens()){
                temp = st.nextToken( ";" );
                switch ( count ) {
                    case 0 :
                        varVec.add( temp );
                        count = 1;
                        temp = st.nextToken( ";" );
                        break;
                    case 1 :
                        memVec.add( temp );
                        count=2;
                        break;
                    case 2 :
                        if ( !temp.equalsIgnoreCase("THEN") ) {
                            opeVec.add( temp );
                            count = 0;
                            break;
                        } else {
                            count=3;
                            break;
                        }
                    case 3 :
                        temp = st.nextToken( ";" );
                        outMember = temp ;
                        count=4;
                        break;
                    case 4 :
                        temp = st.nextToken( ";" );
                        confidence=Integer.parseInt(temp);
                        break;
                    
                    
                    
                }
            }
            /* if((temp=st.nextToken(";")).equalsIgnoreCase("THEN")){break;}
             else if(temp.equalsIgnoreCase("IS")){continue;}
             else if(count%3==0){
               varVec.add(temp);count++;
             }
             else if(count%3==1){
                 
                 memVec.add(temp);count++;
             }
             else if(count%3==2){

                 opeVec.add(temp);count++;
             }
             
           }
            
            
            outMember = temp; 
           
            temp=st.nextToken(";"); 
            //System.out.println(st.nextToken(";")); 
            //System.out.println(Integer.parseInt(st.nextToken(";"))); 
            String confi=st.nextToken(";");
            System.out.println(confi);
            confidence=Integer.parseInt(confi);
            */
            Object[] memOb=memVec.toArray();
            Object[] varOb=varVec.toArray();
            Object[] opeOb=opeVec.toArray();
            
            String[] memberName=new String[memOb.length];
            String[] variableName=new String[varOb.length];
            String[] operatorName=new String[opeOb.length];
            
            memberName[0]=(String) memOb[0];
            variableName[0]=(String) varOb[0];
            
            for(int j=1;j<memOb.length;j++){
            
                memberName[j]=(String) memOb[j];
                variableName[j]=(String) varOb[j];
                operatorName[j-1]=(String) opeOb[j-1];
                
            }
              
          rules[i]=new FuzzyRule(variableName,memberName,operatorName,outMember,confidence);
                   
        }
        
        this.setFuzzyRule(rules);
    }
    
    /**
     * 
     * @param out output variable
     */    
    public void setOutVariable(FuzzyVariable out){
        this.outVariable=out;
    }
    
    /**
     *
     * @return output variable
     */    
    public FuzzyVariable getOutVariable(){
        return outVariable;
    }
    
    /**
     *
     * @param f the fuzzification result for a set of input
     * @return a FuzzificationResult Object contain the fuzzy rule logic operation result
     */    
    public FuzzificationResult getFuzzyInferenceResult(FuzzificationResult[] f){
        Vector nameVector=new Vector();
        Vector degreeVector=new Vector();
        if(fuzzyRules==null)
            return null;
        else{
            // get confidence to multi copy of the same outMember and outMemberDegree
            for(int i=0;i<fuzzyRules.length;i++) {
                for(int j=0;j<fuzzyRules[i].getConfidence();j++) {
                    nameVector.add(fuzzyRules[i].getOutMember());
                    degreeVector.add(new Double(fuzzyRules[i].getOutMemberDegree(f)));
                }
            }
            
            
            
        }
        
        Object[][] temp = new Object[nameVector.toArray().length][2];
        for(int i=0;i<temp.length;i++) {
            temp[i][0]= nameVector.get(i);
            temp[i][1]= degreeVector.get(i);
            
        }
        
        fuzzyInferenceResult = new FuzzificationResult(temp,outVariable.getName());
        return fuzzyInferenceResult;
    }
    
    
    
    
    
    /**
     * add a rule
     * @param r rule to be added
     */    
    public void setFuzzyRule(FuzzyRule r){
        ruleVector.add(r);
        Object[] temp= ruleVector.toArray();
        fuzzyRules=new FuzzyRule[temp.length];
        for(int i=0;i<temp.length;i++) {
            fuzzyRules[i] = (FuzzyRule) temp[i];
        }
    }
    
    
    /**
     *
     * @param rules 
     */    
     public void setFuzzyRule( FuzzyRule[] rules ) {
        if ( rules == null ) { fuzzyRules = null; ruleVector = new Vector(); return; } 
        fuzzyRules = new FuzzyRule[ rules.length ];
        ruleVector = new Vector();
        for ( int i = 0; i < rules.length; i ++ ) {
            fuzzyRules[ i ] = rules[ i ];
            ruleVector.add( rules[ i ] );
        }
    }
    
     /**
      *
      * @return all fuzzy rules
      */     
    public FuzzyRule[] getFuzzyRule(){
        return fuzzyRules;
    }
    
    /**
     *
     * @return all fuzzy variables
     */    
    public FuzzyVariable[] getFuzzyVariable() {
        return fuzzyVariables;
    }
    /**
     *
     * @param ins input variables
     */    
    public void setFuzzyVariable(FuzzyVariable[] ins) {
        this.fuzzyVariables=ins;
    }
  
    
    /**
     * remove a rule from fuzzyRule[] using index 0 to fuzzyRule.length-1
     * @param index
     */    
    public void removeRule(int index) {
        FuzzyRule[] temp=new FuzzyRule[fuzzyRules.length-1];
        for(int i=0;i<index;i++)
            temp[i]=fuzzyRules[i];
        
        for(int i=index;i<temp.length;i++)
            temp[i]=fuzzyRules[i+1];
        
        ruleVector=new Vector();
        
        for(int i=0;i<temp.length;i++)
            ruleVector.add(temp[i]);
        
        fuzzyRules=temp;
        
    }
    
    /**
     * take fuzzy variables' names from a fuzzy variable array
     * @param fuzzyVariables
     * @return
     */    
    public static String[] getFuzzyVariableName(FuzzyVariable[] fuzzyVariables) {
        String[] temp=new String[fuzzyVariables.length];
        for(int i=0;i<temp.length;i++)
            temp[i]=fuzzyVariables[i].getName();
        return temp;
        
    }
    
    /**
     * defuzzification, the fuzzificationResult inputed is a fuzzy rule model
     * fuzzy logic operation result, each member fuzzy set in this result will 
     * have a fuzzy logic operation result. this method, will take each fuzzification 
     * resulted degree in fuzzificationResult out to construct a defuzzification polygon
     * and then get centroids, then get a total centroids, use polygons' areas
     * @param f fuzzy logic operation result
     * @param outVariable output varaible
     * @return defuzzification result final.
     */    
    public double defuzzify(FuzzificationResult f,FuzzyVariable outVariable){
        
        Vector polys = new Vector();
        FuzzificationResult out = f;
        String[] memberName = out.getMemberName();
        Double[] memberDegree = out.getMemberDegree();
        AbstractFuzzySet[] set = outVariable.getFuzzySet();
        GeoPoint[] centroids = null;
        double[] polysArea = null;
        for( int i = 0; i < memberName.length; i++ ) {
            for( int j = 0; j < set.length; j++ ) {
                
                if( set[ j ].getName().equalsIgnoreCase( memberName[i] ) ) {
                    polys.add( set[ j ].getDeFuzzificationPolygon( memberDegree[ i ].doubleValue() ) );
                    break;
                }
            }
            
        }
        
        Object[] temp = polys.toArray();
        defuzzifiedPolygons = new GeoPolygon[temp.length];
        centroids=new GeoPoint[temp.length];
        polysArea=new double[temp.length];
        
        for(int i=0;i<defuzzifiedPolygons.length;i++) {
            defuzzifiedPolygons[i]=(GeoPolygon) temp[i];
            centroids[i]=defuzzifiedPolygons[i].getCentroidLocation();
            polysArea[i]=defuzzifiedPolygons[i].getArea();
        }
        
        
        
        // Center of Mass
        double tempx=0.0;
        double tempy=0.0;
        double tempArea=0.0;
        for( int i = 0; i < centroids.length; i++ ) {
            tempArea = tempArea + polysArea[ i ];
            tempx = tempx + polysArea[ i ] * centroids[ i ].x;
            tempy = tempy + polysArea[ i ] * centroids[ i ].y;
            
        }
        tempx = tempx / tempArea ;
        tempy = tempy / tempArea ;
        
        defuzzifiedCentroid = new GeoPoint(tempx,tempy);
        if( tempArea == 0.0 ) {return 0.0;}
        else{
            return defuzzifiedCentroid.x;
        }
        
    }
    
    /**
     * put in all fuzzification results and get defuzzification value
     * which is the centroid of all those fuzzification result polygons
     * @param f fuzzificaiton result 
     * @return
     */    
    public double getDefuzzificationValue(FuzzificationResult[] f) {
        double y = defuzzify( getFuzzyInferenceResult( f ), outVariable );
        return y;
        
    }
    
    /**
     * the rule model contain all the rules. a rule could be described by a sentence
     * which is a String that will in the format:
     * "Rule:IF;variableName;IS;memberName;operatorName;variableName;memberName;......THEN;Output variable IS ;outMember;The Confidence IS confidenceValue;"
     * therefore, all rules will be a String[] array.
     * see@ toString() it will take the String[] and then merge all the array into 
     *                 a single String.
     */
    public String[] toStringArray() {
        FuzzyRule[] rules = getFuzzyRule();
        if ( rules == null ) { return null; }
        String[] ruleString = new String[ rules.length ];
        for ( int i = 0; i < rules.length; i ++ ) {
            String[] memberName = rules[ i ].getMemberName();
            String[] variableName = rules[ i ].getVariableName();
            String[] operatorName = rules[ i ].getOperatorName();
            String outMember = rules[ i ].getOutMember();
            int confidence = rules[ i ].getConfidence();
            
            StringBuffer temp = new StringBuffer();
            temp.append( "Rule:IF;" );
            temp.append( variableName[ 0 ] + ";IS;" );
            temp.append( memberName[ 0 ] + ";" );
            
            for ( int j = 1; j < memberName.length; j ++ ) {
                temp.append( operatorName[ j - 1 ] + ";" );
                temp.append( variableName[ j ] + ";IS;" );
                temp.append( memberName[ j ] + ";" );
            }
            temp.append( "THEN;" );
            temp.append( "Output variable IS ;" + outMember + ";" );
            temp.append( "The Confidence IS ;" + confidence + ";" );
            ruleString[ i ] = temp.toString();
        }
       return ruleString;
    }
    
    /**
     * it take the rule String array from toStringArray(), then merge them into
     * a String, actually is a paragraphy which contains all the rules' sentence.
     * since after each rule sentence i put "\n\r", so it will return in the text.
     * and so it will be a paragraphy, each rule will a line sentence.
     */
    public String toString() { 
        String[] strs = toStringArray();
        if ( strs == null || strs.length == 0 ) { return "Emption Rule Model, Not Ready For Use Yet. Please Define It.\n\r"; }
        int ruleNumber = strs.length + 1;
        String des = "Based on the fuzzy variables provided, " + ruleNumber + " rules defined which are: \n\r";
        for ( int i = 0; i < strs.length; i ++ ) {
            des = des + "  " + strs[ i ] + "\n\r";
        }
        des = des + "\n\r";
        return des;
    }
    
    /**
     * return the rule model's name
     */
    public String getName() {
        return this.name;
    }
    
    /**
     * set rule model's name
     * @param name rule model's name
     */    
    public void setName(String name) {
        this.name=name;
    }
    
}