/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/
package com.nokia.sdt.emf.dm.impl;

import com.nokia.sdt.component.property.IPropertyValueSource;
import com.nokia.sdt.component.property.ISequencePropertyValue;
import com.nokia.sdt.datamodel.IDesignerDataModel;
import com.nokia.sdt.emf.dm.*;
import com.nokia.sdt.emf.dm.util.PropertyValueSwitch;
import com.nokia.cpp.internal.api.utils.core.Check;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.ui.views.properties.IPropertySource;

import java.util.*;


/**
 * Implementation of IPropertyValueSource for sequence properties.
 * As seen through the IPropertyValueSource interface, the sequence
 * is a set of properties whose ids are the zero-based index values.
 * Existing values can be modified, but sequence elements cannot be
 * added or removed.
 */
public class SequencePropertyValueSource implements IPropertyValueSource, ISequencePropertyValue {

	private IPropertyContainer parentContainer;
	private PropertyValueSequence sequence;
	
	public SequencePropertyValueSource( 
			IPropertyContainer parentContainer, PropertyValueSequence list) {
		Check.checkArg(list);
		Check.checkArg(parentContainer);
		this.parentContainer = parentContainer;
		this.sequence = list;
	}
	
	public Object getEditableValue() {
		return this;
	}
	
	public IPropertyValueSource getValueSource() {
		return this;
	}
	
	List getSequence() {
		return sequence;
	}

	public int addLocalizedString(int index, String value) {
		IPropertyValue pv = DmFactory.eINSTANCE.createIPropertyValue();
		pv.setStringValue(parentContainer.createLocalized(value));
		return addPropertyValue(index, pv);
	}

	public int addStringLiteral(int index, String value) {
		IPropertyValue pv = DmFactory.eINSTANCE.createIPropertyValue();
		pv.setStringValue(parentContainer.createLiteral(value));
		return addPropertyValue(index, pv);
	}
	
	public int addComponentReferenceString(int index, String value) {
		IPropertyValue pv = DmFactory.eINSTANCE.createIPropertyValue();
		pv.setStringValue(parentContainer.createReference(value));
		return addPropertyValue(index, pv);		
	}
	
	public IPropertyValueSource addChildValueSource(int index) {
		IPropertyValue containerPV = parentContainer.createPropertyContainerForProperty(Integer.toString(index));
		addPropertyValue(index, containerPV);
		IPropertyValueSource result = containerPV.getCompoundValue().getPropertyValueSource();
		return result;
	}
	
	int addPropertyValue(int index, IPropertyValue value) {
		if (index < 0) {
			throw new IllegalArgumentException();
		}
		if (index > sequence.size()) {
			index = sequence.size();
		}
		sequence.add(index, value);
		return index;
	}

	private int idToIndex(Object propertyId) {
		int result = -1;
		if (propertyId instanceof String) {
			try {
				result = Integer.parseInt((String)propertyId);
			}
			catch (NumberFormatException x) {
			}
		}
		else if (propertyId instanceof Number) {
			result = ((Number)propertyId).intValue();
		}
		return result;
	}

	public boolean hasPropertyValue(Object propertyId) {
		boolean result = false;
		int index = idToIndex(propertyId);
		if (index >= 0 && index < sequence.size()) {
			result = true;
		}
		return result;
	}

	public Object getPropertyValue(Object propertyId) {
		int index = idToIndex(propertyId);
		return getPropertyValue(index);
	}
	
	Object getPropertyValue(int index) {
		Object result = null;
		if (index >= 0 && index < sequence.size()) {
			IPropertyValue value = (IPropertyValue) sequence.get(index);
			if (value != null) {
				if (value.hasStringValue()) {
					result = parentContainer.lookupString(value.getStringValue());
				}
				else if (value.hasCompoundValue()) {
					IPropertyValueSource ps = value.getCompoundValue().getPropertyValueSource(); 
					result = ps;
				}
				else if (value.hasSequenceValue()) {
					List l = value.getSequenceValue();
					result = l;
				}
			}
		}
		return result;
	}

	public boolean canSetPropertyValue(Object propertyId) {
		return hasPropertyValue(propertyId);
	}

	public int numberOfProperties() {
		return sequence.size();
	}

	public Object[] getIds() {
		String[] result = new String[sequence.size()];
		for (int i = 0; i < sequence.size(); i++) 
			result[i] = Integer.toString(i);
		return result;
	}
	
