/*
 * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.management;

import com.sun.jmx.mbeanserver.Util;
import java.io.InvalidObjectException;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * An immutable descriptor.
 * @since 1.6
 */
public class ImmutableDescriptor implements Descriptor {
 private static final long serialVersionUID = 8853308591080540165L;

 /**
 * The names of the fields in this ImmutableDescriptor with their
 * original case. The names must be in alphabetical order as determined
 * by {@link String#CASE_INSENSITIVE_ORDER}.
 */
 private final String[] names;
 /**
 * The values of the fields in this ImmutableDescriptor. The
 * elements in this array match the corresponding elements in the
 * {@code names} array.
 */
 private final Object[] values;

 private transient int hashCode = -1;

 /**
 * An empty descriptor.
 */
 public static final ImmutableDescriptor EMPTY_DESCRIPTOR =
 new ImmutableDescriptor();

 /**
 * Construct a descriptor containing the given fields and values.
 *
 * @throws IllegalArgumentException if either array is null, or
 * if the arrays have different sizes, or
 * if a field name is null or empty, or if the same field name
 * appears more than once.
 */
 public ImmutableDescriptor(String[] fieldNames, Object[] fieldValues) {
 this(makeMap(fieldNames, fieldValues));
 }

 /**
 * Construct a descriptor containing the given fields. Each String
 * must be of the form {@code fieldName=fieldValue}. The field name
 * ends at the first {@code =} character; for example if the String
 * is {@code a=b=c} then the field name is {@code a} and its value
 * is {@code b=c}.
 *
 * @throws IllegalArgumentException if the parameter is null, or
 * if a field name is empty, or if the same field name appears
 * more than once, or if one of the strings does not contain
 * an {@code =} character.
 */
 public ImmutableDescriptor(String... fields) {
 this(makeMap(fields));
 }

 /**
 * <p>Construct a descriptor where the names and values of the fields
 * are the keys and values of the given Map.</p>
 *
 * @throws IllegalArgumentException if the parameter is null, or
 * if a field name is null or empty, or if the same field name appears
 * more than once (which can happen because field names are not case
 * sensitive).
 */
 public ImmutableDescriptor(Map<String, ?> fields) {
 if (fields == null)
 throw new IllegalArgumentException("Null Map");
 SortedMap<String, Object> map =
 new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
 for (Map.Entry<String, ?> entry : fields.entrySet()) {
 String name = entry.getKey();
 if (name == null || name.equals(""))
 throw new IllegalArgumentException("Empty or null field name");
 if (map.containsKey(name))
 throw new IllegalArgumentException("Duplicate name: " + name);
 map.put(name, entry.getValue());
 }
 int size = map.size();
 this.names = map.keySet().toArray(new String[size]);
 this.values = map.values().toArray(new Object[size]);
 }

 /**
 * This method can replace a deserialized instance of this
 * class with another instance. For example, it might replace
 * a deserialized empty ImmutableDescriptor with
 * {@link #EMPTY_DESCRIPTOR}.
 *
 * @return the replacement object, which may be {@code this}.
 *
 * @throws InvalidObjectException if the read object has invalid fields.
 */
 private Object readResolve() throws InvalidObjectException {

 boolean bad = false;
 if (names == null || values == null || names.length != values.length)
 bad = true;
 if (!bad) {
 if (names.length == 0 && getClass() == ImmutableDescriptor.class)
 return EMPTY_DESCRIPTOR;
 final Comparator<String> compare = String.CASE_INSENSITIVE_ORDER;
 String lastName = ""; // also catches illegal null name
 for (int i = 0; i < names.length; i++) {
 if (names[i] == null ||
 compare.compare(lastName, names[i]) >= 0) {
 bad = true;
 break;
 }
 lastName = names[i];
 }
 }
 if (bad)
 throw new InvalidObjectException("Bad names or values");

 return this;
 }

 private static SortedMap<String, ?> makeMap(String[] fieldNames,
 Object[] fieldValues) {
 if (fieldNames == null || fieldValues == null)
 throw new IllegalArgumentException("Null array parameter");
 if (fieldNames.length != fieldValues.length)
 throw new IllegalArgumentException("Different size arrays");
 SortedMap<String, Object> map =
 new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
 for (int i = 0; i < fieldNames.length; i++) {
 String name = fieldNames[i];
 if (name == null || name.equals(""))
 throw new IllegalArgumentException("Empty or null field name");
 Object old = map.put(name, fieldValues[i]);
 if (old != null) {
 throw new IllegalArgumentException("Duplicate field name: " +
 name);
 }
 }
 return map;
 }

