package de.eiswind.paris.client.core.databinding.validation;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.ValidationStatusProvider;
import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.core.databinding.validation.MultiValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider;
import org.eclipse.jface.databinding.viewers.ObservableValueEditingSupport;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;

public class TestApp {

	private DataBindingContext m_bindingContext;
	private Table table;
	protected Shell shell;

	private List<Bean> model = new ArrayList<Bean>();
	private TableViewer tableViewer;
	private TableViewerColumn col;
	private Label label;
	
	public class MyTableViewerValidator extends MultiValidator {

		private TableViewer viewer;
		private IObservableMap[] columns;
		private IObservableList models;

		public MyTableViewerValidator(TableViewer tableViewer,
				IObservableMap[] cols) {
			super();
			columns = cols;
			viewer = tableViewer;
			// models = WritableList.withElementType( TableObservable.class);
			// models.add(new TableObservable(viewer.getTable()));
		}

		@SuppressWarnings("unchecked")
		protected IStatus validate() {
			System.out.println("validateok");
			IStatus status = ValidationStatus.ok();
			for (IObservableMap map : columns) {
				ObservableTracker.getterCalled(map);
			}

			for (Object o : (Collection) viewer.getInput()) {
				Bean bean2 = (Bean) o;

				if (bean2.getMsg() == null || bean2.getMsg().length() == 0) {
					status = new Status(Status.ERROR, "mmm", "Must enter Text");
				}

			}

			return status;
		}
	}

	public class MyStatusChangeListener implements IValueChangeListener {
		private ValidationStatusProvider prov;
		

		public MyStatusChangeListener(ValidationStatusProvider p) {
			prov = p;
		}

		public void handleValueChange(ValueChangeEvent event) {

			IStatus vs = (IStatus) event.getObservableValue().getValue();

			changeMessage(vs);
		}
	}

	public class Bean {
		
		public Bean(){
			
		}
		private transient java.beans.PropertyChangeSupport propertySupport;
		private String msg;

		public String getMsg() {
			return msg;
		}

		public void setMsg(String msg) {
			Object old = this.msg;
			this.msg = msg;
			if (propertySupport != null)
				propertySupport.firePropertyChange("msg", old, msg);

		}

		public void addPropertyChangeListener(
				java.beans.PropertyChangeListener listener) {
			if (propertySupport == null)
				propertySupport = new java.beans.PropertyChangeSupport(this);
			propertySupport.addPropertyChangeListener(listener);
		}

		/**
		 * @generated
		 */
		public void addPropertyChangeListener(String property,
				java.beans.PropertyChangeListener listener) {
			if (propertySupport == null)
				propertySupport = new java.beans.PropertyChangeSupport(this);
			propertySupport.addPropertyChangeListener(property, listener);
		}

		/**
		 * @generated
		 */
		public void removePropertyChangeListener(
				java.beans.PropertyChangeListener listener) {
			if (propertySupport != null)
				propertySupport.removePropertyChangeListener(listener);
		}

		/**
		 * @generated
		 */
		public void removePropertyChangeListener(String property,
				java.beans.PropertyChangeListener listener) {
			if (propertySupport != null)
				propertySupport
						.removePropertyChangeListener(property, listener);
		}

	}

	public class MyInlineTextEditingSupport extends
			ObservableValueEditingSupport {
		private TextCellEditor cellEditor;
		private String propertyName;

		/**
		 * @param typeCol
		 * @param dbc
		 */
		public MyInlineTextEditingSupport(ColumnViewer typeCol,
				TextCellEditor editor, DataBindingContext dbc,
				String propertyName) {
			super(typeCol, dbc);
			cellEditor = editor;
			this.propertyName = propertyName;
		}

		protected CellEditor getCellEditor(Object element) {
			return cellEditor;
		}

		protected IObservableValue doCreateCellEditorObservable(
				CellEditor cellEditor) {
			return SWTObservables.observeText(cellEditor.getControl(),
					SWT.Modify);
		}

		protected IObservableValue doCreateElementObservable(Object element,
				ViewerCell cell) {
			return BeansObservables.observeValue(element, propertyName);
		}
	}

	/**
	 * Launch the application
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		Display display = Display.getDefault();
		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
			public void run() {
				try {
					TestApp window = new TestApp();
					window.open();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	public void changeMessage(IStatus vs) {
		System.out.println("Status: "+vs.getMessage());
		label.setText(vs.getMessage());
		
	}

	/**
	 * Open the window
	 */
	public void open() {
		final Display display = Display.getDefault();
		createModel();
		createContents();
		shell.open();
		shell.layout();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
	}

	private void createModel() {
		Bean b = new Bean();
		model.add(b);

	}

	/**
	 * Create contents of the window
	 */
	protected void createContents() {
		shell = new Shell();
		shell.setLayout(new GridLayout());
		shell.setSize(500, 375);
		shell.setText("SWT Application");

		label = new Label(shell, SWT.NONE);
		label.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
		label.setText("Label");

		tableViewer = new TableViewer(shell, SWT.BORDER);
		table = tableViewer.getTable();
		table.setLinesVisible(true);
		table.setHeaderVisible(true);
		table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		col = new TableViewerColumn(tableViewer, SWT.NONE);
		col.getColumn().setWidth(100);
		m_bindingContext = initDataBindings();

		//
	}

	protected DataBindingContext initDataBindings() {
		//
		ObservableListContentProvider tableViewerContentProviderList = new ObservableListContentProvider();
		tableViewer.setContentProvider(tableViewerContentProviderList);
		//
		IObservableMap[] tableViewerLabelProviderMaps = BeansObservables
				.observeMaps(tableViewerContentProviderList.getKnownElements(),
						Bean.class, new String[] { "msg" });
		tableViewer.setLabelProvider(new ObservableMapLabelProvider(
				tableViewerLabelProviderMaps));
		//
		WritableList modelWritableList = new WritableList(model, Bean.class);
		tableViewer.setInput(modelWritableList);
		//
		DataBindingContext bindingContext = new DataBindingContext();
		TextCellEditor infoValueEditor = new TextCellEditor(
				(Composite) tableViewer.getControl());
		MyInlineTextEditingSupport textSupp = new MyInlineTextEditingSupport(
				tableViewer, infoValueEditor, bindingContext, "msg");
		col.setEditingSupport(textSupp);
		//
		bindingContext.addValidationStatusProvider(new MyTableViewerValidator(
				tableViewer, tableViewerLabelProviderMaps));
		
		bindingContext.getValidationStatusProviders().addListChangeListener(new IListChangeListener(){
			private Map<IObservableValue, MyStatusChangeListener> listenersAttached = new HashMap<IObservableValue, MyStatusChangeListener>();
			public void handleListChange(ListChangeEvent event) {
				ListDiff diff = event.diff;
				for (ListDiffEntry e : diff.getDifferences()) {
					ValidationStatusProvider p = (ValidationStatusProvider) e
							.getElement();

					if (e.isAddition()) {

						IObservableValue validationStatus = p.getValidationStatus();
						MyStatusChangeListener listener = new MyStatusChangeListener(p);
						validationStatus.addValueChangeListener(listener);
						listenersAttached.put(validationStatus, listener);
					} else {
						IObservableValue validationStatus = p.getValidationStatus();
						MyStatusChangeListener listener = listenersAttached
								.get(validationStatus);
						validationStatus.removeValueChangeListener(listener);
						listenersAttached.remove(validationStatus);
						
						label.setText("removed");
					}
				}

			}
		})
		;
		return bindingContext;
	}

}