//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation 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:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.uma.ecore.util;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

/**
 * 
 * @author Phong Nguyen Le
 * @since 1.5
 *
 */
public abstract class AbstractOppositeFeatureManager {
	protected Map<Class<?>, Set<OppositeFeature>> classOppositeFeaturesMap = new HashMap<Class<?>, Set<OppositeFeature>>();

	/**
	 * Maps EStructuralFeature objects to OppositeFeature objects.
	 */
	protected Map<EStructuralFeature, OppositeFeature> featureOppositeFeatureMap = new HashMap<EStructuralFeature, OppositeFeature>();

	/**
	 * Gets the opposite feature for the given feature.
	 * 
	 * @param feature
	 *            an EMF <code>EStructuralFeature</code> feature
	 * @return an opposite feature that is based on the given feature
	 */
	public OppositeFeature getOppositeFeature(
			EStructuralFeature feature) {
		return (OppositeFeature) featureOppositeFeatureMap.get(feature);
	}

	/**
	 * Registers the given opposite feature.
	 * 
	 * @param oppositeFeature
	 *            the opposite feature to register
	 */
	public void registerOppositeFeature(
			OppositeFeature oppositeFeature) {
		Class<?> cls = oppositeFeature.getOwnerClass();
		Set<OppositeFeature> features = classOppositeFeaturesMap.get(cls);
		if (features == null) {
			features = new HashSet<OppositeFeature>();
			classOppositeFeaturesMap.put(cls, features);
		}
		features.add(oppositeFeature);

		featureOppositeFeatureMap.put(oppositeFeature.getTargetFeature(),
				oppositeFeature);
	}
	
	private ArrayList<OppositeFeature> predefinedOppositeFeatures;

	protected AbstractOppositeFeatureManager() {
		registerPredefinedOppositeFeatures();
	}
	
	/**
	 * Registers the predefined opposite features.
	 */
	private void registerPredefinedOppositeFeatures() {
		predefinedOppositeFeatures = new ArrayList<OppositeFeature>();
		Field[] fields = getClass().getFields();
		for (int i = 0; i < fields.length; i++) {
			Field field = fields[i];
			int mod = field.getModifiers();
			if (Modifier.isPublic(mod) && Modifier.isStatic(mod)
					&& Modifier.isFinal(mod)
					&& field.getType() == OppositeFeature.class) {
				try {
					predefinedOppositeFeatures.add((OppositeFeature) field.get(this));
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				}
			}
		}

		for (OppositeFeature feature : predefinedOppositeFeatures) {
			registerOppositeFeature(feature);
		}
	}

	/**
	 * Gets the predefined opposite features.
	 * 
	 * @return the predefined opposite features
	 */
	public Collection<OppositeFeature> getPredefinedOppositeFeatures() {
		return predefinedOppositeFeatures;
	}

	/**
	 * Gets the value of an opposite feature.
	 * 
	 * @param feature
	 *            an opposite feature
	 * @return the value for the specified opposite feature
	 */
	public Object getOppositeFeatureValue(EObject eObject, OppositeFeature feature) {
		OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(eObject);
		if(adapter == null) {
			throw new IllegalArgumentException("Object is not managed by this manager.");
		}
		return adapter.getOppositeFeatureValue(feature);
	}

	/**
	 * Gets all the opposite features associated with this model object.
	 * 
	 * @return a collection of opposite features
	 */
	public Collection<OppositeFeature> getOppositeFeatures(EObject eObject) {
		OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(eObject);
		if(adapter == null) {
			throw new IllegalArgumentException("Object is not managed by this manager.");
		}
		return adapter.getOppositeFeatures();
	}
	
	public void manage(EObject eObject) {
		OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(eObject);
		if(adapter == null) {
			adapter = createOppositeFeatureAdapter();
			eObject.eAdapters().add(adapter);
		}
	}
	
	protected OppositeFeatureAdapter createOppositeFeatureAdapter() {
		return new OppositeFeatureAdapter(); 
	}
	
	public void release(EObject eObject) {
		OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(eObject);
		if(adapter != null) {
			eObject.eAdapters().remove(adapter);
		}
	}
	
