/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */


import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.event.EventType;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.input.MouseEvent;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.scene.web.WebEngine;
import javafx.scene.web.WebView;
import javafx.stage.Stage;
import javafx.stage.StageStyle;

/**
 *
 * @author kumarse
 */
public class WindowManager extends Application {

    /**
     * @param args the command line arguments
     */
    int stageNumber;
    final int numberOfStages=3;    
    boolean handleDrag;
    Stage[] stage;
    Group[] root;
    Scene[] scene;
    double[] distance;
    double[] prevDistance;
    Color[] colors;
    int[] direction;
    double initX,initY,startX,startY;
    double[][] Dimensions;      // Used to store the left,right,top and bottom bounds of a stage
    final static double distanceThreshold=15,overlapThreshold=0.75;
    
    public void init()
    {
        handleDrag=true;
        distance=new double[numberOfStages];
        prevDistance=new double[numberOfStages];
        direction=new int[numberOfStages];
        stage=new Stage[numberOfStages];
        Dimensions=new double[numberOfStages][4];
        for(stageNumber=0;stageNumber<numberOfStages;stageNumber++)
            Dimensions[stageNumber]=new double[4];
        colors=new Color[numberOfStages];
        colors[0]=Color.CORNSILK;
        colors[1]=Color.STEELBLUE;
        colors[2]=Color.WHITE;
    }
    
    public static void main(String[] args) {
        launch(args);
    }
    
    @Override
    public void start(Stage primaryStage) {
        root=new Group[numberOfStages];
        scene=new Scene[numberOfStages];
        for(stageNumber=0;stageNumber<numberOfStages;stageNumber++)
        {
            stage[stageNumber]=new Stage(StageStyle.TRANSPARENT);
            stage[stageNumber].setTitle("Window "+stageNumber);
            root[stageNumber]=new Group();
            Text num=new Text("Stage "+stageNumber);
            num.setFont(Font.font("Calibri",24));
            num.setX(50);
            num.setY(50);
           
            //WebView browser=new WebView();
            //WebEngine browserEngine=browser.getEngine();
            //browserEngine.load("http://www.google.com");
            //root[stageNumber].getChildren().add(browser);
            
            root[stageNumber].getChildren().add(num);
            scene[stageNumber]=new Scene(root[stageNumber]);
            scene[stageNumber].setFill(colors[stageNumber]);
            stage[stageNumber].setScene(scene[stageNumber]);
            
            //browser.setPrefHeight(400);
            //browser.setPrefWidth(325);
            
            stage[stageNumber].setHeight(250);
            stage[stageNumber].setWidth(250);
            stage[stageNumber].setX((stageNumber*250)+10);
            System.out.println("Window "+stageNumber+" is at X "+stage[stageNumber].getX());
            stage[stageNumber].show();
            
            double X=stage[stageNumber].getX(),Y=stage[stageNumber].getY();
            double height=stage[stageNumber].getHeight(),width=stage[stageNumber].getWidth();
            
            //Initialize the left,right,top and bottom bounds of each window
            Dimensions[stageNumber][0]=X;
            Dimensions[stageNumber][1]=X+width;
            Dimensions[stageNumber][2]=Y;
            Dimensions[stageNumber][3]=Y+height;
            
            
            scene[stageNumber].setOnMousePressed(new EventHandler<MouseEvent>()
            {
                final int temp=stageNumber;
                public void handle(MouseEvent me)
                {
                    for(int i=0;i<numberOfStages;i++)
                        prevDistance[i]=-1;                  
                    handleMousePressEvent(temp,me);
                }
            });
            
            scene[stageNumber].setOnMouseDragged(new EventHandler<MouseEvent>()
            {
                final int temp=stageNumber;
                public void handle(MouseEvent me)
                {
                   handleMouseDragEvent(temp,me);
                }
            });
            
            scene[stageNumber].setOnMouseReleased(new EventHandler<MouseEvent>()
            {
                final int temp=stageNumber;
                public void handle(MouseEvent me)
                {
                    handleDrag=true;
                    if(stage[temp].getX()!=startX || stage[temp].getY()!=startY)    //Check for overlap
                        handleOverlap(temp,startX,startY);
                }
            });
            
            stage[stageNumber].xProperty().addListener(new ChangeListener()
            {
                final int temp=stageNumber;
                public void changed(ObservableValue val,Object oldVal,Object newVal)
                {
                    handleMove(temp);
                }
            });
        
            stage[stageNumber].yProperty().addListener(new ChangeListener()
            {
                final int temp=stageNumber;
                public void changed(ObservableValue val,Object oldVal,Object newVal)
                {
                    handleMove(temp);
                }
            });
           
        }       
       
    }
  
    
    private void handleMousePressEvent(int stageNumber,MouseEvent me)
    {
        startX=stage[stageNumber].getX();
        startY=stage[stageNumber].getY();
        initX=me.getScreenX()-stage[stageNumber].getX();
        initY=me.getScreenY()-stage[stageNumber].getY();
    }
    
    
    private void handleMouseDragEvent(int stageNumber,MouseEvent me)
    {
        if(handleDrag)
        {
            stage[stageNumber].setX(me.getScreenX()-initX);
            stage[stageNumber].setY(me.getScreenY()-initY);
        }
    }
    
