Bean.java

/**
 * 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.deephacks.confit.model;

import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import org.deephacks.confit.model.Schema.SchemaProperty;
import org.deephacks.confit.model.Schema.SchemaPropertyList;
import org.deephacks.confit.model.Schema.SchemaPropertyRef;
import org.deephacks.confit.model.Schema.SchemaPropertyRefList;
import org.deephacks.confit.model.Schema.SchemaPropertyRefMap;
import org.deephacks.confit.serialization.Conversion;
import org.deephacks.confit.serialization.UniqueIds;
import org.deephacks.confit.serialization.ValueSerialization.ValueReader;
import org.deephacks.confit.serialization.ValueSerialization.ValueWriter;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

import static com.google.common.base.Objects.equal;
import static org.deephacks.confit.model.Events.CFG310_CIRCULAR_REF;

/**
 * <p>
 * Bean represent an instance of a configurable bean. Every bean
 * that are to be provisioned must first have its corresponding schema
 * registered in the system.
 * </p>
 * <p>
 * Bean only serve as a simple transfer object and should not be
 * concerned about schema specific thing.  It should not try to
 * understand or validate if specific values are correct.
 * </p>
 * <p>
 * Bean only know about two kinds of values, properties and references. All
 * values are treated as a list of plain strings and do not care if certain
 * properties in reality are single valued.
 * </p>
 * @author Kristoffer Sjogren
 */
public final class Bean {
    private static final Conversion conversion = Conversion.get();
    /** lazy, only needed for binary serialization */
    private static UniqueIds ids;
    private final BeanId id;
    private final HashMap<String, List<String>> properties = new HashMap<>();
    private final HashMap<String, List<BeanId>> references = new HashMap<>();

    private Bean(BeanId id) {
        Preconditions.checkNotNull(id);
        // make a defensive copy
        if (id.isSingleton()) {
            this.id = BeanId.createSingleton(id.getSchemaName());
        } else {
            this.id = BeanId.create(id.getInstanceId(), id.getSchemaName());
        }
    }

    /**
     * Create a admin bean instance.
     *
     * @param id unique identification of the bean instance.
     * @return AdminBean
     */
    public static Bean create(final BeanId id) {
        Preconditions.checkNotNull(id);
        Bean bean = new Bean(id);
        bean.set(id.getSchema());
        return bean;
    }

    /**
     * @return unique identification of the bean instance.
     */
    public BeanId getId() {
        return id;
    }

    /**
     * Schema will only be present if the Bean was fetched or given from
     * a managed administrative context.
     *
     * @return the schema that belong to the bean instance.
     */
    public Schema getSchema() {
        return id.getSchema();
    }

    /**
     * Set the schema that define content structure and constraints of this
     * the bean instance.
     *
     * @param schema schema
     */
    public void set(final Schema schema) {
        this.id.set(schema);
    }

    /**
     * Return the list of property names which have values. Properties
     * with default values are not returned.
     *
     * @return list of property names.
     */
    public List<String> getPropertyNames() {
        ArrayList<String> names = new ArrayList<>(properties.keySet());
        Collections.sort(names);
        return names;
    }

    /**
     * Return the list of property names which are references.
     *
     * @return list of property names.
     */
    public List<String> getReferenceNames() {
        ArrayList<String> names = new ArrayList<>(references.keySet());
        Collections.sort(names);
        return names;
    }

    /**
     * Add a list of value to a property on this bean.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param values final String representations of the parameterized type of the collection
     * that conforms to its type as defined by the bean's schema.
     */
    public void addProperty(final String propertyName, final Collection<String> values) {
        Preconditions.checkNotNull(values);
        Preconditions.checkNotNull(propertyName);
        List<String> list = properties.get(propertyName);
        if (list == null) {
            properties.put(propertyName, new ArrayList<>(values));
        } else {
            list.addAll(values);
        }
    }

