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

import javafx.beans.Observable;
import javafx.beans.binding.Bindings;
import javafx.beans.binding.StringExpression;
import javafx.beans.property.Property;
import javafx.beans.value.ObservableValue;
import javafx.util.Callback;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.fx.core.databinding.AdapterFactory;

// TODO: Auto-generated Javadoc
/**
 * The Class CallBackMultiRelationWithCriteria.
 *
 * @param <T> the generic type
 */
public class CallBackMultiRelationWithCriteria<T> implements Callback<Object, Object> {

    /** The master value property. */
    private final IValueProperty masterValueProperty;

    /** The detail value property. */
    private final IValueProperty detailValueProperty;

    /** The converter. */
    private final IConverter converter;

    /**
     * Instantiates a new call back.
     *
     * @param masterValueProperty the master value property
     * @param detailValueProperty the detail value property
     * @param converter the converter
     */
    public CallBackMultiRelationWithCriteria(IValueProperty masterValueProperty, IValueProperty detailValueProperty, IConverter converter) {
        this.masterValueProperty = masterValueProperty;
        this.detailValueProperty = detailValueProperty;
        this.converter = converter;
    }

    /**
     * {@inheritDoc}
     */
    @SuppressWarnings({ "unchecked" })
    @Override
    public ObservableValue<T> call(Object valueSource) {
        final IObservableValue masterValueObs = this.masterValueProperty.observe(valueSource);

        // When the attribute is a reference with a multiplicity >1
        final Object masterValue = masterValueObs.getValue();

        if (masterValue instanceof EObjectContainmentEList<?>) {

            final EObjectContainmentEList<?> e = (EObjectContainmentEList<?>) masterValue;

            final List<Observable> dependencies = new ArrayList<>();
            // We wrap the EMF property into a javafx
            // property for each element of the list
            for (final Object value : e) {
                final IObservableValue observableValue = this.detailValueProperty.observe(value);
                final ObservableValue<T> tmp = AdapterFactory.adapt(observableValue);
                dependencies.add(tmp);
            }

            // When the previous EMF property change, the javafx
            // property change and so the String expression is
            // recompute.The new computation consist in a new
            // conversion and the addition of a delimiter
            final StringExpression se = Bindings.createStringBinding(() -> {
                final StringBuilder sb = new StringBuilder();
                for (int i = 0; i < e.size(); i++) {

                    final Object containement = e.get(i);

                    if (containement instanceof Property) {
                        sb.append(((Property<?>) containement).getValue());
                    }
                    else {
                        final T value = ((T) containement);
                        final String valueConvert = this.converter.convert(value).toString();
                        sb.append(valueConvert);
                    }

                    if ((i + 1) < e.size()) {
                        sb.append("\n ");
                    }
                }
                return sb.toString();
            }, dependencies.toArray(new Observable[dependencies.size()]));

            return (ObservableValue<T>) se;
        }

        return null;
    }

}