	private Object internalSet(int index, IPropertyValue value, boolean overrideLocalizationState) {
		Object result = null;
		boolean doSet = true;
		IPropertyValue currVal = (IPropertyValue) sequence.get(index);
		if (currVal != null) {
			if (currVal.hasStringValue() && value.hasStringValue() && 
				!overrideLocalizationState) {
				StringValue currStringVal = currVal.getStringValue();
				StringValue newValue = parentContainer.conserveStringType(
						currStringVal, value.getStringValue());
				if (newValue == currStringVal)
					doSet = false;
				else
					value.setStringValue(newValue);
			}
		}
		if (doSet) {
			result = sequence.set(index, value);
		}
		return result;
	}
	
	private void internalClear(int index) {
		IPropertyValue currVal = (IPropertyValue) sequence.get(index);
		if (currVal != null) {
			parentContainer.releasePropertyValue(currVal);
		}

	}

	public void setPropertyValue(Object propertyID, Object newValue) {
		setPropertyValue(propertyID, newValue, false);
	}

	void setPropertyValue(Object propertyId, Object newValue, boolean overrideLocalizationState) {
		Check.checkArg(propertyId != null);
		int index = idToIndex(propertyId);
		if (index >= 0 && index < sequence.size()) {
			if (newValue != null) {
				if (newValue instanceof IPropertySource) {
					// an entry for the compound property must have previously
					// been added, otherwise this is an error
					IPropertyValue pv = (IPropertyValue) sequence.get(index);
					if (pv != null && pv.hasCompoundValue()) {
						pv.getCompoundValue().setFromPropertySource((IPropertySource)newValue);
					}
					else {
						throw new IllegalStateException();
					}
				} else {
					IPropertyValue pv = createPropertyValue(index, newValue);
					internalSet(index, pv, overrideLocalizationState);
				}
			}
			else
				resetPropertyValue(propertyId);
		}
	}
	
	public void resetPropertyValue(final Object propertyId) {
		// Setting to null is not correct. If there's a value all
		// we can do is set to the default for the property type
		int index = idToIndex(propertyId);
		if (index >= 0 && index < sequence.size()) {
			IPropertyValue currValue = (IPropertyValue) sequence.get(index);
		
			PropertyValueSwitch pvs = new PropertyValueSwitch() {
				protected Object handleStringValue(IPropertyValue pv) {
					IPropertyValue newValue = DmFactory.eINSTANCE.createIPropertyValue();
					newValue.setStringValue(parentContainer.createLiteral(null));
					return newValue;
				}
				protected Object handleCompoundValue(IPropertyValue pv) {
					return parentContainer.createPropertyContainerForProperty(propertyId);
				}
				protected Object handleSequenceValue(IPropertyValue pv) {
					return parentContainer.createSequenceForProperty(propertyId);
				}
			};
			
			IPropertyValue newValue = (IPropertyValue) pvs.doSwitch(currValue);
			if (newValue != null)
				internalSet(index, newValue, false);
		}
	}

	public IPropertyValueSource createChildValueSource(Object propertyId, boolean storeValue) {
		IPropertyValue childValue = parentContainer.createPropertyContainerForProperty(propertyId);
		IPropertyValueSource pvs = childValue.getCompoundValue().getPropertyValueSource();
		return pvs;
	}

	public ISequencePropertyValue createChildSequence(Object propertyId, boolean storeValue) {
		// we don't support arrays of arrays, but we do need to generate temporary values for editing
		Check.checkArg(storeValue == false);
		IPropertyValue childValue = parentContainer.createSequenceForProperty(propertyId);
		ISequencePropertyValue pvs = new SequencePropertyValueSource(
				parentContainer, (PropertyValueSequence)childValue.getSequenceValue());
		return pvs;
	}

	public EObject getEObject() {
		return parentContainer.getOwner();
	}

	public IDesignerDataModel getDesignerDataModel() {
		return parentContainer.getDesignerDataModel();
	}
	
	private IPropertyValue createPropertyValue(int index, Object o) {
		IPropertyValue result = null;
		if (o instanceof IPropertyValue) {
			result = (IPropertyValue) o;
		}
		if (o instanceof String) {
			result = DmFactory.eINSTANCE.createIPropertyValue();
			result.setStringValue(parentContainer.createLiteral((String)o));
		}
		else if (o instanceof StringValue) {
			result = DmFactory.eINSTANCE.createIPropertyValue();
			result.setStringValue((StringValue)o);
		}
		else if (o instanceof ISequencePropertyValue) {
			result = parentContainer.createSequenceForProperty(Integer.toString(index));
			for (Iterator iter = ((ISequencePropertyValue)o).iterator(); iter.hasNext();) {
				Object element = iter.next();
				result.getSequenceValue().add(element);
			}
		}
		else if (o instanceof IPropertyValueSource) {
			result = parentContainer.createPropertyContainerForProperty(Integer.toString(index));
			IPropertyValueSource pvs = (IPropertyValueSource) o;
			Object ids[] = pvs.getIds();
			for (int i = 0; i < ids.length; i++) {
				result.getCompoundValue().getProperties().put(ids[i], pvs.getPropertyValue(ids[i]));
			}
		}
	
		if (result == null)
			throw new IllegalArgumentException();
		return result;
	}