 private static SortedMap<String, ?> makeMap(String[] fields) {
 if (fields == null)
 throw new IllegalArgumentException("Null fields parameter");
 String[] fieldNames = new String[fields.length];
 String[] fieldValues = new String[fields.length];
 for (int i = 0; i < fields.length; i++) {
 String field = fields[i];
 int eq = field.indexOf('=');
 if (eq < 0) {
 throw new IllegalArgumentException("Missing = character: " +
 field);
 }
 fieldNames[i] = field.substring(0, eq);
 // makeMap will catch the case where the name is empty
 fieldValues[i] = field.substring(eq + 1);
 }
 return makeMap(fieldNames, fieldValues);
 }

 /**
 * <p>Return an {@code ImmutableDescriptor} whose contents are the union of
 * the given descriptors. Every field name that appears in any of
 * the descriptors will appear in the result with the
 * value that it has when the method is called. Subsequent changes
 * to any of the descriptors do not affect the ImmutableDescriptor
 * returned here.</p>
 *
 * <p>In the simplest case, there is only one descriptor and the
 * returned {@code ImmutableDescriptor} is a copy of its fields at the
 * time this method is called:</p>
 *
 * <pre>
 * Descriptor d = something();
 * ImmutableDescriptor copy = ImmutableDescriptor.union(d);
 * </pre>
 *
 * @param descriptors the descriptors to be combined. Any of the
 * descriptors can be null, in which case it is skipped.
 *
 * @return an {@code ImmutableDescriptor} that is the union of the given
 * descriptors. The returned object may be identical to one of the
 * input descriptors if it is an ImmutableDescriptor that contains all of
 * the required fields.
 *
 * @throws IllegalArgumentException if two Descriptors contain the
 * same field name with different associated values. Primitive array
 * values are considered the same if they are of the same type with
 * the same elements. Object array values are considered the same if
 * {@link Arrays#deepEquals(Object[],Object[])} returns true.
 */
 public static ImmutableDescriptor union(Descriptor... descriptors) {
 // Optimize the case where exactly one Descriptor is non-Empty
 // and it is immutable - we can just return it.
 int index = findNonEmpty(descriptors, 0);
 if (index < 0)
 return EMPTY_DESCRIPTOR;
 if (descriptors[index] instanceof ImmutableDescriptor
 && findNonEmpty(descriptors, index + 1) < 0)
 return (ImmutableDescriptor) descriptors[index];

 Map<String, Object> map =
 new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
 ImmutableDescriptor biggestImmutable = EMPTY_DESCRIPTOR;
 for (Descriptor d : descriptors) {
 if (d != null) {
 String[] names;
 if (d instanceof ImmutableDescriptor) {
 ImmutableDescriptor id = (ImmutableDescriptor) d;
 names = id.names;
 if (id.getClass() == ImmutableDescriptor.class
 && names.length > biggestImmutable.names.length)
 biggestImmutable = id;
 } else
 names = d.getFieldNames();
 for (String n : names) {
 Object v = d.getFieldValue(n);
 Object old = map.put(n, v);
 if (old != null) {
 boolean equal;
 if (old.getClass().isArray()) {
 equal = Arrays.deepEquals(new Object[] {old},
 new Object[] {v});
 } else
 equal = old.equals(v);
 if (!equal) {
 final String msg =
 "Inconsistent values for descriptor field " +
 n + ": " + old + " :: " + v;
 throw new IllegalArgumentException(msg);
 }
 }
 }
 }
 }
 if (biggestImmutable.names.length == map.size())
 return biggestImmutable;
 return new ImmutableDescriptor(map);
 }

 private static boolean isEmpty(Descriptor d) {
 if (d == null)
 return true;
 else if (d instanceof ImmutableDescriptor)
 return ((ImmutableDescriptor) d).names.length == 0;
 else
 return (d.getFieldNames().length == 0);
 }

 private static int findNonEmpty(Descriptor[] ds, int start) {
 for (int i = start; i < ds.length; i++) {
 if (!isEmpty(ds[i]))
 return i;
 }
 return -1;
 }