	private OppositeFeatureAdapter getOppositeFeatureAdapter(EObject eObject) {
		for (Adapter adapter : new ArrayList<Adapter>(eObject.eAdapters())) {
			if(adapter instanceof OppositeFeatureAdapter) {
				return (OppositeFeatureAdapter) adapter;
			}
		}
		return null;
	}
	
	/**
	 * Removes all opposite features registered with the system.
	 */
	public void removeFromAllOppositeFeatures(EObject eObject) {
		// find all features that have opposite features and clear those
		// features. This will remove the references to
		// unloaded object by those opposite features
		//
		for (Iterator iter = eObject.eClass().getEAllReferences().iterator(); iter
				.hasNext();) {
			EReference ref = (EReference) iter.next();
			OppositeFeature oppositeFeature = OppositeFeature.getOppositeFeature(ref);
			if(oppositeFeature != null) {
				if(ref.isMany()) {
					List list = (List) eObject.eGet(ref, false);					
					if(!list.isEmpty()) {
						if(!oppositeFeature.resolveOwner()) {
							list.clear();
						}
						else if(list instanceof InternalEList) {
							List basicList = ((InternalEList)list).basicList();
							for(int i = basicList.size() - 1; i > -1; i--) {
								EObject e = (EObject) basicList.get(i);
								if(!e.eIsProxy()) {
									list.remove(e);
								}
							}
						}
					}
				}
				else {
					EObject e = (EObject) eObject.eGet(ref, false);
					if(e != null && !e.eIsProxy()) {
						eObject.eSet(ref, null);
					}
				}
			}
		}

	}

	
	protected class OppositeFeatureAdapter extends AdapterImpl {
		private static final boolean DEBUG = false;
		
		/**
		 * A map of entries of OppositeFeature / OppositeFeature's value
		 */
		private Map<OppositeFeature, Object> oppositeFeatureMap;

		private boolean hasOppositeFeature = true;

		
		protected OppositeFeatureAdapter() {
		}
		
