package de.deepamehta.core.impl;

import de.deepamehta.core.Association;
import de.deepamehta.core.AssociationType;
import de.deepamehta.core.AssociationDefinition;
import de.deepamehta.core.RelatedAssociation;
import de.deepamehta.core.RelatedTopic;
import de.deepamehta.core.Topic;
import de.deepamehta.core.TopicType;
import de.deepamehta.core.Type;
import de.deepamehta.core.model.AssociationDefinitionModel;
import de.deepamehta.core.model.AssociationModel;
import de.deepamehta.core.model.AssociationRoleModel;
import de.deepamehta.core.model.AssociationTypeModel;
import de.deepamehta.core.model.IndexMode;
import de.deepamehta.core.model.RelatedAssociationModel;
import de.deepamehta.core.model.RelatedTopicModel;
import de.deepamehta.core.model.RoleModel;
import de.deepamehta.core.model.SimpleValue;
import de.deepamehta.core.model.TopicModel;
import de.deepamehta.core.model.TopicRoleModel;
import de.deepamehta.core.model.TopicTypeModel;
import de.deepamehta.core.model.TypeModel;
import de.deepamehta.core.model.ViewConfigurationModel;
import de.deepamehta.core.service.ResultList;
import de.deepamehta.core.service.TypeStorage;
import de.deepamehta.core.util.DeepaMehtaUtils;

import static java.util.Arrays.asList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;



/**
 * Storage-impl agnostic support for fetching/storing type models.
 */
class TypeStorageImpl implements TypeStorage {

    // ------------------------------------------------------------------------------------------------------- Constants

    // role types
    private static final String PARENT_CARDINALITY = "dm4.core.parent_cardinality";
    private static final String CHILD_CARDINALITY  = "dm4.core.child_cardinality";

    // ---------------------------------------------------------------------------------------------- Instance Variables

    private Map<String, TypeModel> typeCache = new HashMap();   // type model cache

    private EmbeddedService dms;

    private Logger logger = Logger.getLogger(getClass().getName());

    // ---------------------------------------------------------------------------------------------------- Constructors

    TypeStorageImpl(EmbeddedService dms) {
        this.dms = dms;
    }

    // --------------------------------------------------------------------------------------------------------- Methods



    // === Type Model Cache ===

    TopicTypeModel getTopicType(String topicTypeUri) {
        TopicTypeModel topicType = (TopicTypeModel) getType(topicTypeUri);
        return topicType != null ? topicType : fetchTopicType(topicTypeUri);
    }

    AssociationTypeModel getAssociationType(String assocTypeUri) {
        AssociationTypeModel assocType = (AssociationTypeModel) getType(assocTypeUri);
        return assocType != null ? assocType : fetchAssociationType(assocTypeUri);
    }

    // ---

    private TypeModel getType(String typeUri) {
        return typeCache.get(typeUri);
    }

    private void putInTypeCache(TypeModel type) {
        typeCache.put(type.getUri(), type);
    }

    void removeFromTypeCache(String typeUri) {
        typeCache.remove(typeUri);
    }



    // === Types ===

    // --- Fetch ---

    // ### TODO: unify with next method
    private TopicTypeModel fetchTopicType(String topicTypeUri) {
        Topic typeTopic = dms.getTopic("uri", new SimpleValue(topicTypeUri));
        checkTopicType(topicTypeUri, typeTopic);
        //
        // 1) fetch type components
        String dataTypeUri = fetchDataTypeTopic(typeTopic.getId(), topicTypeUri, "topic type").getUri();
        List<IndexMode> indexModes = fetchIndexModes(typeTopic.getId());
        List<AssociationDefinitionModel> assocDefs = fetchAssociationDefinitions(typeTopic);
        List<String> labelConfig = fetchLabelConfig(assocDefs);
        ViewConfigurationModel viewConfig = fetchTypeViewConfig(typeTopic);
        //
        // 2) build type model
        TopicTypeModel topicType = new TopicTypeModel(typeTopic.getModel(), dataTypeUri, indexModes,
            assocDefs, labelConfig, viewConfig);
        //
        // 3) put in type model cache
        putInTypeCache(topicType);
        //
        return topicType;
    }