    /**
     * Add a value to a property on this bean.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param value final String representations of the property that conforms to
     * its type as defined by the bean's schema.
     */
    public void addProperty(final String propertyName, final String value) {
        Preconditions.checkNotNull(propertyName);
        Preconditions.checkNotNull(value);
        List<String> values = properties.get(propertyName);
        if (values == null) {
            values = new ArrayList<>();
            values.add(value);
            properties.put(propertyName, values);
        } else {
            values.add(value);
        }
    }

    /**
     * Overwrite the current values with the provided value.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param value final String representations of the property that conforms to
     * its type as defined by the bean's schema.
     */
    public void setProperty(final String propertyName, final String value) {
        Preconditions.checkNotNull(propertyName);
        if (value == null) {
            properties.put(propertyName, null);
            return;
        }
        List<String> values = new ArrayList<>();
        values.add(value);
        properties.put(propertyName, values);
    }

    /**
     * Overwrite/replace the current values with the provided values.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param values final String representations of the property that conforms to
     * its type as defined by the bean's schema.
     */
    public void setProperty(final String propertyName, final List<String> values) {
        Preconditions.checkNotNull(propertyName);
        if (values == null) {
            properties.put(propertyName, null);
            return;
        }
        properties.put(propertyName, values);
    }

    /**
     * Clear the values of a property or reference, setting it to null.
     *
     * This operation can be useful when removing properties using "merge"
     * operation.
     *
     * @param propertyName of the property as defined by the bean's schema.
     */
    public void clear(final String propertyName) {
        Preconditions.checkNotNull(propertyName);
        if (properties.containsKey(propertyName)) {
            properties.put(propertyName, null);
        } else if (references.containsKey(propertyName)) {
            references.put(propertyName, null);
        }
    }

    /**
     * Remove a property or reference as a property from this bean.
     *
     * This operation can be useful when removing properties using "set"
     * operation.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     */
    public void remove(final String propertyName) {
        Preconditions.checkNotNull(propertyName);
        if (properties.containsKey(propertyName)) {
            properties.remove(propertyName);
        } else if (references.containsKey(propertyName)) {
            references.remove(propertyName);
        }
    }

    /**
     * Get the values of a property on a bean.
     *
     * @param propertyName of the property as defined by the bean's schema.
     * @return final String representations of the property that conforms to
     * its type as defined by the bean's schema.
     */
    public List<String> getValues(final String propertyName) {
        Preconditions.checkNotNull(propertyName);
        List<String> values = properties.get(propertyName);
        if (values == null) {
            return null;
        }
        // creates a shallow defensive copy
        return new ArrayList<>(values);
    }

    /**
     * A helper method for getting the value of single valued properties. Returns
     * null if the property does not exist.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @return final String representations of the property that conforms to
     * its type as defined by the bean's schema.
     */
    public String getSingleValue(final String propertyName) {
        Preconditions.checkNotNull(propertyName);
        List<String> values = getValues(propertyName);
        if (values == null || values.size() < 1) {
            return null;
        }
        return values.get(0);
    }

    /**
     * Add a list of references to a property on this bean.
     *
     * A reference identify other beans based on schema and instance id.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param refs the reference as defined by the bean's schema.
     */
    public void addReference(final String propertyName, final Collection<BeanId> refs) {
        Preconditions.checkNotNull(refs);
        Preconditions.checkNotNull(propertyName);
        checkCircularReference(refs.toArray(new BeanId[refs.size()]));
        List<BeanId> list = references.get(propertyName);
        if (list == null) {
            list = new ArrayList<>();
            list.addAll(refs);
            references.put(propertyName, list);
        } else {
            list.addAll(refs);
        }
    }

    /**
     * Check that references does not point to self.
     * @param references from
     */
    private void checkCircularReference(final BeanId... references) {
        for (BeanId beanId : references) {
            if (getId().equals(beanId)) {
                throw CFG310_CIRCULAR_REF(getId(), getId());
            }
        }
    }

