/*
 * MouseSelectListener.java
 *
 * Created on July 31, 2007, 5:55 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package dyno.swing.designer.beans.events;

import dyno.swing.beans.layouts.AbsoluteLayout;
import dyno.swing.designer.beans.AdapterBus;
import dyno.swing.designer.beans.ComponentAdapter;
import dyno.swing.designer.beans.Constants;
import dyno.swing.designer.beans.ContainerAdapter;
import dyno.swing.designer.beans.DesignerEditor;
import dyno.swing.designer.beans.DesignerTransferHandler;
import dyno.swing.designer.beans.SpecialContainerAdapter;
import dyno.swing.designer.beans.SwingDesigner;
import dyno.swing.designer.beans.Util;
import dyno.swing.designer.beans.location.Location;
import dyno.swing.designer.beans.models.SelectionModel;
import dyno.swing.designer.beans.models.StateModel;
import dyno.swing.designer.properties.ValidationException;
import java.awt.Component;
import java.awt.Container;
import java.awt.LayoutManager;
import java.awt.Rectangle;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.RootPaneContainer;
import javax.swing.SwingUtilities;
import javax.swing.TransferHandler;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.MouseInputListener;


/**
 * 普通模式下的鼠標點擊、位置處理器
 * @author William Chen
 */
public class EditingMouseListener implements MouseInputListener, ChangeListener, Constants {

    private SwingDesigner designer;
    /**
     * 普通模式下對應的model
     */
    private StateModel stateModel;
    /**
     * 選擇模型，存儲當前選擇的組件和剪切板
     */
    private SelectionModel selectionModel;
    private Component lastComponent;
    private MouseEvent lastPressEvent;
    private DesignerEditor current_editor;
    private Component current_bean;
    private ComponentAdapter current_adapter;

    /** Creates a new instance of MouseSelectListener */
    public EditingMouseListener(SwingDesigner designer) {
        this.designer = designer;
        stateModel = designer.getStateModel();
        selectionModel = designer.getSelectionModel();
    }

    @Override
    public void mousePressed(MouseEvent e) {
        if (!stopEditing()) {
            return;
        }
        if (!designer.isFocusOwner()) {
            //獲取焦點，以便獲取熱鍵
            designer.requestFocus();
        }

        if (e.isPopupTrigger()) {
            //為觸發上下文菜單預留
            trigger_popup(e);
        } else if (e.getButton() == MouseEvent.BUTTON1) {
            //獲取鼠標所在被選中的組件
            Component comp = selectionModel.getSelectionAt(e);
            Component hotspot = designer.getComponentAt(e);
            if (selectionModel.isSelectedResizable() && 
                    (comp != null) && 
                    (hotspot == comp || 
                    isParent(comp, hotspot))) {
                //如果在鼠標有被選擇的組件，并且組件是處理可被拖拽狀態，則更新當前鼠標的位置信息以及鼠標形狀
                stateModel.updateLocRel2Comp(e, comp);
                designer.updateCursor();

                if (stateModel.getLocation() != Location.outer) {
                    //如果當前是處于拖拽位置，則開始拖拽，記錄初始拖拽狀態
                    stateModel.startSelectionResizing(e);
                }
            } else {
                //如果是其他情況，計算是否在拖拽根組件的位置
                stateModel.updateLocRel2Root(e);

                if (stateModel.getLocation() == Location.outer) {
                    //如果不是處于拖拽位置，則先將該組件添加到被選擇的組件中
                    selectionModel.selectAComponentAtMouseEvent(e);
                    designer.repaint();
                    //并獲取當前鼠標所在的組件
                    comp = designer.getComponentAt(e);

                    if (comp != null) {
                        //獲取組件的適配器
                        ComponentAdapter adapter = AdapterBus.getComponentAdapter(designer, comp);

                        //調用其適配器處理鼠標點擊，在此處可以處理JTabbedPane頁面切換的特殊情況
                        if (adapter.componentClicked(e)) {
                            //如果componentClicked處理結果需要繼續后續鼠標處理
                            if (adapter instanceof ContainerAdapter && ((((ContainerAdapter) adapter).getChildCount() > 0) || (comp.getParent() == null)) && !(adapter instanceof SpecialContainerAdapter)) {
                                //當前組件如果是容器，則開始進入區域拖拽選擇模式
                                stateModel.startSelecting(e);
                                //設置當前選擇的熱點區域
                                selectionModel.setHotspotBounds(new Rectangle());
                            } else if (isComponentResizable(comp)) {
                                //如果鼠標所在的組件是可以拖拽的，則繼續該鼠標的進一步處理
                                mousePressed(e);
                            } else if (comp.getParent() != null) {
                                lastPressEvent = e;
                                lastComponent = comp;
                            }
                        } else {
                            designer.setInvalidated(true);
                        }
                    }
                } else {
                    //如果是拖拽根組件狀態，則更新鼠標形狀
                    designer.updateCursor();
                    //開始resize根組件
                    stateModel.startResizing(e);
                }
            }
        }
    }