    // ### TODO: unify with previous method
    private AssociationTypeModel fetchAssociationType(String assocTypeUri) {
        Topic typeTopic = dms.getTopic("uri", new SimpleValue(assocTypeUri));
        checkAssociationType(assocTypeUri, typeTopic);
        //
        // 1) fetch type components
        String dataTypeUri = fetchDataTypeTopic(typeTopic.getId(), assocTypeUri, "association type").getUri();
        List<IndexMode> indexModes = fetchIndexModes(typeTopic.getId());
        List<AssociationDefinitionModel> assocDefs = fetchAssociationDefinitions(typeTopic);
        List<String> labelConfig = fetchLabelConfig(assocDefs);
        ViewConfigurationModel viewConfig = fetchTypeViewConfig(typeTopic);
        //
        // 2) build type model
        AssociationTypeModel assocType = new AssociationTypeModel(typeTopic.getModel(), dataTypeUri, indexModes,
            assocDefs, labelConfig, viewConfig);
        //
        // 3) put in type model cache
        putInTypeCache(assocType);
        //
        return assocType;
    }

    // ---

    private void checkTopicType(String topicTypeUri, Topic typeTopic) {
        if (typeTopic == null) {
            throw new RuntimeException("Topic type \"" + topicTypeUri + "\" not found in DB");
        } else if (!typeTopic.getTypeUri().equals("dm4.core.topic_type") &&
                   !typeTopic.getTypeUri().equals("dm4.core.meta_type") &&
                   !typeTopic.getTypeUri().equals("dm4.core.meta_meta_type")) {
            throw new RuntimeException("URI \"" + topicTypeUri + "\" refers to a \"" + typeTopic.getTypeUri() +
                "\" when the caller expects a \"dm4.core.topic_type\"");
        }
    }

    private void checkAssociationType(String assocTypeUri, Topic typeTopic) {
        if (typeTopic == null) {
            throw new RuntimeException("Association type \"" + assocTypeUri + "\" not found in DB");
        } else if (!typeTopic.getTypeUri().equals("dm4.core.assoc_type")) {
            throw new RuntimeException("URI \"" + assocTypeUri + "\" refers to a \"" + typeTopic.getTypeUri() +
                "\" when the caller expects a \"dm4.core.assoc_type\"");
        }
    }

    // --- Store ---

    /**
     * Stores the type-specific parts of the given type model.
     * Prerequisite: the generic topic parts are stored already.
     * <p>
     * Called to store a newly created topic type or association type.
     */
    void storeType(TypeModel type) {
        // 1) put in type model cache
        // Note: an association type must be put in type model cache *before* storing its association definitions.
        // Consider creation of association type "Composition Definition": it has a composition definition itself.
        putInTypeCache(type);
        //
        // 2) store type-specific parts
        storeDataType(type.getUri(), type.getDataTypeUri());
        storeIndexModes(type.getUri(), type.getIndexModes());
        storeAssocDefs(type.getId(), type.getAssocDefs());
        storeLabelConfig(type.getLabelConfig(), type.getAssocDefs());
        storeViewConfig(createConfigurableType(type.getId()), type.getViewConfigModel());
    }



    // === Data Type ===

    // --- Fetch ---

    private RelatedTopicModel fetchDataTypeTopic(long typeId, String typeUri, String className) {
        try {
            RelatedTopicModel dataType = dms.storageDecorator.fetchTopicRelatedTopic(typeId, "dm4.core.aggregation",
                "dm4.core.type", "dm4.core.default", "dm4.core.data_type");
            if (dataType == null) {
                throw new RuntimeException("No data type topic is associated to " + className + " \"" + typeUri + "\"");
            }
            return dataType;
        } catch (Exception e) {
            throw new RuntimeException("Fetching the data type topic of " + className + " \"" + typeUri + "\" failed",
                e);
        }
    }

    // --- Store ---

    // ### TODO: compare to low-level method EmbeddedService._associateDataType(). Remove structural similarity.
    void storeDataType(String typeUri, String dataTypeUri) {
        try {
            dms.createAssociation("dm4.core.aggregation",
                new TopicRoleModel(typeUri,     "dm4.core.type"),
                new TopicRoleModel(dataTypeUri, "dm4.core.default"));
        } catch (Exception e) {
            throw new RuntimeException("Associating type \"" + typeUri + "\" with data type \"" +
                dataTypeUri + "\" failed", e);
        }
    }



    // === Index Modes ===