		@Override
		public void notifyChanged(Notification msg) {
			if (msg.getEventType() == Notification.RESOLVE) {
				return;
			}
			
			Object f = msg.getFeature();
			if (f instanceof EStructuralFeature) {
				EStructuralFeature feature = (EStructuralFeature) f;
				OppositeFeature oppositeFeature = getOppositeFeature(feature);
				if (oppositeFeature != null) {
					EObject oldOtherEnd;
					EObject otherEnd;
					if (oppositeFeature.isMany()) {
						switch (msg.getEventType()) {
						case Notification.SET:
							oldOtherEnd = (EObject) msg.getOldValue();
							if (oppositeFeature.resolveOwner()) {
								oldOtherEnd = (EObject) resolve(oldOtherEnd);
							}
							if (oldOtherEnd != null) {
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(oldOtherEnd);
								adapter.oppositeRemove(oppositeFeature, msg
										.getNotifier());
							}
						case Notification.ADD:
							otherEnd = (EObject) msg.getNewValue();
							if (oppositeFeature.resolveOwner()) {
								otherEnd = (EObject) resolve(otherEnd);
								replace(feature, msg.getNewValue(), otherEnd);
							}
							if (otherEnd != null) {
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								adapter.oppositeAdd(oppositeFeature, msg
										.getNotifier());
							}
							break;
						case Notification.ADD_MANY:
							for (Iterator iter = ((Collection) msg.getNewValue())
									.iterator(); iter.hasNext();) {
								Object obj = iter.next();
								otherEnd = (EObject) obj;
								if (oppositeFeature.resolveOwner()) {
									otherEnd = (EObject) resolve(otherEnd);
									replace(feature, obj, otherEnd);
								}
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								adapter.oppositeAdd(oppositeFeature, msg
										.getNotifier());
							}
							break;
						case Notification.REMOVE:
							otherEnd = (EObject) msg.getOldValue();
							if (oppositeFeature.resolveOwner()) {
								otherEnd = (EObject) resolve(otherEnd);
							}
							if (otherEnd != null) {
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								adapter.oppositeRemove(oppositeFeature, msg
										.getNotifier());
							}
							break;
						case Notification.REMOVE_MANY:
							for (Iterator<?> iter = ((Collection) msg.getOldValue())
									.iterator(); iter.hasNext();) {
								otherEnd = (EObject) iter.next();
								if (oppositeFeature.resolveOwner()) {
									otherEnd = (EObject) resolve(otherEnd);
								}
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								adapter.oppositeRemove(oppositeFeature, msg
										.getNotifier());
							}
							break;
						}
					} else {
						switch (msg.getEventType()) {
						case Notification.ADD_MANY:
							for (Iterator<?> iter = ((Collection) msg.getNewValue())
									.iterator(); iter.hasNext();) {
								Object obj = iter.next();
								otherEnd = (EObject) obj;
								if (oppositeFeature.resolveOwner()) {
									otherEnd = (EObject) resolve(otherEnd);
									replace(feature, obj, otherEnd);
								}
								if (otherEnd != null) {
									OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
									EObject oldValue = (EObject) adapter
											.getOppositeFeatureMap().get(
													oppositeFeature);
									if (oldValue != null) {
										// remove otherEnd from target feature of
										// oldValue
										((Collection) oldValue
												.eGet((EStructuralFeature) f))
												.remove(otherEnd);
									}
									adapter.getOppositeFeatureMap().put(
											oppositeFeature, msg.getNotifier());
								}
							}
							break;
						case Notification.REMOVE_MANY:
							for (Iterator<?> iter = ((Collection) msg.getOldValue())
									.iterator(); iter.hasNext();) {
								otherEnd = (EObject) iter.next();
								if (oppositeFeature.resolveOwner()) {
									otherEnd = (EObject) resolve(otherEnd);
								}
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								adapter.getOppositeFeatureMap().put(
										oppositeFeature, null);
							}
							break;
						case Notification.ADD:
							otherEnd = (EObject) msg.getNewValue();
							if (oppositeFeature.resolveOwner()) {
								otherEnd = (EObject) resolve(otherEnd);
								replace(feature, msg.getNewValue(), otherEnd);
							}
							if (otherEnd != null) {
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								EObject oldValue = (EObject) adapter
										.getOppositeFeatureMap().get(
												oppositeFeature);
								if (oldValue != null) {
									// remove otherEnd from target feature of
									// oldValue
									((Collection) oldValue
											.eGet((EStructuralFeature) f))
											.remove(otherEnd);
								}
								adapter.getOppositeFeatureMap().put(
										oppositeFeature, msg.getNotifier());
							}
							break;
						case Notification.SET:
							otherEnd = (EObject) msg.getNewValue();
							if (oppositeFeature.resolveOwner()) {
								otherEnd = (EObject) resolve(otherEnd);
								replace(feature, msg.getNewValue(), otherEnd);
							}
							if (otherEnd != null) {
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								EObject oldValue = (EObject) adapter
										.getOppositeFeatureMap().get(
												oppositeFeature);
								if (oldValue != null) {
									// set the target feature of oldValue to null
									oldValue.eSet((EStructuralFeature) f, null);
								}
								adapter.getOppositeFeatureMap().put(
										oppositeFeature, msg.getNotifier());
							}
							else {
								EStructuralFeature targetFeature = (EStructuralFeature) f;
								if(!targetFeature.isMany()) {
									oldOtherEnd = (EObject) msg.getOldValue();
									if(oldOtherEnd != null) {
										OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(oldOtherEnd);
										adapter.getOppositeFeatureMap().put(oppositeFeature, null);
									}
								}
							}
							break;
						case Notification.REMOVE:
							// case Notification.UNSET:
							otherEnd = (EObject) msg.getOldValue();
							if (oppositeFeature.resolveOwner()) {
								otherEnd = (EObject) resolve(otherEnd);
							}
							if (otherEnd != null) {
								OppositeFeatureAdapter adapter = getOppositeFeatureAdapter(otherEnd);
								adapter.getOppositeFeatureMap().put(
										oppositeFeature, null);
							}
							break;

						}
					}
				}
			}
		}
		
		/**
		 * Resolves the given proxy object.
		 * 
		 * @param object
		 *            a proxy object to resolve
		 * @return the resolved object
		 */
		protected Object resolve(Object object) {
			if (object instanceof InternalEObject
					&& ((InternalEObject) object).eIsProxy()) {
				return ((InternalEObject) getTarget()).eResolveProxy((InternalEObject) object);
			}
			return object;
		}

