/*******************************************************************************

 * Copyright (c) 2008 Ovidio Mallo and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Ovidio Mallo - initial API and implementation (bug 175737)

 ******************************************************************************/

package org.eclipse.core.internal.databinding.observable.masterdetail;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import org.eclipse.core.databinding.observable.Diffs;

import org.eclipse.core.databinding.observable.ObservableTracker;

import org.eclipse.core.databinding.observable.list.AbstractObservableList;

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.masterdetail.IObservableFactory;

import org.eclipse.core.databinding.observable.value.IObservableValue;

import org.eclipse.core.databinding.observable.value.IValueChangeListener;

import org.eclipse.core.databinding.observable.value.ValueChangeEvent;

/**

 *

 */

public class ListDetailObservableList extends AbstractObservableList {

	private IObservableList masterList;

	private IObservableFactory detailFactory;

	private Object detailType;

	private ArrayList detailList;

	private IListChangeListener masterListListener = new IListChangeListener() {

		public void handleListChange(ListChangeEvent event) {

			applyMasterListDiff(event.diff);

		}

	};

	private IValueChangeListener detailValueListener = new IValueChangeListener() {

		public void handleValueChange(ValueChangeEvent event) {

			handleDetailValueChange(event);

		}

	};

	/**

	 * 

	 * @param masterObservableList

	 * @param detailFactory

	 * @param detailType

	 */

	public ListDetailObservableList(IObservableList masterObservableList,

			IObservableFactory detailFactory, Object detailType) {

		super(masterObservableList.getRealm());

		this.masterList = masterObservableList;

		this.detailFactory = detailFactory;

		this.detailType = detailType;

		this.detailList = new ArrayList();

		masterObservableList.addListChangeListener(masterListListener);

		ListDiff initMasterDiff = Diffs.computeListDiff(Collections.EMPTY_LIST,

				masterObservableList);

		applyMasterListDiff(initMasterDiff);

	}

	private void applyMasterListDiff(ListDiff masterListDiff) {

		ListDiffEntry[] masterEntries = masterListDiff.getDifferences();

		ListDiffEntry[] detailEntries = new ListDiffEntry[masterEntries.length];

		for (int i = 0; i < masterEntries.length; i++) {

			ListDiffEntry masterEntry = masterEntries[i];

			int index = masterEntry.getPosition();

			Object detailValue;

			if (masterEntry.isAddition()) {

				// When adding a new master, we must create a new detail.

				Object masterElement = masterEntry.getElement();

				IObservableValue detail = (IObservableValue) detailFactory

						.createObservable(masterElement);

				// Perform the actual addition and add a value change listener.

				detailList.add(index, detail);

				detailValue = detail.getValue();

				detail.addValueChangeListener(detailValueListener);

			} else {

				// When removing an existing master, we remove and dispose the

				// corresponding detail.

				IObservableValue detail = (IObservableValue) detailList

						.remove(index);

				detailValue = detail.getValue();

				detail.dispose();

			}

			// Create the corresponding diff for the detail list.

			detailEntries[i] = Diffs.createListDiffEntry(index, masterEntry

					.isAddition(), detailValue);

		}

		// Fire a list change event with the adapted diffs on the detail list.

		fireListChange(Diffs.createListDiff(detailEntries));

	}

	private void handleDetailValueChange(ValueChangeEvent event) {

		IObservableValue detail = event.getObservableValue();

		for (int i = 0; i < detailList.size(); i++) {

			if (detailList.get(i) == detail) {

				Object oldValue = event.diff.getOldValue();

				Object newValue = event.diff.getNewValue();

				ListDiffEntry[] diffEntries = new ListDiffEntry[2];

				diffEntries[0] = Diffs.createListDiffEntry(i, false, oldValue);

				diffEntries[1] = Diffs.createListDiffEntry(i, true, newValue);

				fireListChange(Diffs.createListDiff(diffEntries));

				break;

			}

		}

	}

	protected int doGetSize() {

		return detailList.size();

	}

	public Object get(int index) {

		ObservableTracker.getterCalled(this);

		return ((IObservableValue) detailList.get(index)).getValue();

	}

	public Object set(int index, Object element) {

		IObservableValue detail = (IObservableValue) detailList.get(index);

		Object oldElement = detail.getValue();

		detail.setValue(element);

		return oldElement;

	}

	public Object getElementType() {

		return detailType;

	}

	public synchronized void dispose() {

		if (masterList != null) {

			masterList.removeListChangeListener(masterListListener);

		}

		if (detailList != null) {

			for (Iterator iter = detailList.iterator(); iter.hasNext();) {

				((IObservableValue) iter.next()).dispose();

			}

		}

		masterList = null;

		detailFactory = null;

		detailType = null;

		masterListListener = null;

		detailValueListener = null;

		super.dispose();

	}

}