	public void clear() {
		for (int i = 0; i < sequence.size(); i++) {
			internalClear(i);
		}
		sequence.clear();
	}

	public boolean isEmpty() {
		return sequence.isEmpty();
	}

	public Iterator iterator() {
		return new SeqListIterator();
	}
	
	public void remove(int index) {
		internalClear(index);
		sequence.remove(index);
	}
	
	public void move(int index, int newIndex) {
		Object obj = sequence.remove(index);
		sequence.add(newIndex, obj);
	}

	public int size() {
		return sequence.size();
	}

	public Object get(int index) {
		return getPropertyValue(index);
	}
	
	class SeqListIterator implements Iterator {
		ListIterator iter = sequence.listIterator();
		
		SeqListIterator() {
			iter = sequence.listIterator();
		}
		
		SeqListIterator(int index) {
			iter = sequence.listIterator(index);
		}
		
		public void remove() {
			throw new UnsupportedOperationException();
		}
		public boolean hasNext() {
			return iter.hasNext();
		}
		public Object next() {
			int nextIndex = iter.nextIndex();
			iter.next();
			return getPropertyValue(nextIndex);
		}
	}

	public String getLocalizablePropertyKey(Object propertyId) {
		String result = null;
		int index = idToIndex(propertyId);
		if (index >= 0 && index < sequence.size()) {
			IPropertyValue value = (IPropertyValue) sequence.get(index);
			if (value != null) {
				if (value.hasStringValue() && value.getStringValue().isKey()) {
					result = value.getStringValue().getValue();
				}
			}
		}
		return result;
	}

	public void setLocalizableStringPropertyValue(Object propertyId, String newValue, boolean overrideCurrentState) {
		setPropertyValue(propertyId, parentContainer.createLocalized(newValue), overrideCurrentState);
	}

	public String getStringPropertyValueSymbol(Object propertyId) {
		String result = null;
		int index = idToIndex(propertyId);
		if (index >= 0 && index < sequence.size()) {
			IPropertyValue currValue = (IPropertyValue) sequence.get(index);
			if (currValue.hasStringValue() && currValue.getStringValue().isKey()) {
				result = currValue.getStringValue().getValue();
			}
		}
		return result;
	}

	public void setReferencePropertyValue(Object propertyId, String newValue) {
		setPropertyValue(propertyId, parentContainer.createReference(newValue));
	}

	public boolean isReferenceProperty(Object propertyId) {
		boolean result = false;
		int index = idToIndex(propertyId);
		if (index >= 0 && index < sequence.size()) {
			IPropertyValue currValue = (IPropertyValue) sequence.get(index);
			if (currValue.hasStringValue()) {
				result = currValue.getStringValue().isReference();
			}
		}
		return result;
	}

	public UndoValue createUndoValue() {
		UndoValue result = new PropertyContainerCopier(parentContainer);
		return result;
	}

	public void setFromUndoValue(UndoValue value, boolean preserveLocalizedStringKeys) {
		Check.checkArg(value instanceof PropertyContainerCopier);
		PropertyContainerCopier copier = (PropertyContainerCopier) value;
		copier.undo(true, preserveLocalizedStringKeys);
	}
	
	public String getPropertyPath() {
		return sequence.getPath();
	}

	public String getPropertyPath(Object propertyId) {
		String result;
		String path = sequence.getPath();
		if (path != null) {
			if (propertyId != null)
				result = path + "." + propertyId.toString();
			else
				result = path;
		}
		else {
			result = propertyId.toString();
		}
		return result;
	}

	public String getElementPath(int index) {
		return getPropertyPath(Integer.toString(index));
	}
	
	public IPropertyValueSource lookupReferencePropertyValueSource(Object id) {
		String referenceName = (String) getPropertyValue(id);
		if (referenceName != null && referenceName.length() > 0) {
			EObject reference = getDesignerDataModel().findByNameProperty(referenceName);
			if (reference != null) {
				return ((INode) reference).getProperties().getPropertyValueSource();
			}
		}
		return null;
	}
}