    private void handleMove(int stageNumber)
    {
        double X=stage[stageNumber].getX(),Y=stage[stageNumber].getY();
        double height=stage[stageNumber].getHeight(),width=stage[stageNumber].getWidth();
        
        double mLeft,mRight,mTop,mBottom,fLeft,fRight,fTop,fBottom;
        
        Dimensions[stageNumber][0]=mLeft=X;        
        Dimensions[stageNumber][1]=mRight=X+width;
        Dimensions[stageNumber][2]=mTop=Y;
        Dimensions[stageNumber][3]=mBottom=Y+height;
        
        /* 
         * Find the nearest window and stick the moving window with that if the distance is less than the distance threshold
         * of 15 pixels.
         */
        
        for(int i=0;i<numberOfStages;i++)
        {
            distance[i]=-1;
            if(i!=stageNumber)
            {
                fLeft=Dimensions[i][0];
                fRight=Dimensions[i][1];
                fTop=Dimensions[i][2];
                fBottom=Dimensions[i][3];

                //Calculate distance between the moving stage and this stage
                
                if(mRight<fLeft && (fLeft-mRight<=distanceThreshold) && mBottom>fTop && mTop<fBottom )
                {
                    //In left region
                    if(mTop<fTop)
                    {
                        if((mBottom-fTop)/(mBottom-mTop)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the left of window "+i);
                            distance[i]=fLeft-mRight;
                            direction[i]=0;

                        }                            
                    }
                    else
                    {
                        if((fBottom-mTop)/(fBottom-fTop)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the left of window "+i);
                            distance[i]=fLeft-mRight;
                            direction[i]=0;
                        }
                    }

                }
                else if(mLeft>fRight && (mLeft-fRight<=distanceThreshold) && mBottom>fTop &&mTop<fBottom )
                {
                    // In right region
                    if(mTop<fTop)
                    {
                        if((mBottom-fTop)/(mBottom-mTop)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the right of window "+i);
                            distance[i]=mLeft-fRight;
                            direction[i]=1;
                        }
                    }
                    else
                    {
                        if((fBottom-mTop)/(fBottom-fTop)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the right of window "+i);
                            distance[i]=mLeft-fRight;
                            direction[i]=1;
                        }
                    }
                }
                else if(mBottom<fTop && (fTop-mBottom<=distanceThreshold) && mRight>fLeft && mLeft<fRight )
                {
                    // In top region
                    if(mLeft<fLeft)
                    {
                        if((mRight-fLeft)/(mRight-mLeft)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the top of window "+i);
                            distance[i]=fTop-mBottom;
                            direction[i]=2;
                        }
                    }
                    else
                    {
                        if((fLeft-mRight)/(fRight-fLeft)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the top of window "+i);
                            distance[i]=fTop-mBottom;
                            direction[i]=2;
                        }
                    }
                }
                else if(mTop>fBottom && (mTop-fBottom<=distanceThreshold) && mRight>fLeft && mLeft<fRight )
                {
                    // In Bottom region
                    if(mLeft<fLeft)
                    {
                        if((mRight-fLeft)/(mRight-mLeft)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the bottom of window "+i);
                            distance[i]=mTop-fBottom;
                            direction[i]=3;
                        }
                    }
                    else
                    {
                        if((fRight-mLeft)/(fRight-fLeft)>=overlapThreshold)
                        {
                            //System.out.println("Stick moving window to the bottom of window "+i);
                            distance[i]=mTop-fBottom;
                            direction[i]=3;
                        }
                    }

                }

            }

        }

        int stick=findStickWindow();
        if(stick!=-1 && distance[stick]<prevDistance[stick])
        {
            handleDrag=false;   //Setting it to false so tht user loses drag control over the window once it is sticked.
            switch(direction[stick])
            {
                case 0:
                    setStage(stageNumber,Dimensions[stick][0]-width,Dimensions[stick][2]); // The moving window must be set at the same Y coordinate as the fixed window
                    break;
                case 1:
                    setStage(stageNumber,Dimensions[stick][1],Dimensions[stick][2]); // The moving window must be set at the same Y coordinate as the fixed window
                    break;
                case 2:
                    setStage(stageNumber,Dimensions[stick][0],Dimensions[stick][2]-height);
                    break;
                case 3:
                    setStage(stageNumber,Dimensions[stick][0],Dimensions[stick][3]);
                    break;    
            }
            /*
            * Evidence that setY and getY are not working properly. The following println always prints the same values for both the
            * Y co-ordinates. But as you can see visually the two windows are not at the same Y level. 
            * When a moving window is sticked to a fixed window, it should ideally be at the same y co-ordinate as the fixed window (if setY works properly). 
            * But often the moving window is at a different Y co-ordinate
            */
             System.out.println("The top Y co-ordinate of the window "+stick+" is "+stage[stick].getY()+ " and the top Y co-ordinate of the window "+stageNumber+" is "+stage[stageNumber].getY());
                   
        }
            
        System.arraycopy(distance, 0, prevDistance, 0, numberOfStages);
    }
    