    /**
     * Add a reference to a property on this bean.
     *
     * A reference identify other beans based on schema and instance id.
     *
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param ref the reference as defined by the bean's schema.
     */
    public void addReference(final String propertyName, final BeanId ref) {
        Preconditions.checkNotNull(ref);
        Preconditions.checkNotNull(propertyName);
        checkCircularReference(ref);
        List<BeanId> list = references.get(propertyName);
        if (list == null) {
            list = new ArrayList<>();
            list.add(ref);
            references.put(propertyName, list);
        } else {
            list.add(ref);
        }
    }

    /**
     * Get the references of a property on a bean.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @return References that identify other beans.
     */
    public List<BeanId> getReference(final String propertyName) {
        List<BeanId> values = references.get(propertyName);
        if (values == null) {
            return null;
        }
        return values;
    }

    /**
     * Get all references for all properties of this bean.
     *
     * @return References that identify other beans.
     */
    public List<BeanId> getReferences() {
        if (references == null) {
            return new ArrayList<>();
        }
        ArrayList<BeanId> result = new ArrayList<>();
        for (List<BeanId> b : references.values()) {
            if (b != null) {
                result.addAll(b);
            }

        }
        return result;
    }

    /**
     * Overwrite/replace the current references with the provided reference.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param values override
     */
    public void setReferences(final String propertyName, final List<BeanId> values) {
        Preconditions.checkNotNull(propertyName);
        if (values == null || values.size() == 0) {
            references.put(propertyName, null);
            return;
        }
        checkCircularReference(values.toArray(new BeanId[values.size()]));
        references.put(propertyName, values);
    }

    /**
     * Overwrite/replace the current references with a provided reference.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @param value override
     */
    public void setReference(final String propertyName, final BeanId value) {
        Preconditions.checkNotNull(propertyName);
        if (value == null) {
            references.put(propertyName, null);
            return;
        }
        checkCircularReference(value);
        List<BeanId> values = new ArrayList<>();
        values.add(value);
        references.put(propertyName, values);
    }

    /**
     * A helper method for getting the value of single referenced property. Returns
     * null if the refrences does not exist.
     *
     * @param propertyName name of the property as defined by the bean's schema.
     * @return the value.
     */
    public BeanId getFirstReference(final String propertyName) {
        List<BeanId> refrences = getReference(propertyName);
        if (refrences == null || refrences.size() < 1) {
            return null;
        }
        return refrences.get(0);
    }