    //comp是否是可以拖拽
    private boolean isComponentResizable(Component comp) {
        Container parent = comp.getParent();

        if (parent != null) {
            //如果其父容器組件的布局管理器為空或者是AbsoluteLayout則可以拖拽
            LayoutManager layout = parent.getLayout();

            if ((layout == null) || layout instanceof AbsoluteLayout) {
                return true;
            }
        }

        return false;
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        if (e.isPopupTrigger()) {
            trigger_popup(e);
        } else {
            if (stateModel.isSelecting()) {
                //如果當前是區域選擇狀態，則選擇該區域所含的組件
                designer.selectComponents(e);
            } else if (stateModel.isDragging()) {
                //如果是處于拖拽狀態，則釋放組件
                designer.releaseComponentsDragging(e);
            } else {
            }
        }

        lastPressEvent = null;
        lastComponent = null;
    }

    private boolean isParent(Component child, Component parent) {
        if (parent == child.getParent()) {
            return true;
        }
        if(parent instanceof RootPaneContainer){
            RootPaneContainer rootPane=(RootPaneContainer)parent;
            return rootPane.getContentPane() == child.getParent();
        }
        return false;
    }

    /**
     * 激活上下文菜單，待完善
     */
    private void trigger_popup(MouseEvent e) {
        ArrayList<Component> selection = selectionModel.getSelectedComponents();

        if ((selection == null) || selection.isEmpty()) {
            return;
        }

        JPopupMenu popupMenu = null;

        if (selection.size() > 0) {
            Component component = selection.get(0);
            ComponentAdapter adapter = AdapterBus.getComponentAdapter(designer, component);
            popupMenu = adapter.getContextPopupMenu(e);
        } else {
            return;
        }

        if (popupMenu != null) {
            popupMenu.show(designer, e.getX(), e.getY());
        }
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        //鼠標移動，獲取鼠標所在被選擇的組件
        Component comp = selectionModel.getSelectionAt(e);

        if (selectionModel.isSelectedResizable() && (comp != null)) {
            //如果當前所在的被選擇組件是可以拖拽的，更新其位置信息
            stateModel.updateLocRel2Comp(e, comp);
        } else {
            //更新其相對于根組件的位置信息
            stateModel.updateLocRel2Root(e);
        }
        //更新鼠標形狀
        designer.updateCursor();
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        if (stateModel.isDragging()) {
            //如果當前是拖拽狀態，拖拽組件
            stateModel.dragging(e);
        } else if (stateModel.isSelecting() && (selectionModel.getHotspotBounds() != null)) {
            //如果是拖拽選擇區域狀態，則更新選擇區域
            stateModel.changeSelection(e);
        } else {
            if ((lastPressEvent == null) || (lastComponent == null)) {
                return;
            }

            if (e.getPoint().distance(lastPressEvent.getPoint()) > 5) {
                TransferHandler handler = new DesignerTransferHandler();
                designer.setTransferHandler(handler);
                handler.exportAsDrag(designer, lastPressEvent, TransferHandler.COPY);
                designer.startDraggingComponent(lastComponent, e.getX(), e.getY());
                e.consume();
                lastPressEvent = null;
            }
        }

        designer.repaint();
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        if (e.getClickCount() <= 1) {
            return;
        }
        if (stopEditing()) {
            Component bean = designer.getComponentAt(e);
            if (bean != null) {
                int x = e.getX();
                int y = e.getY();
                ComponentAdapter adapter = AdapterBus.getComponentAdapter(designer, bean);
                x -= designer.getOuterLeft();
                y -= designer.getOuterTop();

                Rectangle rect = Util.getRelativeBounds(bean);
                x -= rect.x;
                y -= rect.y;

                DesignerEditor editor = adapter.getDesignerEditor(x, y);

                if (editor != null) {
                    current_editor = editor;
                    current_bean = bean;
                    current_adapter = adapter;
                    current_editor.addChangeListener(this);
                    Rectangle bounds = current_adapter.getEditorBounds(x, y);
                    bounds.x += (rect.x + designer.getOuterLeft());
                    bounds.y += (rect.y + designer.getOuterTop());
                    Component editorComponent = current_editor.getEditorComponent();
                    editorComponent.setBounds(bounds);
                    if (editorComponent instanceof Container) {
                        Util.layoutContainer((Container) editorComponent);
                    }
                    designer.add(editorComponent);
                    designer.invalidate();
                    Object v = current_adapter.getBeanValue();
                    current_editor.setValue(v);
                    editorComponent.requestFocus();
                    designer.repaint();
                }
            }
        }
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }

    private boolean stopEditing() {
        if (current_editor != null) {
            try {
                Object value = current_editor.getValue();
                current_adapter.validateBeanValue(value);
                Object old_value = current_adapter.getBeanValue();
                if (Util.isChanged(old_value, value)) {
                    current_adapter.setBeanValue(value);
                    DesignerEvent evt = new DesignerEvent(designer);
                    evt.setAffectedComponent(current_bean);
                    designer.getEditListenerTable().fireComponentEdited(evt);
                }
                designer.remove(current_editor.getEditorComponent());

                Container container = current_bean.getParent();

                if (container != null) {
                    Util.layoutContainer(container);
                }

                designer.invalidate();
                designer.repaint();
                current_editor.removeChangeListener(this);

                current_adapter = null;
                current_bean = null;
                current_editor = null;
                return true;
            } catch (ValidationException e) {
                JOptionPane.showMessageDialog(designer, e.getMessage(), "Error Message", JOptionPane.ERROR_MESSAGE);

                return false;
            }
        }

        return true;
    }

    public void stateChanged(ChangeEvent e) {
        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                stopEditing();
            }
        });
    }
}