/*

   * Copyright 2002-2008 the original author or authors.

   *

   * Licensed under the Apache License, Version 2.0 (the "License");

   * you may not use this file except in compliance with the License.

   * You may obtain a copy of the License at

   *

   *      http://www.apache.org/licenses/LICENSE-2.0

   *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.springframework.beans;

 import java.io.Serializable;

 import java.util.ArrayList;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.springframework.util.StringUtils;

 public class MutablePropertyValues implements PropertyValues, Serializable {

	

 	private final List propertyValueList;

 	private Set processedProperties;

 	private volatile boolean converted = false;


	

 	public MutablePropertyValues() {

 		this.propertyValueList = new ArrayList();

 	}

	

 	public MutablePropertyValues(PropertyValues original) {

 		// We can optimize this because it's all new:

 		// There is no replacement of existing property values.

 		if (original != null) {

 			PropertyValue[] pvs = original.getPropertyValues();

 			this.propertyValueList = new ArrayList(pvs.length);

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

 				PropertyValue newPv = new PropertyValue(pvs[i]);

 				this.propertyValueList.add(newPv);

 			}

 		}

 		else {

 			this.propertyValueList = new ArrayList(0);

 		}

 	}

	

 	public MutablePropertyValues(Map original) {

 		// We can optimize this because it's all new:

 		// There is no replacement of existing property values.

 		if (original != null) {

 			this.propertyValueList = new ArrayList(original.size());

 			Iterator it = original.entrySet().iterator();

 			while (it.hasNext()) {

 				Map.Entry entry = (Map.Entry) it.next();

 				PropertyValue newPv = new PropertyValue((String) entry.getKey(), entry.getValue());

 				this.propertyValueList.add(newPv);

 			}

 		}

 		else {

			this.propertyValueList = new ArrayList(0);

		}

	}

	

	public MutablePropertyValues(List propertyValueList) {

		this.propertyValueList = (propertyValueList != null ? propertyValueList : new ArrayList());

	}


	

	public List getPropertyValueList() {

		return this.propertyValueList;

	}

	

	public MutablePropertyValues addPropertyValues(PropertyValues other) {

		if (other != null) {

			PropertyValue[] pvs = other.getPropertyValues();

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

				PropertyValue newPv = new PropertyValue(pvs[i]);

				addPropertyValue(newPv);

			}

		}

		return this;

	}

	

	public MutablePropertyValues addPropertyValues(Map other) {

		if (other != null) {

			Iterator it = other.entrySet().iterator();

			while (it.hasNext()) {

				Map.Entry entry = (Map.Entry) it.next();

				PropertyValue newPv = new PropertyValue((String) entry.getKey(), entry.getValue());

				addPropertyValue(newPv);

			}

		}

		return this;

	}

	

	public MutablePropertyValues addPropertyValue(PropertyValue pv) {

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

			PropertyValue currentPv = (PropertyValue) this.propertyValueList.get(i);

			if (currentPv.getName().equals(pv.getName())) {

				pv = mergeIfRequired(pv, currentPv);

				setPropertyValueAt(pv, i);

				return this;

			}

		}

		this.propertyValueList.add(pv);

		return this;

	}

	

	public void addPropertyValue(String propertyName, Object propertyValue) {

		addPropertyValue(new PropertyValue(propertyName, propertyValue));

	}

	

	public void setPropertyValueAt(PropertyValue pv, int i) {

		this.propertyValueList.set(i, pv);

	}

	

	private PropertyValue mergeIfRequired(PropertyValue newPv, PropertyValue currentPv) {

		Object value = newPv.getValue();

		if (value instanceof Mergeable) {

			Mergeable mergeable = (Mergeable) value;

			if (mergeable.isMergeEnabled()) {

				Object merged = mergeable.merge(currentPv.getValue());

				return new PropertyValue(newPv.getName(), merged);

			}

		}

		return newPv;

	}

	

	public void removePropertyValue(String propertyName) {

		removePropertyValue(getPropertyValue(propertyName));

	}

	

	public void removePropertyValue(PropertyValue pv) {

		this.propertyValueList.remove(pv);

	}

	

	public void clear() {

		this.propertyValueList.clear();

	}

	public PropertyValue[] getPropertyValues() {

		return (PropertyValue[])

				this.propertyValueList.toArray(new PropertyValue[this.propertyValueList.size()]);

	}

	public PropertyValue getPropertyValue(String propertyName) {

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

			PropertyValue pv = (PropertyValue) this.propertyValueList.get(i);

			if (pv.getName().equals(propertyName)) {

				return pv;

			}

		}

		return null;

	}

	

	public void registerProcessedProperty(String propertyName) {

		if (this.processedProperties == null) {

			this.processedProperties = new HashSet();

		}

		this.processedProperties.add(propertyName);

	}

	public boolean contains(String propertyName) {

		return (getPropertyValue(propertyName) != null ||

				(this.processedProperties != null && this.processedProperties.contains(propertyName)));

	}

	public boolean isEmpty() {

		return this.propertyValueList.isEmpty();

	}

	public int size() {

		return this.propertyValueList.size();

	}

	public PropertyValues changesSince(PropertyValues old) {

		MutablePropertyValues changes = new MutablePropertyValues();

		if (old == this) {

			return changes;

		}

		// for each property value in the new set

		for (Iterator it = this.propertyValueList.iterator(); it.hasNext();) {

			PropertyValue newPv = (PropertyValue) it.next();

			// if there wasn't an old one, add it

			PropertyValue pvOld = old.getPropertyValue(newPv.getName());

			if (pvOld == null) {

				changes.addPropertyValue(newPv);

			}

			else if (!pvOld.equals(newPv)) {

				// it's changed

				changes.addPropertyValue(newPv);

			}

		}

		return changes;

	}


	

	public void setConverted() {

		this.converted = true;

	}

	

	public boolean isConverted() {

		return this.converted;

	}

	public boolean equals(Object other) {

		if (this == other) {

			return true;

		}

		if (!(other instanceof MutablePropertyValues)) {

			return false;

		}

		MutablePropertyValues that = (MutablePropertyValues) other;

		return this.propertyValueList.equals(that.propertyValueList);

	}

	public int hashCode() {

		return this.propertyValueList.hashCode();

	}

	public String toString() {

		PropertyValue[] pvs = getPropertyValues();

		StringBuffer sb = new StringBuffer("PropertyValues: length=" + pvs.length + "; ");

		sb.append(StringUtils.arrayToDelimitedString(pvs, "; "));

		return sb.toString();

	}

}