import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.beans.BeanProperties;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.junit.Test;

public class Main {

	private static class TestRealm extends Realm {
		@Override
		public boolean isCurrent() {
			return true;
		}
	}
	
	private PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
	
	private String model = "";
	
	private String target = "";

	public String getModel() {
		return model;
	}

	public void setModel(String model) {
		changeSupport.firePropertyChange("model", this.model, this.model = model);
	}

	public String getTarget() {
		return target;
	}

	public void setTarget(String target) {
		changeSupport.firePropertyChange("target", this.target, this.target = target);
	}
	
	public void setTargetSilent(String target) {
		this.target = target;
	}
	
	public void addPropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.addPropertyChangeListener(listener);
		
	}
	
	public void removePropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.removePropertyChangeListener(listener);
	}
	
	@Test
	@SuppressWarnings("unchecked")
	public void test() {
		final Realm realm = new TestRealm();
		final Main bean = new Main();
		final IObservableValue<String> modelValue = BeanProperties.value("model").observe(realm, bean);
		final IObservableValue<String> targetValue = BeanProperties.value("target").observe(realm, bean);
		final UpdateValueStrategy targetToModel = new UpdateValueStrategy();
		final DataBindingContext context = new DataBindingContext(realm);
		final Binding binding = context.bindValue(targetValue, modelValue, targetToModel, null);
		// Now register validator
		targetToModel.setAfterGetValidator(new IValidator() {
			@Override
			public IStatus validate(Object value) {
				String existingName = bean.getModel();
				if (existingName.equals(value)) {
					System.out.println("Validate Error: " + value);
					return new Status(IStatus.ERROR, "com.vector.databindingtest", "Invalid Value");
				}
				System.out.println("Validate Ok: " + value);
				return Status.OK_STATUS;
			}
		});
		assertEquals("", targetValue.getValue());
		assertEquals("", modelValue.getValue());

		// Everything is fine here
		bean.setTarget("Test");
		assertEquals("Test", bean.getModel());
		
		// Here, the target is changed without the observable beeing updated  
		bean.setTargetSilent("Anything");
		assertEquals("Test", bean.getModel());

		// calling "updateTargetToModel()" triggers the validator twice. 
		// This is a problem, when the binding contains a validator, whose state depends on the model value 
		// This is because the model value has changed with the first update.
		binding.updateTargetToModel();
		assertEquals("Anything", bean.getModel()); // model was updated successfully
		assertTrue(((IStatus)binding.getValidationStatus().getValue()).isOK()); // However, this will fail
	}
}