    // --- Fetch ---

    private List<IndexMode> fetchIndexModes(long typeId) {
        ResultList<RelatedTopicModel> indexModes = dms.storageDecorator.fetchTopicRelatedTopics(typeId,
            "dm4.core.aggregation", "dm4.core.type", "dm4.core.default", "dm4.core.index_mode", 0);
        return IndexMode.fromTopics(indexModes.getItems());
    }

    // --- Store ---

    private void storeIndexModes(String typeUri, List<IndexMode> indexModes) {
        for (IndexMode indexMode : indexModes) {
            storeIndexMode(typeUri, indexMode);
        }
    }

    void storeIndexMode(String typeUri, IndexMode indexMode) {
        dms.createAssociation("dm4.core.aggregation",
            new TopicRoleModel(typeUri,           "dm4.core.type"),
            new TopicRoleModel(indexMode.toUri(), "dm4.core.default"));
    }



    // === Association Definitions ===

    @Override
    public AssociationDefinitionModel createAssociationDefinition(Association assoc) {
        // Note: the assoc def's ID is already known. Setting it explicitely prevents
        // creating the underlying association (see storeAssociationDefinition()).
        return new AssociationDefinitionModel(assoc.getId(), assoc.getUri(),
            assoc.getTypeUri(), fetchCustomAssocTypeUri(assoc),
            fetchParentType(assoc).getUri(), fetchChildType(assoc).getUri(),
            defaultCardinalityUri(assoc, PARENT_CARDINALITY),
            defaultCardinalityUri(assoc, CHILD_CARDINALITY), null);   // viewConfigModel=null
    }

    // Note: if the underlying association was an association definition before it have cardinality
    // assignments already. These assignments are restored. Otherwise "One" is used as default.
    private String defaultCardinalityUri(Association assoc, String cardinalityRoleTypeUri) {
        RelatedTopicModel cardinality = fetchCardinality(assoc.getId(), cardinalityRoleTypeUri);
        if (cardinality != null) {
            return cardinality.getUri();
        } else {
            return "dm4.core.one";
        }
    }

    @Override
    public void removeAssociationDefinitionFromMemoryAndRebuildSequence(Type type, String childTypeUri) {
        ((AttachedType) type).removeAssocDefFromMemoryAndRebuildSequence(childTypeUri);
    }

    // --- Fetch ---

    private List<AssociationDefinitionModel> fetchAssociationDefinitions(Topic typeTopic) {
        Map<Long, AssociationDefinitionModel> assocDefs = fetchAssociationDefinitionsUnsorted(typeTopic);
        List<RelatedAssociationModel> sequence = fetchSequence(typeTopic);
        // error check
        if (assocDefs.size() != sequence.size()) {
            throw new RuntimeException("DB inconsistency: type \"" + typeTopic.getUri() + "\" has " +
                assocDefs.size() + " association definitions but in sequence are " + sequence.size());
        }
        //
        return sortAssocDefs(assocDefs, DeepaMehtaUtils.idList(sequence));
    }

    private Map<Long, AssociationDefinitionModel> fetchAssociationDefinitionsUnsorted(Topic typeTopic) {
        Map<Long, AssociationDefinitionModel> assocDefs = new HashMap();
        //
        // 1) fetch child topic types
        // Note: we must set fetchRelatingComposite to false here. Fetching the composite of association type
        // Composition Definition would cause an endless recursion. Composition Definition is defined through
        // Composition Definition itself (child types "Include in Label", "Ordered"). ### FIXDOC: this is obsolete
        // Note: the "othersTopicTypeUri" filter is not set here (null). We want match both "dm4.core.topic_type"
        // and "dm4.core.meta_type" (the latter is required e.g. by dm4-mail). ### TODO: add a getRelatedTopics()
        // method that takes a list of topic types.
        ResultList<RelatedTopic> childTypes = typeTopic.getRelatedTopics(asList("dm4.core.aggregation_def",
            "dm4.core.composition_def"), "dm4.core.parent_type", "dm4.core.child_type", null, 0);
            // othersTopicTypeUri=null, maxResultSize=0
        //
        // 2) create association definitions
        // Note: the returned map is an intermediate, hashed by ID. The actual type model is
        // subsequently build from it by sorting the assoc def's according to the sequence IDs.
        for (RelatedTopic childType : childTypes) {
            AssociationDefinitionModel assocDef = fetchAssociationDefinition(childType.getRelatingAssociation(),
                typeTopic.getUri(), childType.getUri());
            assocDefs.put(assocDef.getId(), assocDef);
        }
        return assocDefs;
    }

