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

import java.awt.*;
import java.awt.image.*;
import java.awt.geom.*;
import java.util.Vector;
import java.io.*;
import javax.swing.*;
import uk.ac.leeds.ccg.geotools.*;

/*
 * FuzzyPanel.java
 *
 * Created on June 25, 2002, 12:45 AM
 */

/**
 * it provide a GUI to define a variable's membership function, user can move a point
 * add, delete, fuzzy set.
 * @author  Jianhui Jin
 */

public class FuzzyPanel extends javax.swing.JPanel {
    // this Width is for the X axis arrow in the rightest side, screen size
    double xWidth = 0.0; // the rightest X will be 20 less that the xLine
    // this height is for the y axis arrow in the upper side, screen size
    double yHeight = 0.0; // the highest Y will be 20 less than the line except the mirgin
    
    Line2D.Double yLine = null; // y left side Coordinate Line
    
    Line2D.Double xLine = null; // x Coordinate Line
    
    Line2D.Double yLine2 = null; // y right side Coordinate Line
    
    // double xPosition = 0;// for x starting position
    
    // double yPosition = 0;// for y starting position
    
    /*
     * Coordiante Start Point
     */
    FuzzyPoint coordinateStartPoint = new FuzzyPoint( 0.0d, 0.0d );
    
    // editing variable
    FuzzyVariable fVariable = null;
    // name for this variable
    String name = "";
    // how many time clicked
    private int pointClicked = 0;
    
    Polygon xArrow = null;
    
    Polygon yArrow1 = null;
    
    Polygon yArrow2 = null;
    // could forbide adding and deleting fuzzy set
    protected boolean isMemberAddDeleteEnabled = true;
    
    /**
     *
     * @return get how many times clicked on the same point
     */    
    public int getPointClicked() { return pointClicked; }
    
    public void setPointClicked() { this.pointClicked ++; }
    
    java.awt.event.MouseMotionAdapter MouseMove = new java.awt.event.MouseMotionAdapter() {
        public void mouseDragged(java.awt.event.MouseEvent evt) {
            formMouseDragged(evt);
        }
    };
    
    //for test use
    Object[][] md=null;
    Vector mVector=new Vector();
    Vector dVector=new Vector();
    
    /**
     * paint the panel 
     * @param g 
     */    
    public void paintComponent(Graphics g){
        super.paintComponent(g);
        // initialize the parameters.
        //fuzzyImage=(BufferedImage) this.createImage(width , height);
        // initialise the values for this coordiante
        initCoordinate();
        // draw the coordinate
        drawCoordinate( (Graphics2D) g );
        // draw a image of this variable
        drawFuzzyImage( fVariable, (Graphics2D) g );
        
        //((Graphics2D) g).drawImage(fuzzyImage,0,0,this);
        // if edit member number allowed, set menuitem enable as true, otherwise as false
        // since in a fuzzy logic model, change member number will broke the rule model's rules
        // which might has the member that variable have deleted.
        if ( this.isMemberAddDeleteEnabled() ) {
            this.Add.setEnabled( true );
            this.Delete.setEnabled( true );
        } else {
            this.Add.setEnabled( false );
            this.Delete.setEnabled( false );
        }
        
    }
    
    /**
     * enabled add or delete fuzzy set
     * @param enabled
     */    
    public void setMemberAddDeleteEnabled( boolean enabled ) {
        this.isMemberAddDeleteEnabled = enabled;
    }
    
