package ch.asynk.helloworld;

import java.util.Date;

import com.vaadin.Application;
import com.vaadin.terminal.UserError;
import com.vaadin.terminal.Terminal;
import com.vaadin.terminal.SystemError;
import com.vaadin.terminal.ErrorMessage;
import com.vaadin.terminal.VariableOwner;
import com.vaadin.terminal.URIHandler;
import com.vaadin.terminal.ParameterHandler;
import com.vaadin.terminal.gwt.server.ChangeVariablesErrorEvent;
import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.util.ObjectProperty;
import com.vaadin.data.Validator;
import com.vaadin.data.validator.DoubleValidator;
import com.vaadin.ui.FormLayout;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.ui.Window;
import com.vaadin.ui.Label;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.TextField;
import com.vaadin.ui.AbstractComponent;

class DataMappingLayout extends FormLayout {

    public DataMappingLayout() {
        //
        final TextField tf1 = new TextField("Property.ValueChangeListener");
        tf1.setImmediate(true);
        addComponent(tf1);
        final Label lb1 = new Label();
        lb1.setCaption("The Value");
        addComponent(lb1);
        tf1.addListener( new Property.ValueChangeListener() {
            @Override
            public void valueChange(ValueChangeEvent event) {
                String value = (String) tf1.getValue();
                lb1.setValue(value);
            }
        });
        //
        Double trouble = 66.6;
        final ObjectProperty<Double> property = new ObjectProperty<Double>(trouble);
        final TextField tf2 = new TextField("ObjectProperty + Validator", property);
        tf2.setImmediate(true);
        tf2.addValidator( new DoubleValidator("It should be a double") );
        //tf2.setValidationVisible(false);    // nothing will happen
        addComponent(tf2);
        final Label lb2 = new Label(property);
        lb2.setCaption("The Value");
        addComponent(lb2);
        //
        final TextField tf3 = new TextField("No spaces");
        addComponent(tf3);
        tf3.setComponentError(null); // (actually the default)
        final Button b1 = new Button("Ok!");
        addComponent(b1);
        b1.addListener(new Button.ClickListener() {
            @Override
            public void buttonClick(ClickEvent event) {
                if (! ((String) tf3.getValue()).matches("^\\w*$")) {
                    tf3.setComponentError(new UserError("Must be letters and numbers"));
                } else {
                    tf3.setComponentError(null);
                }
            }
        });
        //
        // final Validator intValidator = new Validator() { ... }
        class MyIntValidator implements Validator {
            public boolean isValid(Object value) {
                if (value == null || !(value instanceof String)) {
                    return false;
                }
                return ((String) value).matches("[1-9][0-9]{4}");
            }
            public void validate(Object value) throws InvalidValueException {
                if (!isValid(value)) {
                    if (value != null && value.toString().startsWith("0")) {
                        throw new InvalidValueException("Must not start with a zero.");
                    } else {
                        throw new InvalidValueException("Must be a number 10000-99999.");
                    }
                }
            }
        };
        final TextField tf5 = new TextField("MyIntValidator");
        tf5.addValidator(new MyIntValidator());
        tf5.setImmediate(true);
        addComponent(tf5);
        //
        class IntegerObjectProperty implements Property {
            Integer data = 0;
            boolean readOnly = false;
            public Class<?> getType() {
                return Integer.class;
            }
            public Object getValue() {
                return data;
            }
            public boolean isReadOnly() {
                return readOnly;
            }
            public void setReadOnly(boolean newStatus) {
                readOnly = newStatus;
            }
            public void setValue(Object newValue) throws ReadOnlyException, ConversionException {
                if (readOnly)
                    throw new ReadOnlyException();
                if (newValue instanceof Integer)
                    data = (Integer) newValue;
                else if (newValue instanceof String)
                    try {
                        data = Integer.parseInt((String) newValue, 16);
                    } catch (NumberFormatException e) {
                        throw new ConversionException("Must be an integer (from property)");
                    }
                else
                    throw new ConversionException("Unknown entry type (from property)");
            }
            @Override
            public String toString() {
                return Integer.toHexString(data)+" (hex)";
            }
        };
        final IntegerObjectProperty intProperty = new IntegerObjectProperty();
        intProperty.setValue(666);
        final TextField tf4 = new TextField("MyObjectProperty",intProperty);
        tf4.setImmediate(true);
        tf4.setErrorHandler(new ComponentErrorHandler() {
            @Override
            public boolean handleComponentError(ComponentErrorEvent event) {
                tf4.setComponentError(new UserError("Must be an integer (from handler)"));
                return true;
            }
        });
        addComponent(tf4);
        //
        Button closeButton = new Button("close the application");
        closeButton.setDescription("This will close the application");
        addComponent(closeButton );
        closeButton.addListener( new Button.ClickListener() {
            @Override
            public void buttonClick(ClickEvent event) {
                getApplication().getMainWindow().getApplication().close();
            }
        });
    }
}