		@Override
		public void setTarget(Notifier newTarget) {
			if(target != null && newTarget != null) {
				throw new IllegalArgumentException("An OppositeFeatureAdapter cannot be associated with 2 targets at the same time.");
			}
			super.setTarget(newTarget);
		}
		
		private Map<OppositeFeature, Object> createOppositeFeatureMap() {
			Map<OppositeFeature, Object> map = new HashMap<OppositeFeature, Object>();
			for (Map.Entry<Class<?>, Set<OppositeFeature>> entry : classOppositeFeaturesMap.entrySet()) {
				Class<?> cls = entry.getKey();
				if (cls.isInstance(getTarget())) {
					for (OppositeFeature oppositeFeature : entry.getValue()) {
						map.put(oppositeFeature, null);
					}
				}
			}
			if (map.isEmpty()) {
				hasOppositeFeature = false;
				return Collections.emptyMap();
			}
			return map;
		}
		
		/**
		 * Gets the opposite feature map.
		 * 
		 * @return a map containing the opposite features mapped to their values
		 */
		protected Map<OppositeFeature, Object> getOppositeFeatureMap() {
			if (oppositeFeatureMap == null && hasOppositeFeature) {
				oppositeFeatureMap = createOppositeFeatureMap();
			}
			if(oppositeFeatureMap == null) {
				return Collections.emptyMap();
			}
			return oppositeFeatureMap;
		}
		
		protected List<?> createOppositeFeatureValueList(EObject eObject, OppositeFeature oppositeFeature) {
			return new OppositeFeatureResolvingEList(eObject, oppositeFeature);
		}

		protected void oppositeAdd(OppositeFeature oppositeFeature, Object object) {
			List list = (List) getOppositeFeatureMap().get(oppositeFeature);
			if (list == null) {
				list = createOppositeFeatureValueList((EObject) getTarget(), oppositeFeature);
				getOppositeFeatureMap().put(oppositeFeature, list);
			}
			if (!list.contains(object)) {
				list.add(object);
			}
		}

		protected void oppositeRemove(OppositeFeature oppositeFeature, Object object) {
			List list = (List) getOppositeFeatureMap().get(oppositeFeature);
			if (list == null) {
				list = createOppositeFeatureValueList((EObject) getTarget(), oppositeFeature);
				getOppositeFeatureMap().put(oppositeFeature, list);
			}
			list.remove(object);
		}

		private void replace(EStructuralFeature feature, Object oldValue, EObject newValue) {
			if (newValue != null && !newValue.eIsProxy() && newValue != oldValue) {
				EObject eObject = (EObject) getTarget();
				boolean notify = eObject.eDeliver();
				try {
					eObject.eSetDeliver(false);
					EcoreUtil.replace(eObject, feature, oldValue, newValue);
				} catch (Exception e) {
					if (DEBUG) {
						CommonPlugin.INSTANCE.log(e);
						e.printStackTrace();
						System.out.println("OppositeFeatureAdapter.replace():"); //$NON-NLS-1$
						System.out.println("  object: " + eObject); //$NON-NLS-1$
						System.out.println("  feature: " + feature); //$NON-NLS-1$
						System.out.println("  proxy: " + oldValue); //$NON-NLS-1$
						System.out.println("  resolved: " + newValue); //$NON-NLS-1$
					}
				} finally {
					eObject.eSetDeliver(notify);
				}
			}

		}

		public Collection<OppositeFeature> getOppositeFeatures() {
			return getOppositeFeatureMap().keySet();
		}
		
		public Object getOppositeFeatureValue(OppositeFeature feature) {
			Object value = getOppositeFeatureMap().get(feature);

			// System.out.println("MultiResourceEObject.getOppositeFeatureValue():");
			// System.out.println(" feature: " + feature);
			// System.out.println(" value: " + value);
			// System.out.println(" this: " + this);

			if (feature.isMany()) {
				if (value == null) {
					return Collections.EMPTY_LIST;
				}

				return ((OppositeFeatureResolvingEList) value)
						.getUnmodifiableList();
			} else if (value instanceof EObject
					&& ((EObject) value).eResource() == null) {
				getOppositeFeatureMap().put(feature, null);
				return null;
			}

			Object resolved = resolve(value);
			if (resolved != value) {
				getOppositeFeatureMap().put(feature, resolved);
				value = resolved;
			}
			return value;
		}

	}
}