    /**
     * is add and delete enabled.
     * @return
     */    
    public boolean isMemberAddDeleteEnabled() {
        return this.isMemberAddDeleteEnabled;
    }
    // draw coordinate
    private void drawCoordinate(Graphics2D graphic) {
        // draw origin point
        FuzzyPoint start = getCoordinateStartPoint();
        graphic.setColor( Color.black );
        graphic.setStroke( new BasicStroke( 3.0f ) );
        // draw y axis
        graphic.draw( yLine );
        // draw x axis
        graphic.draw( xLine );
        // draw right side y axis.
        graphic.draw( yLine2 );
        graphic.setColor( Color.black );
        // draw x axis arrow
        graphic.draw( xArrow );
        graphic.fill( xArrow );
        // draw left y axis arrow
        graphic.draw( yArrow1 );
        graphic.fill( yArrow1 );
        // draw right y axis arrow
        graphic.draw( yArrow2 );
        graphic.fill( yArrow2 );
        
        // draw those text 
        graphic.drawString( "Membership Degree", 5, 25 );
        graphic.drawString( "0.0", (int) start.getX() - 5, (int) start.getY() + 9 );
        graphic.drawString( "1.0" + name + " value", (int) xWidth - 10, (int) start.getY() + 11 );
        graphic.drawString( "1.0", (int) start.getX() - 5, (int) ( start.getY() - yHeight - 3 ) );
        
    }
    // initialise the coordiante
    private void initCoordinate() {
        int width = getWidth(); // panel width
        int height = getHeight(); // panel height
        double xPosition = 20.0d;
        double yPosition = height - 50.0d;
        setCoordinateStartPoint( new FuzzyPoint( xPosition, yPosition ) );
        FuzzyPoint coordinateStartPoint = getCoordinateStartPoint();
        FuzzyPoint xLineTopPoint = new FuzzyPoint( width - xPosition, yPosition );
        FuzzyPoint yLine1TopPoint = new FuzzyPoint( xPosition, 30.d  );
        
        yLine = new Line2D.Double( coordinateStartPoint.getX(), coordinateStartPoint.getY(), yLine1TopPoint.getX(), yLine1TopPoint.getY() ); // y left side Coordinate Line
        xLine = new Line2D.Double( coordinateStartPoint.getX(), coordinateStartPoint.getY(), xLineTopPoint.getX(), xLineTopPoint.getY() ); // X Coordinae Line
        
        xWidth = xLineTopPoint.getX() - coordinateStartPoint.getX() - 20.0d; // x Width start from the start point and the rightest X will be 20 less that the xLine
        yHeight = coordinateStartPoint.getY() - yLine1TopPoint.getY() - 20.0d; // yHeight start from the start pointthe highest Y will be 20 less than the yline except the mirgin
        
        yLine2 = new Line2D.Double(  coordinateStartPoint.getX() + xWidth, coordinateStartPoint.getY(), coordinateStartPoint.getX() + xWidth, yLine1TopPoint.getY() ); // yLine2 ends the coordinate in the right side
        FuzzyPoint yLine2TopPoint = new FuzzyPoint( xPosition + xWidth, 30.0d );
        
        int[] xArrowPointX = { (int) xLineTopPoint.getX(), (int) ( xLineTopPoint.getX() - 15.0d ), (int) ( xLineTopPoint.getX() - 15.0d ) };
        int[] xArrowPointY = { (int) ( xLineTopPoint.getY() ), (int) ( xLineTopPoint.getY() - 4.0d ) , (int) ( xLineTopPoint.getY() + 4.0d ) };
        xArrow = new Polygon( xArrowPointX, xArrowPointY, 3 );
        
        int[] y1ArrowPointX = { (int) yLine1TopPoint.getX(), (int) ( yLine1TopPoint.getX() - 4.0d ), (int) ( yLine1TopPoint.getX() + 4.0d ) };
        int[] y1ArrowPointY = { (int) yLine1TopPoint.getY(), (int) ( yLine1TopPoint.getY() + 15.0d ) , (int) ( yLine1TopPoint.getY() + 15.0d ) };
        yArrow1 = new Polygon( y1ArrowPointX, y1ArrowPointY , 3 );
        
        int[] y2ArrowPointX = { (int) yLine2TopPoint.getX(), (int) ( yLine2TopPoint.getX() - 4.0d ), (int) ( yLine2TopPoint.getX() + 4.0d ) };
        int[] y2ArrowPointY = { (int) ( yLine2TopPoint.getY() ), (int) ( yLine2TopPoint.getY() + 15.0d ) , (int) ( yLine2TopPoint.getY() + 15.0d ) };
        yArrow2 = new Polygon( y2ArrowPointX, y2ArrowPointY, 3 );
    }
    
    // draw editting variable
    private void drawFuzzyImage( FuzzyVariable fVariable, Graphics2D graphic ){
        //graphic= fuzzyImage.createGraphics();
        graphic.setStroke( new BasicStroke( 1.0f ) );
        AbstractFuzzySet[] set = fVariable.getFuzzySet();
        for( int i = 0; i < set.length; i ++ )
            drawFuzzyMember( graphic, set[ i ] );
        
    }
    
