/*=============================================================================#
 # Copyright (c) 2012, 2020 Stephan Wahlbrink and others.
 # 
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 # which is available at https://www.apache.org/licenses/LICENSE-2.0.
 # 
 # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 # 
 # Contributors:
 #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
 #=============================================================================*/

package org.eclipse.statet.rtm.base.ui.rexpr;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.databinding.IEMFObservable;
import org.eclipse.emf.databinding.edit.EMFEditProperties;
import org.eclipse.emf.databinding.edit.IEMFEditListProperty;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.MoveCommand;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.jface.databinding.swt.typed.WidgetProperties;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.databinding.viewers.ObservableValueEditingSupport;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.ViewerCell;
import org.eclipse.jface.viewers.ViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

import org.eclipse.statet.jcommons.lang.Nullable;

import org.eclipse.statet.ecommons.emf.core.IContext;
import org.eclipse.statet.ecommons.emf.core.databinding.IEMFEditContext;
import org.eclipse.statet.ecommons.emf.core.databinding.IEMFEditPropertyContext;
import org.eclipse.statet.ecommons.emf.ui.forms.EFProperty;
import org.eclipse.statet.ecommons.emf.ui.forms.IEFFormPage;
import org.eclipse.statet.ecommons.ui.components.ButtonGroup;
import org.eclipse.statet.ecommons.ui.content.ElementSourceSelectionProvider;
import org.eclipse.statet.ecommons.ui.util.SelectionTransferDragAdapter;
import org.eclipse.statet.ecommons.ui.viewers.ViewerUtils;
import org.eclipse.statet.ecommons.ui.viewers.ViewerUtils.TableComposite;

import org.eclipse.statet.rtm.base.ui.editors.RtFormToolkit;
import org.eclipse.statet.rtm.base.util.RExprTypes;
import org.eclipse.statet.rtm.rtdata.types.RTypedExpr;


public class RExprListProperty extends EFProperty implements ButtonGroup.IActions<RTypedExpr> {
	
	
	private class RExprEditing extends ObservableValueEditingSupport<RTypedExpr, RTypedExpr, String> {
		
		
		private CellEditor cellEditor;
		
		
		public RExprEditing() {
			super(RExprListProperty.this.widget.viewer, RExprListProperty.this.getDataBindingContext());
		}
		
		
		@Override
		protected CellEditor getCellEditor(final Object element) {
			if (element instanceof RTypedExpr) {
				if (this.cellEditor == null) {
					this.cellEditor= createRExprCellEditor();
				}
				return this.cellEditor;
			}
			return null;
		}
		
		protected CellEditor createRExprCellEditor() {
			final TextCellEditor editor= new TextCellEditor((Composite) getViewer().getControl());
//			editor.setValidator(new RIdentifierCellValidator());
			return editor;
		}
		
		@Override
		protected IObservableValue<String> doCreateCellEditorObservable(final CellEditor cellEditor) {
			return WidgetProperties.text(SWT.Modify)
					.observe(((TextCellEditor)this.cellEditor).getControl());
		}
		
		@Override
		protected Binding createBinding(final IObservableValue<String> target, final IObservableValue<RTypedExpr> model) {
			return getDataBindingContext().bindValue(
					target,
					model,
					new UpdateValueStrategy<String, @Nullable RTypedExpr>(UpdateValueStrategy.POLICY_CONVERT)
							.setConverter(new String2RTypedExprConverter(RExprListProperty.this.types.getDefaultTypeKey())),
					new UpdateValueStrategy<@Nullable RTypedExpr, String>()
							.setConverter(new RExpr2StringConverter()) );
		}
		
