/*
 * Copyright The WildFly Authors
 * SPDX-License-Identifier: Apache-2.0
 */

package org.jboss.as.host.controller;

import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ACCESS;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ADD;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ADVANCED_FILTER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.APPLICATION_CLASSIFICATION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.AUDIT;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.AUDIT_LOG;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.AUTHENTICATION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.AUTHORIZATION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONFIGURATION_CHANGES;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONNECTION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONSTRAINT;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONTENT;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CORE_SERVICE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.DEFAULT_INTERFACE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.DEPLOYMENT;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.DEPLOYMENT_OVERLAY;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ENABLED;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.EXCLUDE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.EXTENSION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.FILE_HANDLER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.GROUP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.GROUP_SEARCH;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.GROUP_TO_PRINCIPAL;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.HASH;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.HOST;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.HOST_SCOPED_ROLE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.INCLUDE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.INCLUDES;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.INTERFACE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.IN_MEMORY_HANDLER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.JSON_FORMATTER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.KERBEROS;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.KEYTAB;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.LDAP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.LDAP_CONNECTION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.LOCAL_DESTINATION_OUTBOUND_SOCKET_BINDING;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.LOGGER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.MANAGEMENT;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.MAX_HISTORY;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.NAMESPACES;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PATH;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PERIODIC_ROTATING_FILE_HANDLER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PORT_OFFSET;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PRINCIPAL_TO_GROUP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PROFILE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PROFILE_NAME;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PROPERTIES;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PROVIDER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RELATIVE_TO;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.REMOTE_DESTINATION_OUTBOUND_SOCKET_BINDING;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ROLE_MAPPING;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RUNTIME_NAME;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SCHEMA_LOCATIONS;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SECURITY_REALM;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SENSITIVITY_CLASSIFICATION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SERVER_CONFIG;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SERVER_GROUP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SERVER_GROUP_SCOPED_ROLE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SERVER_IDENTITY;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SERVER_LOGGER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SERVICE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SIZE_ROTATING_FILE_HANDLER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SOCKET_BINDING;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SOCKET_BINDING_DEFAULT_INTERFACE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SOCKET_BINDING_GROUP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SOCKET_BINDING_PORT_OFFSET;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SYSLOG_HANDLER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SYSTEM_PROPERTY;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.USERNAME_FILTER;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.USERNAME_IS_DN;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.USERNAME_TO_DN;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.VALUE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.VAULT;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.VAULT_EXPRESSION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.VAULT_OPTIONS;
import static org.jboss.as.host.controller.ManagedServerBootCmdFactory.resolveExpressions;

import java.io.File;
import java.util.AbstractList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.jboss.as.controller.AttributeDefinition;
import org.jboss.as.controller.ExpressionResolver;
import org.jboss.as.controller.OperationFailedException;
import org.jboss.as.controller.PathAddress;
import org.jboss.as.controller.PathElement;
import org.jboss.as.controller.SimpleAttributeDefinition;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CLASSIFICATION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONFIGURED_APPLICATION;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONFIGURED_REQUIRES_ADDRESSABLE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONFIGURED_REQUIRES_READ;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.CONFIGURED_REQUIRES_WRITE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.TYPE;
import org.jboss.as.controller.operations.common.NamespaceAddHandler;
import org.jboss.as.controller.operations.common.SchemaLocationAddHandler;
import org.jboss.as.server.services.net.SocketBindingAddHandler;
import org.jboss.as.controller.operations.common.Util;
import org.jboss.as.controller.parsing.Attribute;
import org.jboss.as.controller.resource.InterfaceDefinition;
import org.jboss.as.controller.services.path.PathAddHandler;
import org.jboss.as.domain.controller.DomainController;
import org.jboss.as.domain.controller.LocalHostControllerInfo;
import org.jboss.as.domain.management.access.SensitivityResourceDefinition;
import org.jboss.as.domain.management.audit.AuditLogLoggerResourceDefinition;
import org.jboss.as.domain.management.audit.FileAuditLogHandlerResourceDefinition;
import org.jboss.as.domain.management.audit.InMemoryAuditLogHandlerResourceDefinition;
import org.jboss.as.domain.management.audit.JsonAuditLogFormatterResourceDefinition;
import org.jboss.as.domain.management.audit.PeriodicRotatingFileAuditLogHandlerResourceDefinition;
import org.jboss.as.domain.management.audit.SizeRotatingFileAuditLogHandlerResourceDefinition;
import org.jboss.as.domain.management.audit.SyslogAuditLogHandlerResourceDefinition;
import org.jboss.as.host.controller.logging.HostControllerLogger;
import org.jboss.as.repository.ContentReference;
import org.jboss.as.repository.HostFileRepository;
import org.jboss.as.server.controller.resources.SystemPropertyResourceDefinition;
import org.jboss.as.server.deployment.ModelContentReference;
import org.jboss.as.server.operations.SetServerGroupHostHandler;
import org.jboss.as.server.operations.SystemPropertyAddHandler;
import org.jboss.as.server.services.net.BindingGroupAddHandler;
import org.jboss.as.server.services.net.LocalDestinationOutboundSocketBindingResourceDefinition;
import org.jboss.as.server.services.net.RemoteDestinationOutboundSocketBindingResourceDefinition;
import org.jboss.dmr.ModelNode;
import org.jboss.dmr.Property;

/**
 * Factory creating the boot operations for a {@linkplain ManagedServer}.
 *
 * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
 * @author <a href="mailto:jperkins@redhat.com">James R. Perkins</a>
 * @author Emanuel Muckenhuber
 */
public final class ManagedServerOperationsFactory {

    private static final ModelNode EMPTY = new ModelNode();

    static {
        EMPTY.setEmptyList();
        EMPTY.protect();
    }