    // draw a fuzzy set
    private void drawFuzzyMember( Graphics2D g, AbstractFuzzySet set ){
        g.setColor( set.getColor() );
        FuzzyPoint[] ps = set.getFuzzyPoint();
        for( int i = 0; i <ps.length - 1; i ++ ) {
            Line2D.Double line = new Line2D.Double( fuzzyPointToImagePoint( ps[ i ] ), fuzzyPointToImagePoint( ps[ i + 1 ] ) );
            g.draw( line );
        }
        
        FuzzyPoint selectedPoint = this.fVariable.getSelectedFuzzyPoint();
        if( selectedPoint != null ) {
            g.setColor( selectedPoint.getColor() );
            selectedPoint = fuzzyPointToImagePoint( selectedPoint );
            g.drawOval( ( int ) selectedPoint.getX(), ( int ) selectedPoint.getY(), 5, 5 );
            //g.fillOval( ( int ) selectedPoint.getX(), ( int ) selectedPoint.getY(), 2, 2 );
        }
        
        g.setColor( Color.RED );
        FuzzyPoint temp = fuzzyPointToImagePoint( set.getTopPoint());
        g.drawString( set.getName(), (int) temp.x - 2, (int) temp.y - 2 );
        
    }
    
    // convert fuzzy point to a screen value point
    private FuzzyPoint fuzzyPointToImagePoint( FuzzyPoint p ) {
        FuzzyPoint newPoint = new FuzzyPoint();
        FuzzyPoint startPoint = getCoordinateStartPoint();
        newPoint.setLocation( p.getX() * xWidth + startPoint.getX(), startPoint.getY() - p.getY() * yHeight);
        return newPoint;
        
    }
    
    // convert screen value point to fuzzy point
    private FuzzyPoint imagePointToFuzzyPoint( FuzzyPoint p ){
        FuzzyPoint newPoint = new FuzzyPoint();
        FuzzyPoint startPoint = getCoordinateStartPoint();
        newPoint.setLocation( ( p.getX() - startPoint.getX() ) / xWidth, ( startPoint.getY() - p.getY() ) / yHeight );
        return newPoint;
        
    }
    
    /** Creates new form FuzzyPanel */
    public FuzzyPanel(){
        initComponents();
        this.fVariable = new FuzzyVariable("");
        this.name = "";
        setBorder( new javax.swing.border.TitledBorder( name + " Fuzzy Sets" ) );
        repaint();
    }
    