class MainLayout extends VerticalLayout {

    public MainLayout() {
        Label label = new Label("Hello world");
        addComponent(label);
        //
        addComponent( new Button("What is the time?", new Button.ClickListener() {
            @Override
            public void buttonClick(ClickEvent event) {
                getApplication().getMainWindow().showNotification("The time is " + new Date(), "<i>italic</i> <b>bold</b> description",Window.Notification.TYPE_WARNING_MESSAGE);
                event.getButton().setComponentError( new UserError("Stop pressing this button !!") );
            }
        }));
        ///
        Button exceptionButton = new Button("throw an exception");
        addComponent(exceptionButton );
        exceptionButton.addListener( new Button.ClickListener() {
            @Override
            public void buttonClick(ClickEvent event) {
                throw new RuntimeException("Wahou !! : exception");
            }
        });
        //
        Button nextButton = new Button("next layout");
        nextButton.setDescription("Go to next layout");
        addComponent(nextButton );
        nextButton.addListener( new Button.ClickListener() {
            @Override
            public void buttonClick(ClickEvent event) {
                getApplication().getMainWindow().setContent( new DataMappingLayout() );
            }
        });
    }

}

public class HelloWorldApp extends Application {
    private static final long serialVersionUID = 1L;

    @Override
    public void init() {
        final Window mainWindow = new Window("Hello World Application");
        mainWindow.setContent( new MainLayout() );
        setMainWindow(mainWindow);
        setLogoutURL("http://asynk.ch");
    }

    @Override
    public void terminalError(Terminal.ErrorEvent event) {
        // Call the default implementation.
        //super.terminalError(event);
        // http://dev.vaadin.com/browser/releases/6.6.6/src/com/vaadin/Application.java#L1190
        final Throwable t = event.getThrowable();
        Object owner = null;
        if (event instanceof VariableOwner.ErrorEvent) {
            owner = ((VariableOwner.ErrorEvent) event).getVariableOwner();
        } else if (event instanceof URIHandler.ErrorEvent) {
            owner = ((URIHandler.ErrorEvent) event).getURIHandler();
        } else if (event instanceof ParameterHandler.ErrorEvent) {
            owner = ((ParameterHandler.ErrorEvent) event).getParameterHandler();
        } else if (event instanceof ChangeVariablesErrorEvent) {
            owner = ((ChangeVariablesErrorEvent) event).getComponent();
        }
        if (owner instanceof AbstractComponent) {
            if (t instanceof ErrorMessage) {
                ((AbstractComponent) owner).setComponentError((ErrorMessage)t);
            } else {
                //((AbstractComponent) owner).setComponentError(new SystemError(t));
                ((AbstractComponent) owner).setComponentError(new UserError("User Error!"));
            }
        }
        // Some custom behaviour.
        if (getMainWindow() != null) {
            getMainWindow().showNotification("An unchecked exception occured!", event.getThrowable().toString(), Window.Notification.TYPE_ERROR_MESSAGE);
        }
    }
}