    /**
     * Create a list of operations required to a boot a managed server.
     *
     * @param serverName the server name
     * @param domainModel the complete domain model
     * @param hostModel the local host model
     * @param domainController the domain controller
     * @return the list of boot operations
     */
    public static ModelNode createBootUpdates(final String serverName, final ModelNode domainModel, final ModelNode hostModel,
                                              final DomainController domainController, final ExpressionResolver expressionResolver) {
        final ManagedServerOperationsFactory factory = new ManagedServerOperationsFactory(serverName, domainModel,
                hostModel, domainController, expressionResolver);


        return factory.getBootUpdates();
    }

    private final String serverName;
    private final ModelNode domainModel;
    private final ModelNode hostModel;
    private final ModelNode serverModel;
    private final ModelNode serverGroup;
    private final String serverGroupName;
    private final String profileName;
    private final DomainController domainController;

    ManagedServerOperationsFactory(final String serverName, final ModelNode domainModel, final ModelNode hostModel,
                                   final DomainController domainController, final ExpressionResolver expressionResolver) {
        this.serverName = serverName;
        this.domainModel = domainModel;
        this.hostModel = hostModel;
        this.domainController = domainController;
        ManagedServerBootCmdFactory.ManagedServerExprResolver managedServerExpResolver = new ManagedServerBootCmdFactory.ManagedServerExprResolver(expressionResolver, this.serverName);
        this.serverModel = resolveExpressions(hostModel.require(SERVER_CONFIG).require(serverName), managedServerExpResolver, true);

        this.serverGroupName = serverModel.require(GROUP).asString();
        this.serverGroup = resolveExpressions(domainModel.require(SERVER_GROUP).require(serverGroupName), managedServerExpResolver, true);
        this.profileName = serverGroup.require(PROFILE).asString();
    }

    ModelNode getBootUpdates() {

        int portOffSet = 0;
        String socketBindingRef = null;
        String defaultInterface = null;

        if (serverGroup.hasDefined(SOCKET_BINDING_GROUP)) {
            socketBindingRef = serverGroup.get(SOCKET_BINDING_GROUP).asString();
        }
        if (serverModel.hasDefined(SOCKET_BINDING_GROUP)) {
            socketBindingRef = serverModel.get(SOCKET_BINDING_GROUP).asString();
        }
        if (serverGroup.hasDefined(SOCKET_BINDING_PORT_OFFSET)) {
            portOffSet = serverGroup.get(SOCKET_BINDING_PORT_OFFSET).asInt();
        }
        if (serverModel.hasDefined(SOCKET_BINDING_PORT_OFFSET)) {
            portOffSet = serverModel.get(SOCKET_BINDING_PORT_OFFSET).asInt();
        }
        if (serverGroup.hasDefined(SOCKET_BINDING_DEFAULT_INTERFACE)) {
            defaultInterface = serverGroup.get(SOCKET_BINDING_DEFAULT_INTERFACE).asString();
        }
        if (serverModel.hasDefined(SOCKET_BINDING_DEFAULT_INTERFACE)) {
            defaultInterface = serverModel.get(SOCKET_BINDING_DEFAULT_INTERFACE).asString();
        }
        if (socketBindingRef == null) {
            throw HostControllerLogger.ROOT_LOGGER.undefinedSocketBinding(serverName);
        }

        final ModelNodeList updates = new ModelNodeList();

        setServerGroupHost(updates);
        addNamespaces(updates);
        addProfileName(updates);
        addSchemaLocations(updates);
        addExtensions(updates);
        addPaths(updates);
        addSystemProperties(updates);
        addVault(updates);
        addManagementSecurityRealms(updates);
        addAuditLog(updates);
        addManagementConnections(updates);
        addManagementAuthorization(updates);
        addConfigurationChanges(updates);
        addInterfaces(updates);
        addSocketBindings(updates, portOffSet, socketBindingRef, defaultInterface);
        addSubsystems(updates);
        addDeployments(updates);
        addDeploymentOverlays(updates);

        return updates.model;
    }

    private void setServerGroupHost(ModelNodeList updates) {
        ModelNode op = Util.createEmptyOperation(SetServerGroupHostHandler.OPERATION_NAME, null);
        op.get(SERVER_GROUP).set(serverGroupName);
        LocalHostControllerInfo lhci = domainController.getLocalHostInfo();
        op.get(HOST).set(lhci.getLocalHostName());

        updates.add(op);
    }

    private void addNamespaces(List<ModelNode> updates) {
        final Map<String, ModelNode> map = new LinkedHashMap<String, ModelNode>();
        addNamespaces(map, domainModel.get(NAMESPACES));
        addNamespaces(map, hostModel.get(NAMESPACES));
        updates.addAll(map.values());
    }

    private void addNamespaces(Map<String, ModelNode> map, ModelNode namespaces) {
        if (namespaces.isDefined()) {
            for (Property prop : namespaces.asPropertyList()) {
                map.put(prop.getName(), NamespaceAddHandler.getAddNamespaceOperation(EMPTY, prop.getName(), prop.getValue().asString()));
            }
        }
    }

    private void addProfileName(List<ModelNode> updates) {
        updates.add(Util.getWriteAttributeOperation(EMPTY, PROFILE_NAME, profileName));
    }

    private void addSchemaLocations(List<ModelNode> updates) {
        final Map<String, ModelNode> map = new LinkedHashMap<String, ModelNode>();
        addSchemaLocations(map, domainModel.get(SCHEMA_LOCATIONS));
        addSchemaLocations(map, hostModel.get(SCHEMA_LOCATIONS));
        updates.addAll(map.values());
    }

    private void addSchemaLocations(Map<String, ModelNode> map, ModelNode namespaces) {
        if (namespaces.isDefined()) {
            for (Property prop : namespaces.asPropertyList()) {
                map.put(prop.getName(), SchemaLocationAddHandler.getAddSchemaLocationOperation(EMPTY, prop.getName(), prop.getValue().asString()));
            }
        }
    }