    // ---

    @Override
    public AssociationDefinitionModel fetchAssociationDefinition(Association assoc) {
        return fetchAssociationDefinition(assoc, fetchParentType(assoc).getUri(), fetchChildType(assoc).getUri());
    }

    private AssociationDefinitionModel fetchAssociationDefinition(Association assoc, String parentTypeUri,
                                                                                     String childTypeUri) {
        try {
            long assocId = assoc.getId();
            return new AssociationDefinitionModel(
                assocId, assoc.getUri(), assoc.getTypeUri(), fetchCustomAssocTypeUri(assoc),
                parentTypeUri, childTypeUri,
                fetchCardinalityOrThrow(assocId, PARENT_CARDINALITY).getUri(),
                fetchCardinalityOrThrow(assocId, CHILD_CARDINALITY).getUri(),
                fetchAssocDefViewConfig(assoc)
            );
        } catch (Exception e) {
            throw new RuntimeException("Fetching association definition failed (parentTypeUri=\"" + parentTypeUri +
                "\", childTypeUri=" + childTypeUri + ", " + assoc + ")", e);
        }
    }

    private String fetchCustomAssocTypeUri(Association assoc) {
        TopicModel assocType = dms.storageDecorator.fetchAssociationRelatedTopic(assoc.getId(),
            "dm4.core.custom_assoc_type", "dm4.core.parent", "dm4.core.child", "dm4.core.assoc_type");
        return assocType != null ? assocType.getUri() : null;
    }

    // ---

    private List<AssociationDefinitionModel> sortAssocDefs(Map<Long, AssociationDefinitionModel> assocDefs,
                                                           List<Long> sequence) {
        List<AssociationDefinitionModel> sortedAssocDefs = new ArrayList();
        for (long assocDefId : sequence) {
            AssociationDefinitionModel assocDef = assocDefs.get(assocDefId);
            // error check
            if (assocDef == null) {
                throw new RuntimeException("DB inconsistency: ID " + assocDefId +
                    " is in sequence but not in the type's association definitions");
            }
            sortedAssocDefs.add(assocDef);
        }
        return sortedAssocDefs;
    }

    // --- Store ---

    private void storeAssocDefs(long typeId, Collection<AssociationDefinitionModel> assocDefs) {
        for (AssociationDefinitionModel assocDef : assocDefs) {
            storeAssociationDefinition(assocDef);
        }
        storeSequence(typeId, assocDefs);
    }

    void storeAssociationDefinition(AssociationDefinitionModel assocDef) {
        try {
            // 1) create association
            // Note: if the association definition has been created interactively the underlying association
            // exists already. Its ID is already known. A possible Custom Association Type assignment is
            // already stored as well.
            if (assocDef.getId() == -1) {
                // 1a) custom association type
                String customAssocTypeUri = assocDef.getCustomAssocTypeUri();
                if (customAssocTypeUri != null) {
                    assocDef.getChildTopicsModel().putRef("dm4.core.assoc_type", customAssocTypeUri);
                }
                //
                dms.createAssociation(assocDef);
            }
            // Note: the assoc def ID is definitely known only after creating the association
            long assocDefId = assocDef.getId();
            //
            // 2) cardinality
            // Note: if the underlying association was an association definition before it has cardinality
            // assignments already. These must be removed before assigning new cardinality.
            removeCardinalityAssignmentIfExists(assocDefId, PARENT_CARDINALITY);
            removeCardinalityAssignmentIfExists(assocDefId, CHILD_CARDINALITY);
            associateCardinality(assocDefId, PARENT_CARDINALITY, assocDef.getParentCardinalityUri());
            associateCardinality(assocDefId, CHILD_CARDINALITY,  assocDef.getChildCardinalityUri());
            //
            // 3) view config
            storeViewConfig(createConfigurableAssocDef(assocDefId), assocDef.getViewConfigModel());
        } catch (Exception e) {
            throw new RuntimeException("Storing association definition \"" + assocDef.getChildTypeUri() +
                "\" of type \"" + assocDef.getParentTypeUri() + "\" failed", e);
        }
    }