    // Find the window which has the minimim distance from the moving window    
    int findStickWindow()
    {
        int nearest=-1;
        double minDistance=100;
        for(int i=0;i<numberOfStages;i++)
        {
            if(distance[i]!=-1 && distance[i]<minDistance)
            {
                minDistance=distance[i];
                nearest=i;
            }
        }
        return nearest;
    }
    
    // Set the X and Y co-ordinates of a stage/window
    void setStage(int stageNumber,double X,double Y)
    {
        stage[stageNumber].setX(X);
        stage[stageNumber].setY(Y);
    }
   
    // Check if the window that moved is overlapping with any other window. If so take it back to its original position
    void handleOverlap(int stageNumber,double startX,double startY)
    {
        double curTop=Dimensions[stageNumber][2],curBottom=Dimensions[stageNumber][3];
        double curLeft=Dimensions[stageNumber][0],curRight=Dimensions[stageNumber][1];
        double top,bottom,left,right;
        for(int i=0;i<numberOfStages;i++)
        {
            if(i!=stageNumber)
            {
                left=Dimensions[i][0];
                right=Dimensions[i][1];
                top=Dimensions[i][2];
                bottom=Dimensions[i][3];
                if(left<curRight && right>curLeft && top<curBottom && bottom>curTop)
                {
                    setStage(stageNumber,startX,startY);
                    break;
                }
            }
        }
    } 
    
    
}