    private void addExtensions(List<ModelNode> updates) {
        final Set<String> extensionNames = new LinkedHashSet<String>();
        addExtensions(extensionNames, domainModel.get(EXTENSION));

        for (String name : extensionNames) {
            updates.add(Util.createAddOperation(PathAddress.pathAddress(PathElement.pathElement(EXTENSION, name))));
        }
    }

    private void addExtensions(Set<String> extensionNames, ModelNode extensions) {
        if (extensions.isDefined()) {
            extensionNames.addAll(extensions.keys());
        }
    }

    private void addPaths(List<ModelNode> updates) {
        final Map<String, ModelNode> paths = new LinkedHashMap<String, ModelNode>();
        addPaths(paths, domainModel.get(PATH));
        addPaths(paths, hostModel.get(PATH));
        addPaths(paths, serverModel.get(PATH));

        for (Map.Entry<String, ModelNode> entry : paths.entrySet()) {
            updates.add(PathAddHandler.getAddPathOperation(PathAddress.pathAddress(PathElement.pathElement(PATH, entry.getKey())), entry.getValue().get(PATH), entry.getValue().get(RELATIVE_TO)));
        }
    }

    private void addPaths(Map<String, ModelNode> map, ModelNode path) {
        if (path.isDefined()) {
            for (Property prop : path.asPropertyList()) {
                //TODO merge rather than replace existing?
                map.put(prop.getName(), prop.getValue());
            }
        }
    }

    private void addSystemProperties(List<ModelNode> updates) {
        Map<String, String> props = getAllSystemProperties(false);

        for (Map.Entry<String, String> entry : props.entrySet()) {
            ModelNode address = new ModelNode();
            address.add(SYSTEM_PROPERTY, entry.getKey());
            ModelNode op = Util.getEmptyOperation(SystemPropertyAddHandler.OPERATION_NAME, address);
            if (entry.getValue() != null) {
                op.get(VALUE).set(entry.getValue());
            }
            updates.add(op);
        }
    }

    private Map<String, String> getAllSystemProperties(boolean boottimeOnly) {
        Map<String, String> props = new LinkedHashMap<String, String>();

        addSystemProperties(domainModel, props, boottimeOnly);
        addSystemProperties(serverGroup, props, boottimeOnly);
        addSystemProperties(hostModel, props, boottimeOnly);
        addSystemProperties(serverModel, props, boottimeOnly);

        return props;
    }

    private void addSystemProperties(final ModelNode source, final Map<String, String> props, boolean boottimeOnly) {
        if (source.hasDefined(SYSTEM_PROPERTY)) {
            for (Property prop : source.get(SYSTEM_PROPERTY).asPropertyList()) {
                ModelNode propResource = prop.getValue();
                try {
                    if (boottimeOnly && !SystemPropertyResourceDefinition.BOOT_TIME.resolveModelAttribute(domainController.getExpressionResolver(), propResource).asBoolean()) {
                        continue;
                    }
                } catch (OperationFailedException e) {
                    throw new IllegalStateException(e);
                }
                String val = propResource.hasDefined(VALUE) ? propResource.get(VALUE).asString() : null;
                props.put(prop.getName(), val);
            }
        }
    }

    private void addVault(List<ModelNode> updates) {
        if (hostModel.get(CORE_SERVICE).isDefined()) {
            addVault(updates, hostModel.get(CORE_SERVICE).get(VAULT));
        }
    }

    private void addVault(List<ModelNode> updates, ModelNode vaultNode) {
        if (vaultNode.isDefined()) {
            ModelNode vault = new ModelNode();
            ModelNode codeNode = vaultNode.get(Attribute.CODE.getLocalName());
            if (codeNode.isDefined()) {
                vault.get(Attribute.CODE.getLocalName()).set(codeNode.asString());
            }
            ModelNode moduleNode = vaultNode.get(Attribute.MODULE.getLocalName());
            if (moduleNode.isDefined()) {
                vault.get(Attribute.MODULE.getLocalName()).set(moduleNode.asString());
            }
            ModelNode vaultAddress = new ModelNode();
            vaultAddress.add(CORE_SERVICE, VAULT);
            addAddNameAndAddress(vault, vaultAddress);

            ModelNode optionsNode = vaultNode.get(VAULT_OPTIONS);
            if (optionsNode.isDefined()) {
                vault.get(VAULT_OPTIONS).set(optionsNode);
            }
            updates.add(vault);
        }
    }