    /**
     * Clears this bean from all properties and references.
     */
    public void clear() {
        properties.clear();
        references.clear();
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(getId());
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Bean)) {
            return false;
        }
        Bean other = (Bean) obj;
        return equal(getId(), other.getId());
    }

    @Override
    public final String toString() {
        return Objects.toStringHelper(Bean.class).add("id", id).add("schema", getSchema())
                .add("properties", properties).add("references", references).toString();
    }

    public static Collection<Bean> copy(Collection<Bean> beans) {
        Collection<Bean> copies = new ArrayList<>();
        for (Bean bean : beans) {
            copies.add(copy(bean));
        }
        return copies;
    }

    public static Bean copy(Bean bean) {
        if (bean == null) {
            return null;
        }
        Bean copy = Bean.create(bean.getId());
        for (String property : bean.getPropertyNames()) {
            Collection<String> values = bean.getValues(property);
            if (values == null) {
                continue;
            }
            copy.setProperty(property, bean.getValues(property));
        }
        for (String property : bean.getReferenceNames()) {
            List<BeanId> ids = bean.getReference(property);
            if (ids == null) {
                continue;
            }
            for (BeanId id : ids) {
                copy.addReference(property, BeanId.create(id.getInstanceId(), id.getSchemaName()));
            }
        }
        return copy;
    }

    public byte[] write() {
        if (ids == null) {
            ids = UniqueIds.lookup();
        }
        Schema schema = getSchema();
        Preconditions.checkNotNull(schema);
        ValueWriter writer = new ValueWriter();

        for (SchemaProperty property : schema.get(SchemaProperty.class)) {
            int propId = ids.getSchemaId(property.getFieldName());
            Object value;
            if(writer.isBasicType(property.getClassType())) {
                value = conversion.convert(getSingleValue(property.getFieldName()), property.getClassType());
            } else {
                value = getSingleValue(property.getFieldName());
            }
            writer.putValue(propId, value);
        }
        for (SchemaPropertyList property : schema.get(SchemaPropertyList.class)) {
            int propId = ids.getSchemaId(property.getFieldName());
            Collection<?> values;
            if(writer.isBasicType(property.getClassType())) {
                values = conversion.convert(getValues(property.getFieldName()), property.getClassType());
                writer.putValues(propId, values, property.getClassType());
            } else {
                values = getValues(property.getFieldName());
                writer.putValues(propId, values, String.class);
            }
        }
        for (SchemaPropertyRef property : schema.get(SchemaPropertyRef.class)) {
            int propId = ids.getSchemaId(property.getFieldName());
            BeanId beanId = getFirstReference(property.getFieldName());
            if (beanId != null) {
                writer.putValue(propId, beanId.getInstanceId());
            }
        }
        for (SchemaPropertyRefList property : schema.get(SchemaPropertyRefList.class)) {
            int propId = ids.getSchemaId(property.getFieldName());
            ArrayList<String> list = new ArrayList<>();
            List<BeanId> beanIds = getReference(property.getFieldName());
            if(beanIds != null) {
                for (BeanId id : beanIds) {
                    list.add(id.getInstanceId());
                }
                writer.putValues(propId, list, String.class);
            }
        }
        for (SchemaPropertyRefMap property : schema.get(SchemaPropertyRefMap.class)) {
            int propId = ids.getSchemaId(property.getFieldName());
            ArrayList<String> list = new ArrayList<>();
            List<BeanId> beanIds = getReference(property.getFieldName());
            if(beanIds != null) {
                for (BeanId id : beanIds) {
                    list.add(id.getInstanceId());
                }
                writer.putValues(propId, list, String.class);
            }
        }
        return writer.write();
    }

    public static Bean read(BeanId beanId, byte[] data) {
        if (ids == null) {
            ids = UniqueIds.lookup();
        }
        Preconditions.checkNotNull(beanId);
        Preconditions.checkNotNull(data);
        Schema schema = beanId.getSchema();
        Preconditions.checkNotNull(schema);

        Bean bean = Bean.create(beanId);
        ValueReader reader = new ValueReader(data);

        Multimap<String, String> properties = ArrayListMultimap.create();
        Multimap<String, BeanId> references = ArrayListMultimap.create();

        int[] propertyIds = reader.getIds();
        for (int id : propertyIds) {
            String propertyName = ids.getSchemaName(id);
            Object value = reader.getValue(id);
            if (schema.isProperty(propertyName)) {
                if (Collection.class.isAssignableFrom(value.getClass())) {
                    properties.putAll(propertyName, conversion.convert((Collection)value, String.class));
                } else {
                    properties.put(propertyName, conversion.convert(value, String.class));
                }
            } else if (schema.isReference(propertyName)) {
                String schemaName = schema.getReferenceSchemaName(propertyName);
                if (Collection.class.isAssignableFrom(value.getClass())) {
                    for (String instanceId : (Collection<String>) value) {
                        references.put(propertyName, BeanId.create(instanceId, schemaName));
                    }
                } else {
                    String instanceId = (String) value;
                    references.put(propertyName, BeanId.create(instanceId, schemaName));
                }
            } else {
                throw new IllegalArgumentException("Unrecognized property " + propertyName);
            }
        }
        for (String propertyName : properties.keySet()) {
            bean.addProperty(propertyName, properties.get(propertyName));
        }
        for (String propertyName : references.keySet()) {
            bean.addReference(propertyName, references.get(propertyName));
        }
        bean.set(schema);
        return bean;
    }

}