 private int fieldIndex(String name) {
 return Arrays.binarySearch(names, name, String.CASE_INSENSITIVE_ORDER);
 }

 public final Object getFieldValue(String fieldName) {
 checkIllegalFieldName(fieldName);
 int i = fieldIndex(fieldName);
 if (i < 0)
 return null;
 Object v = values[i];
 if (v == null || !v.getClass().isArray())
 return v;
 if (v instanceof Object[])
 return ((Object[]) v).clone();
 // clone the primitive array, could use an 8-way if/else here
 int len = Array.getLength(v);
 Object a = Array.newInstance(v.getClass().getComponentType(), len);
 System.arraycopy(v, 0, a, 0, len);
 return a;
 }

 public final String[] getFields() {
 String[] result = new String[names.length];
 for (int i = 0; i < result.length; i++) {
 Object value = values[i];
 if (value == null)
 value = "";
 else if (!(value instanceof String))
 value = "(" + value + ")";
 result[i] = names[i] + "=" + value;
 }
 return result;
 }

 public final Object[] getFieldValues(String... fieldNames) {
 if (fieldNames == null)
 return values.clone();
 Object[] result = new Object[fieldNames.length];
 for (int i = 0; i < fieldNames.length; i++) {
 String name = fieldNames[i];
 if (name != null && !name.equals(""))
 result[i] = getFieldValue(name);
 }
 return result;
 }

 public final String[] getFieldNames() {
 return names.clone();
 }

 /**
 * Compares this descriptor to the given object. The objects are equal if
 * the given object is also a Descriptor, and if the two Descriptors have
 * the same field names (possibly differing in case) and the same
 * associated values. The respective values for a field in the two
 * Descriptors are equal if the following conditions hold:
 *
 * <ul>
 * <li>If one value is null then the other must be too.</li>
 * <li>If one value is a primitive array then the other must be a primitive
 * array of the same type with the same elements.</li>
 * <li>If one value is an object array then the other must be too and
 * {@link Arrays#deepEquals(Object[],Object[])} must return true.</li>
 * <li>Otherwise {@link Object#equals(Object)} must return true.</li>
 * </ul>
 *
 * @param o the object to compare with.
 *
 * @return {@code true} if the objects are the same; {@code false}
 * otherwise.
 *
 */
 // Note: this Javadoc is copied from javax.management.Descriptor
 // due to 6369229.
 @Override
 public boolean equals(Object o) {
 if (o == this)
 return true;
 if (!(o instanceof Descriptor))
 return false;
 String[] onames;
 if (o instanceof ImmutableDescriptor) {
 onames = ((ImmutableDescriptor) o).names;
 } else {
 onames = ((Descriptor) o).getFieldNames();
 Arrays.sort(onames, String.CASE_INSENSITIVE_ORDER);
 }
 if (names.length != onames.length)
 return false;
 for (int i = 0; i < names.length; i++) {
 if (!names[i].equalsIgnoreCase(onames[i]))
 return false;
 }
 Object[] ovalues;
 if (o instanceof ImmutableDescriptor)
 ovalues = ((ImmutableDescriptor) o).values;
 else
 ovalues = ((Descriptor) o).getFieldValues(onames);
 return Arrays.deepEquals(values, ovalues);
 }

 /**
 * <p>Returns the hash code value for this descriptor. The hash
 * code is computed as the sum of the hash codes for each field in
 * the descriptor. The hash code of a field with name {@code n}
 * and value {@code v} is {@code n.toLowerCase().hashCode() ^ h}.
 * Here {@code h} is the hash code of {@code v}, computed as
 * follows:</p>
 *
 * <ul>
 * <li>If {@code v} is null then {@code h} is 0.</li>
 * <li>If {@code v} is a primitive array then {@code h} is computed using
 * the appropriate overloading of {@code java.util.Arrays.hashCode}.</li>
 * <li>If {@code v} is an object array then {@code h} is computed using
 * {@link Arrays#deepHashCode(Object[])}.</li>
 * <li>Otherwise {@code h} is {@code v.hashCode()}.</li>
 * </ul>
 *
 * @return A hash code value for this object.
 *
 */
 // Note: this Javadoc is copied from javax.management.Descriptor
 // due to 6369229.
 @Override
 public int hashCode() {
 if (hashCode == -1) {
 hashCode = Util.hashCode(names, values);
 }
 return hashCode;
 }