    private void addManagementSecurityRealms(List<ModelNode> updates) {
        if (hostModel.get(CORE_SERVICE, MANAGEMENT, SECURITY_REALM).isDefined()) {
            ModelNode securityRealms = hostModel.get(CORE_SERVICE, MANAGEMENT, SECURITY_REALM);
            Set<String> keys = securityRealms.keys();
            for (String current : keys) {
                ModelNode addOp = new ModelNode();
                ModelNode realmAddress = new ModelNode();
                realmAddress.add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, current);
                addAddNameAndAddress(addOp, realmAddress);
                updates.add(addOp);

                ModelNode currentRealm = securityRealms.get(current);
                if (currentRealm.hasDefined(SERVER_IDENTITY)) {
                    ModelNode serverIdentity = currentRealm.require(SERVER_IDENTITY);
                    if (serverIdentity.hasDefined(KERBEROS)) {
                        addKerberosServerIdentity(serverIdentity, realmAddress, updates);
                    } else {
                        addManagementComponentComponent(currentRealm, realmAddress, SERVER_IDENTITY, updates);
                    }
                }
                if (currentRealm.hasDefined(AUTHENTICATION)) {
                    addManagementComponentComponent(currentRealm, realmAddress, AUTHENTICATION, updates);
                }
                if (currentRealm.hasDefined(AUTHORIZATION)) {
                    ModelNode authorization = currentRealm.require(AUTHORIZATION);
                    if (authorization.hasDefined(PROPERTIES)) {
                        addManagementComponentComponent(currentRealm, realmAddress, AUTHORIZATION, updates);
                    } else if (authorization.hasDefined(LDAP)) {
                        ModelNode ldap = authorization.require(LDAP);
                        // Add authorization=ldap
                        ModelNode addLdap = new ModelNode();
                        ModelNode ldapAddr = realmAddress.clone().add(AUTHORIZATION, LDAP);
                        addAddNameAndAddress(addLdap, ldapAddr);
                        addLdap.get(CONNECTION).set(ldap.get(CONNECTION));
                        updates.add(addLdap);

                        // Add sub-resources
                        if (ldap.hasDefined(USERNAME_TO_DN)) {
                            ModelNode usernameToDn = ldap.require(USERNAME_TO_DN);
                            if (usernameToDn.hasDefined(USERNAME_IS_DN)) {
                                addLdapChild(usernameToDn.require(USERNAME_IS_DN), ldapAddr, USERNAME_TO_DN, USERNAME_IS_DN, updates);
                            } else if (usernameToDn.hasDefined(USERNAME_FILTER)) {
                                addLdapChild(usernameToDn.require(USERNAME_FILTER), ldapAddr, USERNAME_TO_DN, USERNAME_FILTER, updates);
                            } else if (usernameToDn.hasDefined(ADVANCED_FILTER)) {
                                addLdapChild(usernameToDn.require(ADVANCED_FILTER), ldapAddr, USERNAME_TO_DN, ADVANCED_FILTER, updates);
                            }
                        }
                        if (ldap.hasDefined(GROUP_SEARCH)) {
                            ModelNode groupSearch = ldap.require(GROUP_SEARCH);
                            if (groupSearch.hasDefined(GROUP_TO_PRINCIPAL)) {
                                addLdapChild(groupSearch.require(GROUP_TO_PRINCIPAL), ldapAddr, GROUP_SEARCH, GROUP_TO_PRINCIPAL, updates);
                            } else if (groupSearch.hasDefined(PRINCIPAL_TO_GROUP)) {
                                addLdapChild(groupSearch.require(PRINCIPAL_TO_GROUP), ldapAddr, GROUP_SEARCH, PRINCIPAL_TO_GROUP, updates);
                            }
                        }
                    }
                }
            }
        }
    }

    private void addKerberosServerIdentity(ModelNode serverIdentity, ModelNode realmAddress, List<ModelNode> updates) {
        ModelNode kerberos = serverIdentity.require(KERBEROS);
        ModelNode addKerberos = new ModelNode();
        ModelNode kerberosAddr = realmAddress.clone().add(SERVER_IDENTITY, KERBEROS);
        addAddNameAndAddress(addKerberos, kerberosAddr);
        updates.add(addKerberos);
        if (kerberos.hasDefined(KEYTAB)) {
            ModelNode keytab = kerberos.require(KEYTAB);
            ModelNode addKeytab = new ModelNode();
            Property keytabProp = keytab.asProperty();
            convertAttributesToParams(keytabProp.getValue(), addKeytab);
            addAddNameAndAddress(addKeytab, kerberosAddr.clone().add(KEYTAB, keytabProp.getName()));
            updates.add(addKeytab);
        }
    }

    private void addLdapChild(ModelNode child, ModelNode parentAddress, String key, String value, List<ModelNode> updates) {
        ModelNode add = new ModelNode();
        convertAttributesToParams(child, add);
        addAddNameAndAddress(add, parentAddress.clone().add(key, value));
        updates.add(add);
    }

    private void addManagementComponentComponent(ModelNode parent, ModelNode parentAddress, String key, List<ModelNode> updates) {
        for (String currentComponent : parent.get(key).keys()) {
            ModelNode addComponent = new ModelNode();
            // First take the properties to pass over.
            addComponent.set(parent.get(key, currentComponent));

            // Now convert it to an operation by adding a name and address.
            ModelNode identityAddress = parentAddress.clone().add(key, currentComponent);
            addAddNameAndAddress(addComponent, identityAddress);

            updates.add(addComponent);
        }
    }

    private void addAuditLog(ModelNodeList updates) {
        final ModelNode auditLogModel = hostModel.get(CORE_SERVICE, MANAGEMENT, ACCESS, AUDIT);
        if (auditLogModel.isDefined()){
            final PathAddress auditLogAddr = PathAddress.pathAddress(PathElement.pathElement(CORE_SERVICE, MANAGEMENT), PathElement.pathElement(ACCESS, AUDIT));
            updates.add(Util.createAddOperation(auditLogAddr));
            if (auditLogModel.get(JSON_FORMATTER).isDefined()) {
                for (Property formatterProp : auditLogModel.get(JSON_FORMATTER).asPropertyList()) {
                    final PathAddress formatterAddress = auditLogAddr.append(PathElement.pathElement(JSON_FORMATTER, formatterProp.getName()));
                    updates.add(JsonAuditLogFormatterResourceDefinition.createServerAddOperation(formatterAddress, formatterProp.getValue()));
                }
            }
            if (auditLogModel.get(IN_MEMORY_HANDLER).isDefined()){
                for (Property fileProp : auditLogModel.get(IN_MEMORY_HANDLER).asPropertyList()){
                    final PathAddress fileHandlerAddress = auditLogAddr.append(PathElement.pathElement(IN_MEMORY_HANDLER, fileProp.getName()));
                    updates.add(InMemoryAuditLogHandlerResourceDefinition.createServerAddOperation(fileHandlerAddress, fileProp.getValue()));
                }
            }
            if (auditLogModel.get(FILE_HANDLER).isDefined()){
                for (Property fileProp : auditLogModel.get(FILE_HANDLER).asPropertyList()){
                    final PathAddress fileHandlerAddress = auditLogAddr.append(PathElement.pathElement(FILE_HANDLER, fileProp.getName()));
                    updates.add(FileAuditLogHandlerResourceDefinition.createServerAddOperation(fileHandlerAddress, fileProp.getValue()));
                }
            }
            if (auditLogModel.get(SIZE_ROTATING_FILE_HANDLER).isDefined()){
                for (Property sizeRotatingFileProp : auditLogModel.get(SIZE_ROTATING_FILE_HANDLER).asPropertyList()){
                    final PathAddress sizeRotatingFileHandlerAddress = auditLogAddr.append(PathElement.pathElement(SIZE_ROTATING_FILE_HANDLER, sizeRotatingFileProp.getName()));
                    updates.add(SizeRotatingFileAuditLogHandlerResourceDefinition.createServerAddOperation(sizeRotatingFileHandlerAddress, sizeRotatingFileProp.getValue()));
                }
            }
            if (auditLogModel.get(PERIODIC_ROTATING_FILE_HANDLER).isDefined()){
                for (Property periodicRotatingFileProp : auditLogModel.get(PERIODIC_ROTATING_FILE_HANDLER).asPropertyList()){
                    final PathAddress periodicRotatingFileHandlerAddress = auditLogAddr.append(PathElement.pathElement(PERIODIC_ROTATING_FILE_HANDLER, periodicRotatingFileProp.getName()));
                    updates.add(PeriodicRotatingFileAuditLogHandlerResourceDefinition.createServerAddOperation(periodicRotatingFileHandlerAddress, periodicRotatingFileProp.getValue()));
                }
            }
            if (auditLogModel.get(SYSLOG_HANDLER).isDefined()){
                for (Property syslogProp : auditLogModel.get(SYSLOG_HANDLER).asPropertyList()){
                    final PathAddress syslogHandlerAddress = auditLogAddr.append(SYSLOG_HANDLER, syslogProp.getName());
                    SyslogAuditLogHandlerResourceDefinition.createServerAddOperations(updates, syslogHandlerAddress, syslogProp.getValue());
                }
            }
            if (auditLogModel.get(SERVER_LOGGER, AUDIT_LOG).isDefined()){
                //server-logger=audit-log becomes logger=audit-log on the server
                final PathAddress loggerAddress = auditLogAddr.append(LOGGER, AUDIT_LOG);
                AuditLogLoggerResourceDefinition.createServerAddOperations(updates, loggerAddress, auditLogModel.get(SERVER_LOGGER, AUDIT_LOG));
            }
        }
    }

    private void addConfigurationChanges(ModelNodeList updates) {
        final ModelNode configurationChangesModel = hostModel.get(CORE_SERVICE, MANAGEMENT, SERVICE, CONFIGURATION_CHANGES);
        if (configurationChangesModel.isDefined()) {
            ModelNode addConfigurationChanges = Util.createAddOperation(PathAddress.pathAddress().append(CORE_SERVICE, MANAGEMENT).append(SERVICE, CONFIGURATION_CHANGES));
            addConfigurationChanges.get(MAX_HISTORY).set(configurationChangesModel.get(MAX_HISTORY));
            updates.add(addConfigurationChanges);
        }
    }

    private void addManagementConnections(List<ModelNode> updates) {
        if (hostModel.get(CORE_SERVICE, MANAGEMENT, LDAP_CONNECTION).isDefined()) {
            ModelNode baseAddress = new ModelNode();
            baseAddress.add(CORE_SERVICE, MANAGEMENT);

            ModelNode connections = hostModel.get(CORE_SERVICE, MANAGEMENT, LDAP_CONNECTION);
            for (String connectionName : connections.keys()) {
                ModelNode addConnection = new ModelNode();
                // First take the properties to pass over.
                addConnection.set(connections.get(connectionName));

                // Now convert it to an operation by adding a name and address.
                ModelNode identityAddress = baseAddress.clone().add(LDAP_CONNECTION, connectionName);
                addAddNameAndAddress(addConnection, identityAddress);

                updates.add(addConnection);
            }
        }
    }

    private void addManagementAuthorization(ModelNodeList updates) {
        ModelNode domainConfig = domainModel.get(CORE_SERVICE, MANAGEMENT, ACCESS, AUTHORIZATION);
        if (domainConfig.isDefined()) {
            ModelNode baseAddress = new ModelNode();
            baseAddress.add(CORE_SERVICE, MANAGEMENT);
            baseAddress.add(ACCESS, AUTHORIZATION);

            if (domainConfig.hasDefined(PROVIDER)) {
                ModelNode providerOp = Util.getWriteAttributeOperation(baseAddress, PROVIDER, domainConfig.get(PROVIDER));
                updates.add(providerOp);
            }

            addRoleMappings(domainConfig, baseAddress, updates);
            convertSimpleResources(domainConfig, SERVER_GROUP_SCOPED_ROLE, baseAddress, updates);
            convertSimpleResources(domainConfig, HOST_SCOPED_ROLE, baseAddress, updates);
            if (domainConfig.hasDefined(CONSTRAINT)) {
                ModelNode constraints = domainConfig.get(CONSTRAINT);
                if (constraints.hasDefined(APPLICATION_CLASSIFICATION)) {
                    convertApplicationClassificationConstraints(constraints.get(APPLICATION_CLASSIFICATION), baseAddress, updates);
                }
                if (constraints.hasDefined(SENSITIVITY_CLASSIFICATION)) {
                    convertSensitivityClassificationConstraints(constraints.get(SENSITIVITY_CLASSIFICATION), baseAddress, updates);
                }
                if (constraints.hasDefined(VAULT_EXPRESSION)) {
                    ModelNode address = baseAddress.clone().add(CONSTRAINT, VAULT_EXPRESSION);
                    ModelNode ve = constraints.get(VAULT_EXPRESSION);
                    // No add for this one; need to write attributes
                    for (AttributeDefinition ad : SensitivityResourceDefinition.getWritableVaultAttributeDefinitions()) {
                        String attr = ad.getName();
                        if (ve.hasDefined(attr)) {
                            updates.add(Util.getWriteAttributeOperation(address, attr, ve.get(attr)));
                        }
                    }
                }
            }
        }
    }

    private void addRoleMappings(ModelNode accessControl, ModelNode baseAddress, ModelNodeList updates) {
        if (accessControl.hasDefined(ROLE_MAPPING)) {
            for (Property roleProp : accessControl.get(ROLE_MAPPING).asPropertyList()) {
                ModelNode roleAddress = baseAddress.clone().add(ROLE_MAPPING, roleProp.getName());
                updates.add(Util.getEmptyOperation(ADD, roleAddress));

                ModelNode roleMapping = roleProp.getValue();
                convertSimpleResources(roleMapping, INCLUDE, roleAddress, updates);
                convertSimpleResources(roleMapping, EXCLUDE, roleAddress, updates);
            }
        }
    }

    private void addInterfaces(List<ModelNode> updates) {
        final Map<String, ModelNode> interfaces = new LinkedHashMap<String, ModelNode>();
        addInterfaces(interfaces, domainModel.get(INTERFACE));
        addInterfaces(interfaces, hostModel.get(INTERFACE));
        addInterfaces(interfaces, hostModel.get(SERVER_CONFIG, serverName, INTERFACE));

        for (Map.Entry<String, ModelNode> entry : interfaces.entrySet()) {
            updates.add(getAddInterfaceOperation(PathAddress.pathAddress(PathElement.pathElement(INTERFACE, entry.getKey())), entry.getValue()));
        }
    }
    private static ModelNode getAddInterfaceOperation(PathAddress address, ModelNode criteria) {
           ModelNode op = Util.createAddOperation(address);
           for (final AttributeDefinition def : InterfaceDefinition.ROOT_ATTRIBUTES) {
               if(criteria.hasDefined(def.getName())) {
                   op.get(def.getName()).set(criteria.get(def.getName()));
               }
           }
           return op;
       }

    private void addInterfaces(Map<String, ModelNode> map, ModelNode iface) {
        if (iface.isDefined()) {
            for (Property prop : iface.asPropertyList()) {
                map.put(prop.getName(), prop.getValue());
            }
        }
    }

    private void addSocketBindings(List<ModelNode> updates, int portOffSet, String bindingRef, String defaultInterface) {
        final Set<String> processed = new HashSet<String>();
        final Map<String, ModelNode> groups = new LinkedHashMap<String, ModelNode>();
        if (domainModel.hasDefined(SOCKET_BINDING_GROUP)) {
            for (Property prop : domainModel.get(SOCKET_BINDING_GROUP).asPropertyList()) {
                ModelNode node = prop.getValue().clone();
                if (portOffSet > 0) {
                    node.get(PORT_OFFSET).set(portOffSet);
                }
                groups.put(prop.getName(), node);
            }
        }
        final ModelNode group = groups.get(bindingRef);
        if (group == null) {
            throw HostControllerLogger.ROOT_LOGGER.undefinedSocketBindingGroup(bindingRef);
        }
        final PathAddress groupAddress = PathAddress.pathAddress(PathElement.pathElement(SOCKET_BINDING_GROUP, bindingRef));
        final ModelNode groupAdd = BindingGroupAddHandler.getOperation(groupAddress, group);
        groupAdd.get(PORT_OFFSET).set(portOffSet);
        if(defaultInterface != null) {
            groupAdd.get(DEFAULT_INTERFACE).set(defaultInterface);
        }
        updates.add(groupAdd);
        mergeBindingGroups(updates, groups, bindingRef, group, processed);
    }

    private void mergeBindingGroups(List<ModelNode> updates, Map<String, ModelNode> groups, final String groupName, ModelNode group, Set<String> processed) {
        addSocketBindings(updates, group, groupName, group.get(DEFAULT_INTERFACE));
        if (group.has(INCLUDES) && group.get(INCLUDES).isDefined()) {
            for (final ModelNode include : group.get(INCLUDES).asList()) {
                final String ref = include.asString();
                if (processed.add(ref)) {
                    final ModelNode includedGroup = groups.get(ref);
                    if (includedGroup == null) {
                        throw HostControllerLogger.ROOT_LOGGER.undefinedSocketBindingGroup(ref);
                    }
                    mergeBindingGroups(updates, groups, groupName, includedGroup, processed);
                }
            }
        }
    }

    private void addSocketBindings(List<ModelNode> updates, ModelNode group, final String groupName, ModelNode defaultInterface) {
        if (group.hasDefined(SOCKET_BINDING)) {
            for (final Property socketBinding : group.get(SOCKET_BINDING).asPropertyList()) {
                final String name = socketBinding.getName();
                final ModelNode binding = socketBinding.getValue();
                if (!binding.isDefined()) {
                    continue;
                }
                if (!binding.get(DEFAULT_INTERFACE).isDefined()) {
                    binding.get(DEFAULT_INTERFACE).set(defaultInterface);
                }
                updates.add(SocketBindingAddHandler.getOperation(PathAddress.pathAddress(PathElement.pathElement(SOCKET_BINDING_GROUP, groupName),
                        PathElement.pathElement(SOCKET_BINDING, name)), binding));
            }
        }
        // outbound-socket-binding (for local destination)
        if (group.hasDefined(LOCAL_DESTINATION_OUTBOUND_SOCKET_BINDING)) {
            for (final Property localDestinationOutboundSocketBindings : group.get(LOCAL_DESTINATION_OUTBOUND_SOCKET_BINDING).asPropertyList()) {
                final String outboundSocketBindingName = localDestinationOutboundSocketBindings.getName();
                final ModelNode binding = localDestinationOutboundSocketBindings.getValue();
                if (!binding.isDefined()) {
                    continue;
                }
                // add the local destination outbound socket binding add operation
                updates.add(getLocalSocketBindingAddOperation(PathAddress.pathAddress(PathElement.pathElement(SOCKET_BINDING_GROUP, groupName),
                        PathElement.pathElement(LOCAL_DESTINATION_OUTBOUND_SOCKET_BINDING, outboundSocketBindingName)), binding));
            }
        }
        // outbound-socket-binding (for remote destination)
        if (group.hasDefined(REMOTE_DESTINATION_OUTBOUND_SOCKET_BINDING)) {
            for (final Property remoteDestinationOutboundSocketBindings : group.get(REMOTE_DESTINATION_OUTBOUND_SOCKET_BINDING).asPropertyList()) {
                final String outboundSocketBindingName = remoteDestinationOutboundSocketBindings.getName();
                final ModelNode binding = remoteDestinationOutboundSocketBindings.getValue();
                if (!binding.isDefined()) {
                    continue;
                }
                // add the local destination outbound socket binding add operation
                updates.add(getRemoteSocketBindingAddOperation(PathAddress.pathAddress(PathElement.pathElement(SOCKET_BINDING_GROUP, groupName),
                        PathElement.pathElement(REMOTE_DESTINATION_OUTBOUND_SOCKET_BINDING, outboundSocketBindingName)), binding));
            }
        }
    }

    public static ModelNode getLocalSocketBindingAddOperation(final PathAddress address, final ModelNode localDestinationOutboundSocketBinding) {
            final ModelNode addOperation = Util.createAddOperation(address);
            // socket binding reference
            for (SimpleAttributeDefinition ad : LocalDestinationOutboundSocketBindingResourceDefinition.ATTRIBUTES) {
                if (localDestinationOutboundSocketBinding.get(ad.getName()).isDefined()) {
                    addOperation.get(ad.getName()).set(localDestinationOutboundSocketBinding.get(ad.getName()));
                }
            }
            return addOperation;
        }

        public static ModelNode getRemoteSocketBindingAddOperation(final PathAddress address, final ModelNode remoteDestinationOutboundSocketBinding) {
            final ModelNode addOperation = Util.createAddOperation(address);
            for (SimpleAttributeDefinition ad : RemoteDestinationOutboundSocketBindingResourceDefinition.ATTRIBUTES) {
                if (remoteDestinationOutboundSocketBinding.get(ad.getName()).isDefined()) {
                    addOperation.get(ad.getName()).set(remoteDestinationOutboundSocketBinding.get(ad.getName()));
                }
            }
            return addOperation;
        }

    private void addSubsystems(List<ModelNode> updates) {
        ModelNode node = domainController.getProfileOperations(profileName);
        updates.addAll(node.asList());
    }

    private void addDeployments(List<ModelNode> updates) {
        if (serverGroup.hasDefined(DEPLOYMENT)) {

            HostFileRepository remoteRepository = null;
            if (!domainController.getLocalHostInfo().isMasterDomainController()) {
                remoteRepository = domainController.getRemoteFileRepository();
            }

            for (Property deployment : serverGroup.get(DEPLOYMENT).asPropertyList()) {
                String name = deployment.getName();
                ModelNode details = deployment.getValue();

                ModelNode domainDeployment = domainModel.require(DEPLOYMENT).require(name);
                ModelNode deploymentContent = domainDeployment.require(CONTENT).clone();
                PathAddress addr = PathAddress.pathAddress(PathElement.pathElement(DEPLOYMENT, name));
                if (remoteRepository != null) {
                    // Make sure we have a copy of the deployment in the local repo
                    for (ModelNode content : deploymentContent.asList()) {
                        if ((content.hasDefined(HASH))) {
                            byte[] hash = content.require(HASH).asBytes();
                            ContentReference reference = ModelContentReference.fromModelAddress(addr, hash);
                            File[] files = domainController.getLocalFileRepository().getDeploymentFiles(reference);
                            if (files == null || files.length == 0) {
                                remoteRepository.getDeploymentFiles(reference);
                            }
                        }
                    }
                }

                ModelNode addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
                addOp.get(RUNTIME_NAME).set(details.get(RUNTIME_NAME));
                addOp.get(CONTENT).set(deploymentContent);
                if (!details.hasDefined(ENABLED)) {
                    addOp.get(ENABLED).set(true);  // TODO this seems wrong
                } else {
                    addOp.get(ENABLED).set(details.get(ENABLED));
                }

                updates.add(addOp);
            }
        }
    }

    public void addDeploymentOverlays(final List<ModelNode> updates) {
        if (domainModel.hasDefined(DEPLOYMENT_OVERLAY)) {

            HostFileRepository remoteRepository = null;
            if (!domainController.getLocalHostInfo().isMasterDomainController()) {
                remoteRepository = domainController.getRemoteFileRepository();
            }

            for (Property deploymentOverlay : domainModel.get(DEPLOYMENT_OVERLAY).asPropertyList()) {
                String name = deploymentOverlay.getName();
                ModelNode details = deploymentOverlay.getValue();


                PathAddress addr = PathAddress.pathAddress(PathElement.pathElement(DEPLOYMENT_OVERLAY, name));
                ModelNode addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
                updates.add(addOp);

                if (details.hasDefined(CONTENT)) {

                    for (Property content : details.get(CONTENT).asPropertyList()) {
                        final String contentName = content.getName();
                        final ModelNode contentDetails = content.getValue();
                        byte[] hash = contentDetails.require(CONTENT).asBytes();
                        ContentReference reference = ModelContentReference.fromModelAddress(addr, hash);
                        File[] files = domainController.getLocalFileRepository().getDeploymentFiles(reference);
                        if (files == null || files.length == 0) {
                            if (remoteRepository != null) {
                                remoteRepository.getDeploymentFiles(reference);
                            }
                        }
                        addr = PathAddress.pathAddress(PathElement.pathElement(DEPLOYMENT_OVERLAY, name), PathElement.pathElement(CONTENT, contentName));
                        addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
                        addOp.get(CONTENT).get(HASH).set(contentDetails.get(CONTENT));
                        updates.add(addOp);
                    }
                }
                if (serverGroup.hasDefined(DEPLOYMENT_OVERLAY)) {
                    final ModelNode groupOverlay = serverGroup.get(DEPLOYMENT_OVERLAY).asObject();
                    if (groupOverlay.has(name)) {
                        ModelNode deploymentsNode = groupOverlay.get(name);
                        if(deploymentsNode.has(DEPLOYMENT)) {
                        for (Property content : deploymentsNode.get(DEPLOYMENT).asPropertyList()) {
                            final String deploymentName = content.getName();
                            //final ModelNode deploymentDetails = content.getValue();
                            addr = PathAddress.pathAddress(PathElement.pathElement(DEPLOYMENT_OVERLAY, name), PathElement.pathElement(DEPLOYMENT, deploymentName));
                            addOp = Util.getEmptyOperation(ADD, addr.toModelNode());
                            updates.add(addOp);
                        }
                        }
                    }
                }

            }
        }
    }

    private ModelNode addAddNameAndAddress(ModelNode op, ModelNode address){
        op.get(OP).set(ADD);
        op.get(OP_ADDR).set(address);
        return op;
    }

    private static void convertApplicationClassificationConstraints(ModelNode model, ModelNode baseAddress, ModelNodeList updates) {
        PathAddress constraintAddress = PathAddress.pathAddress(baseAddress).append(CONSTRAINT, APPLICATION_CLASSIFICATION);
        if (model.hasDefined(TYPE)) {
            for (Property prop : model.get(TYPE).asPropertyList()) {
                PathAddress constraintTypeAddress = constraintAddress.append(TYPE, prop.getName());
                if (prop.getValue().hasDefined(CLASSIFICATION)) {
                    for (Property classification : prop.getValue().get(CLASSIFICATION).asPropertyList()) {
                        PathAddress classificationAddress = constraintTypeAddress.append(CLASSIFICATION, classification.getName());
                        if (classification.getValue().hasDefined(CONFIGURED_APPLICATION)) {
                            ModelNode addOp = Util.getWriteAttributeOperation(classificationAddress, CONFIGURED_APPLICATION, classification.getValue().get(CONFIGURED_APPLICATION).asBoolean());
                            updates.add(addOp);
                        }
                    }
                }
            }
        }
    }

    private static void convertSensitivityClassificationConstraints(ModelNode model, ModelNode baseAddress, ModelNodeList updates) {
        PathAddress constraintAddress = PathAddress.pathAddress(baseAddress).append(CONSTRAINT, SENSITIVITY_CLASSIFICATION);
        if (model.hasDefined(TYPE)) {
            for (Property prop : model.get(TYPE).asPropertyList()) {
                PathAddress constraintTypeAddress = constraintAddress.append(TYPE, prop.getName());
                if (prop.getValue().hasDefined(CLASSIFICATION)) {
                    for (Property classification : prop.getValue().get(CLASSIFICATION).asPropertyList()) {
                        PathAddress classificationAddress = constraintTypeAddress.append(CLASSIFICATION, classification.getName());
                        if (classification.getValue().hasDefined(CONFIGURED_REQUIRES_READ)) {
                            ModelNode addOp = Util.getWriteAttributeOperation(classificationAddress, CONFIGURED_REQUIRES_READ, classification.getValue().get(CONFIGURED_REQUIRES_READ).asBoolean());
                            updates.add(addOp);
                        }
                        if (classification.getValue().hasDefined(CONFIGURED_REQUIRES_WRITE)) {
                            ModelNode addOp = Util.getWriteAttributeOperation(classificationAddress, CONFIGURED_REQUIRES_WRITE, classification.getValue().get(CONFIGURED_REQUIRES_WRITE).asBoolean());
                            updates.add(addOp);
                        }
                        if (classification.getValue().hasDefined(CONFIGURED_REQUIRES_ADDRESSABLE)) {
                            ModelNode addOp = Util.getWriteAttributeOperation(classificationAddress, CONFIGURED_REQUIRES_ADDRESSABLE, classification.getValue().get(CONFIGURED_REQUIRES_ADDRESSABLE).asBoolean());
                            updates.add(addOp);
                        }
                    }
                }
            }
        }
    }

    private static void convertSimpleResources(ModelNode model, String type, ModelNode baseAddress, ModelNodeList updates) {
        if (model.hasDefined(type)) {
            for (Property prop : model.get(type).asPropertyList()) {
                ModelNode address = baseAddress.clone().add(type, prop.getName());
                ModelNode addOp = Util.getEmptyOperation(ADD, address);
                convertAttributesToParams(prop.getValue(), addOp);
                updates.add(addOp);
            }
        }
    }

    private static void convertAttributesToParams(ModelNode value, ModelNode addOp) {
        if (value.isDefined()) {
            for (Property prop : value.asPropertyList()) {
                ModelNode attrVal = prop.getValue();
                if (attrVal.isDefined()) {
                    addOp.get(prop.getName()).set(attrVal);
                }
            }
        }
    }

    private class ModelNodeList extends AbstractList<ModelNode> implements List<ModelNode> {


        private final ModelNode model = new ModelNode().setEmptyList();

        @Override
        public boolean add(ModelNode modelNode) {
            model.add(modelNode);
            return true;
        }

        @Override
        public ModelNode get(int index) {
            return model.get(index);
        }

        @Override
        public int size() {
            return model.asInt();
        }
    }

}