		@Override
		protected IObservableValue<RTypedExpr> doCreateElementObservable(final RTypedExpr element, final ViewerCell cell) {
			return new AbstractObservableValue<RTypedExpr>() {
				RTypedExpr value= element;
				@Override
				public Object getValueType() {
					return RTypedExpr.class;
				}
				@Override
				protected RTypedExpr doGetValue() {
					return this.value;
				}
				@Override
				protected void doSetValue(final @Nullable RTypedExpr value) {
					final int index= getIndex(value);
					final CommandStack commandStack= getEditingDomain().getCommandStack();
					final IEMFObservable emfObservable= (IEMFObservable) RExprListProperty.this.modelObservable;
					Command command;
					if (value == null) {
						if (index >= 0) {
							RExprListProperty.this.modelObservable.remove(index);
						}
						return;
					}
					else {
						if (index >= 0) {
							command= SetCommand.create(getEditingDomain(),
									emfObservable.getObserved(), getEFeature(),
									value, index );
	//						this.modelObservable.set(index, value);
						}
						else {
	//						command= AddCommand.create(this.context.getEditingDomain(),
	//								emfObservable.getObserved(), emfObservable.getStructuralFeature(),
	//								value );
							RExprListProperty.this.modelObservable.add(value);
							return;
						}
					}
					commandStack.execute(command);
				}
			};
		}
		
	}
	
	
	private final IRExprTypesUIProvider provider;
	private final RExprTypes types;
	private List<RExprTypeUIAdapter> typeUIAdapters;
	
	private TableComposite widget;
	private ButtonGroup<RTypedExpr> buttonGroup;
	
	private IObservableList<RTypedExpr> modelObservable;
	
	
	public RExprListProperty(final String label, final String tooltip,
			final EClass eClass, final EStructuralFeature eFeature,
			final IRExprTypesUIProvider provider) {
		super(label, tooltip, eClass, eFeature);
		
		this.provider= provider;
		this.types= provider.getTypes(getEClass(), getEFeature());
	}
	
	
	protected IRExprTypesUIProvider getProvider() {
		return this.provider;
	}
	
	@Override
	public void create(final Composite parent, final IEFFormPage page) {
		final IRExprTypesUIProvider provider= getProvider();
		this.typeUIAdapters= provider.getUIAdapters(this.types, getEClass(), getEFeature() );
		final RtFormToolkit toolkit= (RtFormToolkit) page.getToolkit();
		
		toolkit.createPropLabel(parent, getLabel(), getTooltip(), 3);
		
		this.widget= toolkit.createPropSingleColumnTable(parent, 6, 25);
		
		this.widget.viewer.setContentProvider(new ObservableListContentProvider());
		final ViewerColumn column= this.widget.getViewerColumn(0);
		column.setLabelProvider(new RExprLabelProvider(this.typeUIAdapters));
		
		this.buttonGroup= new ButtonGroup<>(parent, this, true);
		this.buttonGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
		
		customizeButtonGroup(this.buttonGroup);
	}
	
	protected void customizeButtonGroup(final ButtonGroup<RTypedExpr> buttonGroup) {
		buttonGroup.addAddButton(null);
		buttonGroup.addDeleteButton(null);
		buttonGroup.addSeparator();
		buttonGroup.addUpButton(null);
		buttonGroup.addDownButton(null);
	}
	
	@Override
	public Control getControl() {
		return this.widget;
	}
	
	public TableViewer getViewer() {
		return this.widget.viewer;
	}
	
	
	@Override
	public RTypedExpr edit(final int command, final RTypedExpr item, final Object parent) {
		switch(command) {
		case ButtonGroup.ADD_NEW:
			return new RTypedExpr(this.types.getDefaultTypeKey(), ""); //$NON-NLS-1$
		case ButtonGroup.EDIT:
			return item;
		default:
			return null;
		}
	}
	
	@Override
	public void updateState(final IStructuredSelection selection) {
	}
	