    // === Parent Type / Child Type ===

    // --- Fetch ---

    @Override
    public Topic fetchParentType(Association assoc) {
        Topic parentTypeTopic = assoc.getTopic("dm4.core.parent_type");
        // error check
        if (parentTypeTopic == null) {
            throw new RuntimeException("Invalid association definition: topic role dm4.core.parent_type " +
                "is missing in " + assoc);
        }
        //
        return parentTypeTopic;
    }

    @Override
    public Topic fetchChildType(Association assoc) {
        Topic childTypeTopic = assoc.getTopic("dm4.core.child_type");
        // error check
        if (childTypeTopic == null) {
            throw new RuntimeException("Invalid association definition: topic role dm4.core.child_type " +
                "is missing in " + assoc);
        }
        //
        return childTypeTopic;
    }



    // === Cardinality ===

    // --- Fetch ---

    private RelatedTopicModel fetchCardinality(long assocDefId, String cardinalityRoleTypeUri) {
        return dms.storageDecorator.fetchAssociationRelatedTopic(assocDefId,
            "dm4.core.aggregation", "dm4.core.assoc_def", cardinalityRoleTypeUri, "dm4.core.cardinality");
    }

    private RelatedTopicModel fetchCardinalityOrThrow(long assocDefId, String cardinalityRoleTypeUri) {
        RelatedTopicModel cardinality = fetchCardinality(assocDefId, cardinalityRoleTypeUri);
        // error check
        if (cardinality == null) {
            throw new RuntimeException("Invalid association definition: cardinality is missing (assocDefId=" +
                assocDefId + ", cardinalityRoleTypeUri=\"" + cardinalityRoleTypeUri + "\")");
        }
        //
        return cardinality;
    }

    // --- Store ---

    void storeParentCardinalityUri(long assocDefId, String parentCardinalityUri) {
        storeCardinalityUri(assocDefId, PARENT_CARDINALITY, parentCardinalityUri);
    }

    void storeChildCardinalityUri(long assocDefId, String childCardinalityUri) {
        storeCardinalityUri(assocDefId, CHILD_CARDINALITY, childCardinalityUri);
    }

    // ---

    private void storeCardinalityUri(long assocDefId, String cardinalityRoleTypeUri, String cardinalityUri) {
        // remove current assignment
        RelatedTopicModel cardinality = fetchCardinalityOrThrow(assocDefId, cardinalityRoleTypeUri);
        removeCardinalityAssignment(cardinality);
        // create new assignment
        associateCardinality(assocDefId, cardinalityRoleTypeUri, cardinalityUri);
    }

    private void removeCardinalityAssignmentIfExists(long assocDefId, String cardinalityRoleTypeUri) {
        RelatedTopicModel cardinality = fetchCardinality(assocDefId, cardinalityRoleTypeUri);
        if (cardinality != null) {
            removeCardinalityAssignment(cardinality);
        }
    }

    private void removeCardinalityAssignment(RelatedTopicModel cardinalityAssignment) {
        long assocId = cardinalityAssignment.getRelatingAssociation().getId();
        dms.deleteAssociation(assocId);
    }

    private void associateCardinality(long assocDefId, String cardinalityRoleTypeUri, String cardinalityUri) {
        dms.createAssociation("dm4.core.aggregation",
            new TopicRoleModel(cardinalityUri, cardinalityRoleTypeUri),
            new AssociationRoleModel(assocDefId, "dm4.core.assoc_def"));
    }



    // === Sequence ===

    // --- Fetch ---

    // Note: the sequence is fetched in 2 situations:
    // 1) When fetching a type's association definitions.
    //    In this situation we don't have a Type object at hand but a sole type topic.
    // 2) When deleting a sequence in order to rebuild it.
    private List<RelatedAssociationModel> fetchSequence(Topic typeTopic) {
        try {
            List<RelatedAssociationModel> sequence = new ArrayList();
            //
            RelatedAssociationModel assocDef = fetchSequenceStart(typeTopic.getId());
            if (assocDef != null) {
                sequence.add(assocDef);
                while ((assocDef = fetchSuccessor(assocDef.getId())) != null) {
                    sequence.add(assocDef);
                }
            }
            //
            return sequence;
        } catch (Exception e) {
            throw new RuntimeException("Fetching sequence for type \"" + typeTopic.getUri() + "\" failed", e);
        }
    }