 @Override
 public String toString() {
 StringBuilder sb = new StringBuilder("{");
 for (int i = 0; i < names.length; i++) {
 if (i > 0)
 sb.append(", ");
 sb.append(names[i]).append("=");
 Object v = values[i];
 if (v != null && v.getClass().isArray()) {
 String s = Arrays.deepToString(new Object[] {v});
 s = s.substring(1, s.length() - 1); // remove [...]
 v = s;
 }
 sb.append(String.valueOf(v));
 }
 return sb.append("}").toString();
 }

 /**
 * Returns true if all of the fields have legal values given their
 * names. This method always returns true, but a subclass can
 * override it to return false when appropriate.
 *
 * @return true if the values are legal.
 *
 * @exception RuntimeOperationsException if the validity checking fails.
 * The method returns false if the descriptor is not valid, but throws
 * this exception if the attempt to determine validity fails.
 */
 public boolean isValid() {
 return true;
 }

 /**
 * <p>Returns a descriptor which is equal to this descriptor.
 * Changes to the returned descriptor will have no effect on this
 * descriptor, and vice versa.</p>
 *
 * <p>This method returns the object on which it is called.
 * A subclass can override it
 * to return another object provided the contract is respected.
 *
 * @exception RuntimeOperationsException for illegal value for field Names
 * or field Values.
 * If the descriptor construction fails for any reason, this exception will
 * be thrown.
 */
 @Override
 public Descriptor clone() {
 return this;
 }

 /**
 * This operation is unsupported since this class is immutable. If
 * this call would change a mutable descriptor with the same contents,
 * then a {@link RuntimeOperationsException} wrapping an
 * {@link UnsupportedOperationException} is thrown. Otherwise,
 * the behavior is the same as it would be for a mutable descriptor:
 * either an exception is thrown because of illegal parameters, or
 * there is no effect.
 */
 public final void setFields(String[] fieldNames, Object[] fieldValues)
 throws RuntimeOperationsException {
 if (fieldNames == null || fieldValues == null)
 illegal("Null argument");
 if (fieldNames.length != fieldValues.length)
 illegal("Different array sizes");
 for (int i = 0; i < fieldNames.length; i++)
 checkIllegalFieldName(fieldNames[i]);
 for (int i = 0; i < fieldNames.length; i++)
 setField(fieldNames[i], fieldValues[i]);
 }

 /**
 * This operation is unsupported since this class is immutable. If
 * this call would change a mutable descriptor with the same contents,
 * then a {@link RuntimeOperationsException} wrapping an
 * {@link UnsupportedOperationException} is thrown. Otherwise,
 * the behavior is the same as it would be for a mutable descriptor:
 * either an exception is thrown because of illegal parameters, or
 * there is no effect.
 */
 public final void setField(String fieldName, Object fieldValue)
 throws RuntimeOperationsException {
 checkIllegalFieldName(fieldName);
 int i = fieldIndex(fieldName);
 if (i < 0)
 unsupported();
 Object value = values[i];
 if ((value == null) ?
 (fieldValue != null) :
 !value.equals(fieldValue))
 unsupported();
 }

 /**
 * Removes a field from the descriptor.
 *
 * @param fieldName String name of the field to be removed.
 * If the field name is illegal or the field is not found,
 * no exception is thrown.
 *
 * @exception RuntimeOperationsException if a field of the given name
 * exists and the descriptor is immutable. The wrapped exception will
 * be an {@link UnsupportedOperationException}.
 */
 public final void removeField(String fieldName) {
 if (fieldName != null && fieldIndex(fieldName) >= 0)
 unsupported();
 }

 static Descriptor nonNullDescriptor(Descriptor d) {
 if (d == null)
 return EMPTY_DESCRIPTOR;
 else
 return d;
 }

 private static void checkIllegalFieldName(String name) {
 if (name == null || name.equals(""))
 illegal("Null or empty field name");
 }

 private static void unsupported() {
 UnsupportedOperationException uoe =
 new UnsupportedOperationException("Descriptor is read-only");
 throw new RuntimeOperationsException(uoe);
 }

 private static void illegal(String message) {
 IllegalArgumentException iae = new IllegalArgumentException(message);
 throw new RuntimeOperationsException(iae);
 }
}