	@Override
	public void bind(final IEMFEditContext context) {
		super.bind(context);
		
		final IEMFEditListProperty emfProperty= EMFEditProperties.list(getEditingDomain(),
				getEFeature() );
		this.modelObservable= emfProperty.observeDetail(getBaseObservable());
		
		this.widget.viewer.setInput(this.modelObservable);
		this.buttonGroup.connectTo(this.widget.viewer, this.modelObservable, null);
		
		final ViewerColumn column= this.widget.getViewerColumn(0);
		column.setEditingSupport(new RExprEditing());
		ViewerUtils.installDefaultEditBehaviour2(this.widget.viewer);
		
		final ElementSourceSelectionProvider extSelectionProvider= new ElementSourceSelectionProvider(
				this.widget.viewer, this );
		{	final int operations= (DND.DROP_DEFAULT | DND.DROP_COPY | DND.DROP_MOVE);
			final Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getTransfer() };
			this.widget.viewer.addDragSupport(operations, transfers, new SelectionTransferDragAdapter(
					extSelectionProvider ));
			this.widget.viewer.addDropSupport(operations, transfers, new RExprViewerDropAdapter(
					this.widget.viewer, this.typeUIAdapters, this ) {
				@Override
				protected boolean canMove(final IContext source, final Object input) {
					final IEMFEditPropertyContext sourcePropertyContext= source.getAdapter(IEMFEditPropertyContext.class);
					return (sourcePropertyContext != null
							&& getEditingDomain() == sourcePropertyContext.getEditingDomain());
				}
				@Override
				protected int getIndex(final Object element) {
					return RExprListProperty.this.modelObservable.indexOf(element);
				}
				@Override
				protected void insertExprs(final List<RTypedExpr> exprs, final int index, final int time) {
					if (index >= 0) {
						RExprListProperty.this.modelObservable.addAll(index, exprs);
					}
					else {
						RExprListProperty.this.modelObservable.addAll(exprs);
					}
				}
				@Override
				protected void moveExprs(final IContext source, final List<RTypedExpr> exprs, final int index, final int time) {
					final IEMFEditPropertyContext sourceContext= (IEMFEditPropertyContext) source;
					
					final EObject owner= (EObject) ((IObserving) RExprListProperty.this.modelObservable).getObserved();
					final IObservable sourceObservable= sourceContext.getPropertyObservable();
					if (owner == null || sourceObservable == null) {
						return;
					}
					Command command;
					
					if (sourceObservable == RExprListProperty.this.modelObservable) {
						if (exprs.size() == 1) {
							final RTypedExpr expr= exprs.get(0);
							final int oldIndex= getIndex(expr);
							if (oldIndex < 0) {
								return;
							}
							command= MoveCommand.create(getEditingDomain(),
									owner, getEFeature(), expr, (oldIndex < index) ? index - 1 : index );
						}
						else {
							final CompoundCommand compound= new CompoundCommand();
							final List<RTypedExpr> after= new ArrayList<>(exprs.size());
							for (final RTypedExpr expr : exprs) {
								final int oldIndex= getIndex(expr);
								if (oldIndex < 0) {
									continue;
								}
								if (oldIndex < index) {
									compound.append(MoveCommand.create(getEditingDomain(),
											owner, getEFeature(), expr, index - 1 ));
								}
								else {
									after.add(expr);
								}
							}
							for (final RTypedExpr expr : after) {
								compound.append(MoveCommand.create(getEditingDomain(),
										owner, getEFeature(), expr, index ));
							}
							command= compound;
						}
					}
					else {
						final EObject oldOwner= (EObject) ((IObserving) sourceObservable).getObserved();
						final CompoundCommand compound= new CompoundCommand();
						compound.append(AddCommand.create(getEditingDomain(),
								owner, getEFeature(), exprs));
						compound.append(RemoveCommand.create(getEditingDomain(),
								oldOwner, sourceContext.getEFeature(), exprs));
						command= compound;
					}
					
					getEditingDomain().getCommandStack().execute(command);
				}
			});
		}
		
		if (!this.modelObservable.isEmpty()) {
			this.widget.viewer.setSelection(new StructuredSelection(this.modelObservable.get(0)));
		}
		else {
			this.buttonGroup.updateState();
		}
	}
	
	protected int getIndex(final Object element) {
		for (int i= 0; i < this.modelObservable.size(); i++) {
			if (this.modelObservable.get(i) == element) {
				return i;
			}
		}
		return this.modelObservable.indexOf(element);
	}
	
	@Override
	public IObservableList getPropertyObservable() {
		return this.modelObservable;
	}
	
}