    // ---

    private RelatedAssociationModel fetchSequenceStart(long typeId) {
        return dms.storageDecorator.fetchTopicRelatedAssociation(typeId, "dm4.core.aggregation",
            "dm4.core.type", "dm4.core.sequence_start", null);      // othersAssocTypeUri=null
    }

    private RelatedAssociationModel fetchSuccessor(long assocDefId) {
        return dms.storageDecorator.fetchAssociationRelatedAssociation(assocDefId, "dm4.core.sequence",
            "dm4.core.predecessor", "dm4.core.successor", null);    // othersAssocTypeUri=null
    }

    private RelatedAssociationModel fetchPredecessor(long assocDefId) {
        return dms.storageDecorator.fetchAssociationRelatedAssociation(assocDefId, "dm4.core.sequence",
            "dm4.core.successor", "dm4.core.predecessor", null);    // othersAssocTypeUri=null
    }

    // --- Store ---

    private void storeSequence(long typeId, Collection<AssociationDefinitionModel> assocDefs) {
        logger.fine("### Storing " + assocDefs.size() + " sequence segments for type " + typeId);
        AssociationDefinitionModel lastAssocDef = null;
        for (AssociationDefinitionModel assocDef : assocDefs) {
            appendToSequence(typeId, assocDef.getId(), lastAssocDef);
            lastAssocDef = assocDef;
        }
    }

    void appendToSequence(long typeId, long assocDefId, AssociationDefinitionModel lastAssocDef) {
        if (lastAssocDef == null) {
            storeSequenceStart(typeId, assocDefId);
        } else {
            storeSequenceSegment(lastAssocDef.getId(), assocDefId);
        }
    }

    void insertAtSequenceStart(long typeId, long assocDefId) {
        // delete sequence start
        RelatedAssociationModel assocDef = fetchSequenceStart(typeId);
        dms.deleteAssociation(assocDef.getRelatingAssociation().getId());
        // reconnect
        storeSequenceStart(typeId, assocDefId);
        storeSequenceSegment(assocDefId, assocDef.getId());
    }

    void insertIntoSequence(long assocDefId, long beforeAssocDefId) {
        // delete sequence segment
        RelatedAssociationModel assocDef = fetchPredecessor(beforeAssocDefId);
        dms.deleteAssociation(assocDef.getRelatingAssociation().getId());
        // reconnect
        storeSequenceSegment(assocDef.getId(), assocDefId);
        storeSequenceSegment(assocDefId, beforeAssocDefId);
    }

    // ---

    private void storeSequenceStart(long typeId, long assocDefId) {
        dms.createAssociation("dm4.core.aggregation",
            new TopicRoleModel(typeId, "dm4.core.type"),
            new AssociationRoleModel(assocDefId, "dm4.core.sequence_start"));
    }

    private void storeSequenceSegment(long predAssocDefId, long succAssocDefId) {
        dms.createAssociation("dm4.core.sequence",
            new AssociationRoleModel(predAssocDefId, "dm4.core.predecessor"),
            new AssociationRoleModel(succAssocDefId, "dm4.core.successor"));
    }

    // ---

    void rebuildSequence(Type type) {
        deleteSequence(type);
        storeSequence(type.getId(), type.getModel().getAssocDefs());
    }

    private void deleteSequence(Topic typeTopic) {
        List<RelatedAssociationModel> sequence = fetchSequence(typeTopic);
        logger.info("### Deleting " + sequence.size() + " sequence segments of type \"" + typeTopic.getUri() + "\"");
        for (RelatedAssociationModel assoc : sequence) {
            long assocId = assoc.getRelatingAssociation().getId();
            dms.deleteAssociation(assocId);
        }
    }



    // === Label Configuration ===

    // --- Fetch ---

    private List<String> fetchLabelConfig(List<AssociationDefinitionModel> assocDefs) {
        List<String> labelConfig = new ArrayList();
        for (AssociationDefinitionModel assocDef : assocDefs) {
            RelatedTopicModel includeInLabel = fetchLabelConfigTopic(assocDef.getId());
            if (includeInLabel != null && includeInLabel.getSimpleValue().booleanValue()) {
                labelConfig.add(assocDef.getChildTypeUri());
            }
        }
        return labelConfig;
    }