    /**
     *
     * @param fVariable
     */    
    public FuzzyPanel( FuzzyVariable fVariable ) {
        initComponents();
        this.fVariable = fVariable;
        this.name = fVariable.name;
        setBorder( new javax.swing.border.TitledBorder( name + " Fuzzy Sets" ) );
        repaint();
    }
    
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    private void initComponents() {//GEN-BEGIN:initComponents
        editPop = new javax.swing.JPopupMenu();
        Add = new javax.swing.JMenuItem();
        jSeparator1 = new javax.swing.JSeparator();
        Delete = new javax.swing.JMenuItem();
        jSeparator2 = new javax.swing.JSeparator();
        setMemberPointNumber = new javax.swing.JMenuItem();
        jSeparator3 = new javax.swing.JSeparator();
        Defuzzify = new javax.swing.JMenuItem();
        nameField = new javax.swing.JTextField();
        jLabel1 = new javax.swing.JLabel();

        Add.setText("Add");
        Add.setToolTipText("add a set");
        Add.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                AddActionPerformed(evt);
            }
        });

        editPop.add(Add);

        editPop.add(jSeparator1);

        Delete.setText("Delete");
        Delete.setToolTipText("delete a set");
        Delete.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                DeleteActionPerformed(evt);
            }
        });

        editPop.add(Delete);

        editPop.add(jSeparator2);

        setMemberPointNumber.setText("Set Member Point Number");
        setMemberPointNumber.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                setMemberPointNumberActionPerformed(evt);
            }
        });

        editPop.add(setMemberPointNumber);

        editPop.add(jSeparator3);

        Defuzzify.setText("Fuzzify and Defuzzify Test");
        Defuzzify.setToolTipText("Move a Point");
        Defuzzify.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                DefuzzifyActionPerformed(evt);
            }
        });

        editPop.add(Defuzzify);

        setLayout(new org.netbeans.lib.awtextra.AbsoluteLayout());

        setBackground(new java.awt.Color(255, 255, 255));
        setBorder(new javax.swing.border.TitledBorder(""));
        addMouseListener(new java.awt.event.MouseAdapter() {
            public void mousePressed(java.awt.event.MouseEvent evt) {
                formMousePressed(evt);
            }
            public void mouseReleased(java.awt.event.MouseEvent evt) {
                formMouseReleased(evt);
            }
            public void mouseClicked(java.awt.event.MouseEvent evt) {
                formMouseClicked(evt);
            }
        });

        nameField.setText("Test");
        nameField.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                nameFieldActionPerformed(evt);
            }
        });

        add(nameField, new org.netbeans.lib.awtextra.AbsoluteConstraints(180, 270, 50, -1));

        jLabel1.setText("Name");
        add(jLabel1, new org.netbeans.lib.awtextra.AbsoluteConstraints(140, 270, -1, -1));

    }//GEN-END:initComponents
    // change the number of points for the selected fuzzy set 
    private void setMemberPointNumberActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_setMemberPointNumberActionPerformed
        AbstractFuzzySet selectedSet = this.fVariable.getSelectedFuzzySet();
        if( selectedSet == null ) return;
        
        int setPointNumber = 3;
        
        try { setPointNumber = Integer.parseInt( JOptionPane.showInputDialog( this, "How Many Point You Want To Be Used To Construct This Member " ) ); }
        catch( Exception e ) { System.out.println( " Cancel Action " ); return; }
        
        AbstractFuzzySet newSet = new FuzzySet( setPointNumber, selectedSet.getTopPoint().getX(), selectedSet.getSetWidth() );
        
        this.fVariable.setFuzzySet( newSet, selectedSet );
        
        this.repaint();
        
        // Add your handling code here:
    }//GEN-LAST:event_setMemberPointNumberActionPerformed
    // edit the name of this variable
    private void nameFieldActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_nameFieldActionPerformed
        fVariable.setName(nameField.getText());
        this.setName(nameField.getText());
        setBorder(new javax.swing.border.TitledBorder(name + " Fuzzy Sets"));
        this.repaint();
        // Add your handling code here:
    }//GEN-LAST:event_nameFieldActionPerformed
    // mouse click once select a set, twice selected a point
    private void formMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMouseClicked
        this.removeMouseMotionListener(MouseMove);
        FuzzyPoint clickedPoint= imagePointToFuzzyPoint(new FuzzyPoint((int) evt.getX(),(int) evt.getY()));
        this.setPointClicked();
        FuzzificationResult f = fVariable.getFuzzificationResult(clickedPoint);
        
        // test
        Object[][] temp=f.getMemberNameAndDegree();
        for(int i=0;i<temp.length;i++) {
            System.out.println( (String) temp[i][0] );
            System.out.println( ( (Double) temp[i][1] ).toString() );
        }
        // test finish
        
        if( ( this.getPointClicked() % 2 ) != 0 ) {
            fVariable.setSelectedFuzzySetByDetection( clickedPoint );
            fVariable.setSelectedPoint( null );
            
        } else {
            fVariable.setSelectedFuzzyPointByDetection( clickedPoint, fVariable.getSelectedFuzzySet() );
            
        }
        
        this.repaint();
        this.addMouseMotionListener(MouseMove);
        // Add your handling code here:
    }//GEN-LAST:event_formMouseClicked
    //for test
    private FuzzyPoint clickedPoint;
    // this method is for test
    private void DefuzzifyActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_DefuzzifyActionPerformed
        
        AbstractFuzzySet selectedSet = fVariable.getSelectedFuzzySet();
        mVector.add( selectedSet.getName() );
        dVector.add( new Double( clickedPoint.y ) );
        
        
        Object[] m = mVector.toArray();
        Object[] d = dVector.toArray();
        md = new Object[m.length][2];
        
        for( int i = 0; i < m.length; i++ ) {
            md[ i ][ 0 ] = m[ i ];
            md[ i ][ 1 ] = d[ i ];
        }
        
        FuzzificationResult test = new FuzzificationResult( md, "test");
        new FuzzyRuleModel( "test" ).defuzzify( test, fVariable );
        
        GeoPoint cen = FuzzyRuleModel.defuzzifiedCentroid;
        FuzzyPoint centroid = new FuzzyPoint( cen.x, cen.y );
        GeoPolygon[] geopolys = FuzzyRuleModel.defuzzifiedPolygons;
        Graphics g = this.getGraphics();
        for( int i = 0; i < geopolys.length; i ++ ) {
            double[] dx = geopolys[ i ].getPointsAsArrayX();
            double[] dy = geopolys[ i ].getPointsAsArrayY();
            
            int[] x = new int[ dx.length ];
            int[] y = new int[ dy.length ];
            
            for( int j = 0;j < dx.length; j ++ ) {
                
                x[j] = (int) this.fuzzyPointToImagePoint(new FuzzyPoint(dx[j],dy[j])).x;
                y[j] = (int) this.fuzzyPointToImagePoint(new FuzzyPoint(dx[j],dy[j])).y;
            }
            
            g.setColor(Color.black);
            g.fillPolygon( x,y,geopolys[i].getNPoints());
        }
        
        System.out.println(centroid.x);
        System.out.println(centroid.y);
        
        
        g.setColor(Color.red);
        g.fillOval((int)this.fuzzyPointToImagePoint(centroid).x,(int)this.fuzzyPointToImagePoint(centroid).y,5,5);
        
        
    }//GEN-LAST:event_DefuzzifyActionPerformed
    // move set, points
    private void formMouseDragged(java.awt.event.MouseEvent evt) {
        //FuzzyPoint d=imagePointToFuzzyPoint(new FuzzyPoint((double) evt.getX(),(double) evt.getY()));
        //System.out.println(d.x);
        //System.out.println(d.y);
        
        fVariable.moveSet(imagePointToFuzzyPoint(new FuzzyPoint((double) evt.getX(),(double) evt.getY())));
        
        //pointMoveFirst=false;
        this.repaint();
        
        // Add your handling code here:
    }
    // add a set
    private void AddActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_AddActionPerformed
        
        fVariable.addSet();
        
        this.repaint();// Add your handling code here:
    }//GEN-LAST:event_AddActionPerformed
    // delete a set
    private void DeleteActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_DeleteActionPerformed
        fVariable.deleteSet();
        this.repaint();// Add your handling code here:
    }//GEN-LAST:event_DeleteActionPerformed
    // right click action, popup a menu
    private void formMouseReleased(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMouseReleased
        //this.removeMouseMotionListener(MouseMove);
        clickedPoint= imagePointToFuzzyPoint(new FuzzyPoint((int) evt.getX(),(int) evt.getY()));
        if(evt.isPopupTrigger()) editPop.show(this,evt.getX(),evt.getY());
        
        
        // Add your handling code here:
    }//GEN-LAST:event_formMouseReleased
    
    private void formMousePressed(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMousePressed
        //this.removeMouseMotionListener(MouseMove);
        clickedPoint= imagePointToFuzzyPoint(new FuzzyPoint((int) evt.getX(),(int) evt.getY()));
        if(evt.isPopupTrigger()) editPop.show(this,getX(),getY());
        
        
        // Add your handling code here:
    }//GEN-LAST:event_formMousePressed
    /**
     * set editting fuzzy variable
     * @param fVariable
     */    
    public void setFuzzyVariable(FuzzyVariable fVariable){
        this.fVariable=fVariable;
    }
    /**
     * save out fuzzy variable parameter object aray as a serielizable object
     * @param fVariable 
     * @param out
     * @throws IOException
     */    
    public static void save( FuzzyVariable fVariable, File out ) throws IOException {
        ObjectOutputStream objectStream=new ObjectOutputStream( new FileOutputStream( out ) );
        objectStream.writeObject( fVariable.toObject() );
        objectStream.close();
        
    }
    
    /**
     * load in a serielisable fuzzy variable parameter object[]
     * @param in
     * @throws IOException
     * @throws ClassNotFoundException
     * @return
     */    
    public static FuzzyVariable load( File in ) throws IOException,ClassNotFoundException{
        ObjectInputStream objectStream = new ObjectInputStream( new FileInputStream( in ) );
        
        return new FuzzyVariable( ( Object[] ) objectStream.readObject() );
        
    }
    
    /**
     * edit name enable
     * @param enabled
     */    
    public void setNameEditorEnabled( boolean enabled ) {
        nameField.setEditable( enabled );
    }
    /**
     * set editing variable's name
     * @param name
     */    
    public void setName(String name) {
        this.name=name;
    }
    
    /**
     * 
     * @return editing variable
     */    
    public FuzzyVariable getFuzzyVariable() {
        return this.fVariable;
    }
    
    /**
     *
     * @return origin point of the coordinate
     */    
    public FuzzyPoint getCoordinateStartPoint() {
        return this.coordinateStartPoint;
    }
    
    /**
     * set coordinate point
     * @param start 
     */    
    public void setCoordinateStartPoint( FuzzyPoint start ) {
        this.coordinateStartPoint = new FuzzyPoint( start.getX(), start.getY() );
    }
    
    
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JMenuItem setMemberPointNumber;
    private javax.swing.JSeparator jSeparator3;
    private javax.swing.JSeparator jSeparator2;
    private javax.swing.JSeparator jSeparator1;
    private javax.swing.JTextField nameField;
    private javax.swing.JPopupMenu editPop;
    private javax.swing.JMenuItem Defuzzify;
    private javax.swing.JMenuItem Delete;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JMenuItem Add;
    // End of variables declaration//GEN-END:variables
    
}