/*******************************************************************************
 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
 * in Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.scenegraph.swing;

import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.List;

import javax.swing.JComponent;
import javax.swing.JFormattedTextField;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerListModel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import org.simantics.scenegraph.utils.DummyComponent;

public class SpinnerNode extends ComponentNode<JSpinner> implements ChangeListener, FocusListener, PropertyChangeListener, KeyListener {
    /**
     * 
     */
    private static final long serialVersionUID = 7073028693751719102L;

    protected boolean editable = true;
    protected Object value = "";
    protected String tooltip = "";
    protected double borderWidth = 0;

    protected transient ActionListener actionListener = null;

    protected Font font = null;
    protected Color color = null;
    protected List<String> items = null;
    
    @Override
    public String toString() {
        return super.toString() + "[editable=" + editable + ", value=" + value + "]";
    }
    
    @Override
    public void init() {
        component = new JSpinner(new SpinnerListModel());
        component.setEnabled(editable);
        component.addChangeListener(this);
        component.setVisible(true);
        component.addFocusListener(this);
        component.addKeyListener(this);
        component.setLocation(0, 0);
        
        JComponent editor = component.getEditor();
        if (editor instanceof JSpinner.DefaultEditor) {
        	JFormattedTextField ftf = ((JSpinner.DefaultEditor)editor).getTextField();
	        if (ftf != null ) {
	            ftf.setColumns(8); //specify more width than we need
	            ftf.setHorizontalAlignment(JTextField.LEFT);
	        }
        }

        super.init();
    }

    @SyncField("items")
    public void setItems(List<String> items) {
        this.items = items;
        SpinnerListModel model = (SpinnerListModel)component.getModel();
        model.setList(items);
    }
    
    @SyncField("editable")
    public void setEditable(boolean value) {
        this.editable = value;

        if(component != null) {
            component.setEnabled(value);
        }
    }

    @PropertySetter("Stroke Width")
    @SyncField("borderWidth")
    public void setBorderWidth(Float borderWidth) {
        this.borderWidth = borderWidth;
//        if(component != null) {
//            ((TextField)component).setBorder(borderWidth);
//        }
    }

    @SyncField("value")
    public void setValue(Object value) {
        this.value = value;
        // RemoteViewer does not have component initialized
        if (component != null && value != null) {
            System.out.println("SpinnerNode.setValue(" + value + ")");
            try {
            	component.setValue(value);
                component.repaint();
            } catch(IllegalArgumentException e) {
            	// FIXME..
            }
        }
    }

    @SyncField("tooltip")
    public void setToolTipText(String tooltip) {
        this.tooltip = tooltip;
        if (component != null) {
            component.setToolTipText(tooltip);
        }
    }

    @PropertySetter("Font")
    @SyncField("font")
    public void setFont(Font font) {
        this.font = font;
        if (component != null) {
            setComponentFont(font);
        }
    }

    @PropertySetter("Color")
    @SyncField("color")
    public void setColor(Color color) {
        this.color = color;
        if (component != null) {
            component.setForeground(color);
        }
    }

    public Object getValue() {
        return value;
    }

    public Font getFont() {
        return font;
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        if("value".equals(evt.getPropertyName()) && component != null) {
        	component.setValue(evt.getNewValue());
            component.repaint();
        } else if("editable".equals(evt.getPropertyName()) && component != null) {
            component.setEnabled((Boolean)evt.getNewValue());
        }
    }

    public void setActionListener(ActionListener actionListener) {
        this.actionListener = actionListener;
    }

    void loseFocus() {
        if (component != null)
            if (component.isFocusOwner())
                if (container.getParent() != null)
                    container.getParent().requestFocusInWindow(); // Lose focus
    }

    @Override
    public void focusGained(FocusEvent arg0) {
    }

    @Override
    public void focusLost(FocusEvent arg0) {
        if (component != null) {
            ActionEvent e = new ActionEvent(component, ActionEvent.ACTION_PERFORMED, (String) component.getValue());
            performAction(e);
        }
    }

    /**
     * Wrapper method to send event to serverside
     * 
     * @param e
     */
    @ServerSide
    public void performAction(ActionEvent e) {
        if (actionListener != null) {
            //System.out.println("MonitorNode.performAction(" + e + ")");
            actionListener.actionPerformed(e);
        }
    }

    @Override
    public void keyPressed(KeyEvent e) {
    }

    @Override
    public void keyTyped(KeyEvent e) {
    }

    @Override
    public void keyReleased(KeyEvent e) {
        if (e.getModifiers() == 0 && e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            // ESC without modifiers == CANCEL edit
            // TODO: signal about cancellation
            loseFocus();
        }
    }

    /**
     * Quick hack to test widget feature..
     * FIXME: Use existing methods or variables..
     * 
     * @param input
     */
    public void input(String input) {
        ActionEvent e = new ActionEvent(new DummyComponent(), ActionEvent.ACTION_PERFORMED, input);
        performAction(e);
    }

	@Override
	public void stateChanged(ChangeEvent e) {
        JSpinner spi = (JSpinner)e.getSource();
        try{
          spi.commitEdit();
        }
        catch (Exception ex){
          ex.printStackTrace();
        }
//		loseFocus();
	}
}