    private RelatedTopicModel fetchLabelConfigTopic(long assocDefId) {
        return dms.storageDecorator.fetchAssociationRelatedTopic(assocDefId, "dm4.core.composition",
            "dm4.core.parent", "dm4.core.child", "dm4.core.include_in_label");
    }

    // --- Store ---

    /**
     * Stores the label configuration of a <i>newly created</i> type.
     */
    private void storeLabelConfig(List<String> labelConfig, Collection<AssociationDefinitionModel> assocDefs) {
        for (AssociationDefinitionModel assocDef : assocDefs) {
            boolean includeInLabel = labelConfig.contains(assocDef.getChildTypeUri());
            // Note: we don't do the storage in a type-driven fashion here (as in new AttachedAssociationDefinition(
            // assocDef, dms).getChildTopics().set(...)). A POST_UPDATE_ASSOCIATION event would be fired for the
            // assoc def and the Type Editor plugin would react and try to access the assoc def's parent type.
            // This means retrieving a type that is in-mid its storage process. Strange errors would occur.
            // As a workaround we create the child topic manually.
            Topic topic = dms.createTopic(new TopicModel("dm4.core.include_in_label", new SimpleValue(includeInLabel)));
            dms.createAssociation(new AssociationModel("dm4.core.composition",
                new AssociationRoleModel(assocDef.getId(), "dm4.core.parent"),
                new TopicRoleModel(topic.getId(), "dm4.core.child")
            ));
        }
    }

    /**
     * Updates the label configuration of an <i>existing</i> type.
     */
    void updateLabelConfig(List<String> labelConfig, Collection<AssociationDefinition> assocDefs) {
        for (AssociationDefinition assocDef : assocDefs) {
            boolean includeInLabel = labelConfig.contains(assocDef.getChildTypeUri());
            assocDef.getChildTopics().set("dm4.core.include_in_label", includeInLabel);
        }
    }



    // === View Configurations ===

    // --- Fetch ---

    // ### TODO: unify both methods

    private ViewConfigurationModel fetchTypeViewConfig(Topic typeTopic) {
        try {
            // Note: othersTopicTypeUri=null, the view config's topic type is unknown (it is client-specific)
            ResultList<RelatedTopic> configTopics = typeTopic.getRelatedTopics("dm4.core.aggregation",
                "dm4.core.type", "dm4.core.view_config", null, 0).loadChildTopics();
            return new ViewConfigurationModel(DeepaMehtaUtils.toTopicModels(configTopics));
        } catch (Exception e) {
            throw new RuntimeException("Fetching view configuration for type \"" + typeTopic.getUri() +
                "\" failed", e);
        }
    }

    private ViewConfigurationModel fetchAssocDefViewConfig(Association assocDef) {
        try {
            // Note: othersTopicTypeUri=null, the view config's topic type is unknown (it is client-specific)
            ResultList<RelatedTopic> configTopics = assocDef.getRelatedTopics("dm4.core.aggregation",
                "dm4.core.assoc_def", "dm4.core.view_config", null, 0).loadChildTopics();
            return new ViewConfigurationModel(DeepaMehtaUtils.toTopicModels(configTopics));
        } catch (Exception e) {
            throw new RuntimeException("Fetching view configuration for association definition " + assocDef.getId() +
                " failed", e);
        }
    }

    // --- Store ---

    private void storeViewConfig(RoleModel configurable, ViewConfigurationModel viewConfig) {
        try {
            for (TopicModel configTopic : viewConfig.getConfigTopics()) {
                storeViewConfigTopic(configurable, configTopic);
            }
        } catch (Exception e) {
            throw new RuntimeException("Storing view configuration failed (configurable=" + configurable + ")", e);
        }
    }

    Topic storeViewConfigTopic(RoleModel configurable, TopicModel configTopic) {
        Topic topic = dms.createTopic(configTopic);
        dms.createAssociation("dm4.core.aggregation", configurable, new TopicRoleModel(topic.getId(),
            "dm4.core.view_config"));
        return topic;
    }

    // --- Helper ---

    RoleModel createConfigurableType(long typeId) {
        return new TopicRoleModel(typeId, "dm4.core.type");
    }

    RoleModel createConfigurableAssocDef(long assocDefId) {
        return new AssociationRoleModel(assocDefId, "dm4.core.assoc_def");
    }
}