/*
 * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
package org.opendaylight.nemo.user.tenantmanager;

import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.RegisterUserInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Operations;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateDefinitions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.*;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.Operation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.OperationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.user.rev151010.UserRoles;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.user.rev151010.user.roles.UserRole;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

/**
 * Created by z00293636 on 2015/8/29.
 */

/* maintain tenant information, including how many tenants are active, their information */
public class TenantManage {
    private static final Logger LOG = LoggerFactory.getLogger(TenantManage.class);
    private DataBroker dataBroker;
    private User user;
    private Map<UserId, Map<NodeId, Node>> userNodeMap = new HashMap<UserId, Map<NodeId, Node>>();
    private Map<UserId, Map<ConnectionId, Connection>> userConnectionMap = new HashMap<UserId, Map<ConnectionId, Connection>>();
    private Map<UserId, Map<FlowId, Flow>> userFlowMap = new HashMap<UserId, Map<FlowId, Flow>>();
    private Map<UserId, Map<OperationId, Operation>> userOperationMap = new HashMap<UserId, Map<OperationId, Operation>>();
    private Map<UserId, Map<TemplateName, TemplateDefinition>> userTemplateDefinitionMap = new HashMap<UserId, Map<TemplateName, TemplateDefinition>>();
    private Map<UserId, Map<TemplateInstanceId, TemplateInstance>> userTemplateInstanceMap = new HashMap<UserId, Map<TemplateInstanceId, TemplateInstance>>();
    private Map<UserId, Map<String, String>> userDeleteIntent = new HashMap<UserId, Map<String, String>>();
    private Map<UserId, Map<String, String>> userNameIdMap = new HashMap<UserId, Map<String, String>>();

    public TenantManage(DataBroker dataBroker){
        this.dataBroker = dataBroker;
    }

    private void setUser(User user)
    {
        this.user = user;
    }

    public User getUser()
    {
        return user;
    }

    /**
     *
     * @return null if an error was encountered, or an empty map if there was no
     *         error but no data was retrieved.
     */
    public Map<UserRoleName, UserRole> getUserRoles() {

        InstanceIdentifier<UserRoles> userRolesInsId = InstanceIdentifier.builder(UserRoles.class).build();
        ListenableFuture<Optional<UserRoles>> userRolesFuture = this.dataBroker.newReadOnlyTransaction().read(
                LogicalDatastoreType.CONFIGURATION, userRolesInsId);

        final Optional<UserRoles> userRolesOpt;
        try {
            // TODO: consider time out here?
            userRolesOpt = userRolesFuture.get();
        } catch (InterruptedException e) {
            LOG.error("Cannot read role information.", e);
            return null;
        } catch (ExecutionException e) {
            LOG.error("Cannot read role information.", e);
            return null;
        }

        // TODO: change to Java 8 lambda expressions
        return userRolesOpt.transform(new Function<UserRoles, Map<UserRoleName, UserRole>>() {
            @Override
            public Map<UserRoleName, UserRole> apply(UserRoles input) {
                return Maps.uniqueIndex(input.getUserRole(), new Function<UserRole, UserRoleName>() {
                    @Override
                    public UserRoleName apply(UserRole role) {
                        return role.getRoleName();
                    }
                });
            }
        }).or(new HashMap<UserRoleName, UserRole>());
    }

    /**
    *
    * @return null if an error was encountered, or an empty map if there was no
    *         error but no data was retrieved.
    */
    public Map<UserId, User> getUsers() {
        InstanceIdentifier<Users> usersInsId = InstanceIdentifier.builder(Users.class).build();
        ListenableFuture<Optional<Users>> usersFuture = dataBroker.newReadOnlyTransaction().read(
                LogicalDatastoreType.CONFIGURATION, usersInsId);

        final Optional<Users> usersOpt;
        try {
            // TODO: consider time out here?
            usersOpt = usersFuture.get();
        } catch (InterruptedException e) {
            LOG.error("Cannot read user information.", e);
            return null;
        } catch (ExecutionException e) {
            LOG.error("Cannot read user information.", e);
            return null;
        }

        // TODO: change to Java 8 lambda expressions
        return usersOpt.transform(new Function<Users, Map<UserId, User>>() {
            @Override
            public Map<UserId, User> apply(Users input) {
                return Maps.uniqueIndex(input.getUser(), new Function<User, UserId>() {
                    @Override
                    public UserId apply(User user) {
                        return user.getUserId();
                    }
                });
            }
        }).or(new HashMap<UserId, User>());
    }

    public void fetchVNSpace(UserId userId){
        final Map<UserId, User> users = getUsers();
        setUser((users != null) ? users.get(userId) : null);
    }

    public void addUser(RegisterUserInput registerUserInput){
        WriteTransaction t = dataBroker.newWriteOnlyTransaction();
        if (registerUserInput.getUserId() != null)
        {
            User user = new UserBuilder(registerUserInput).build();
            UserKey userKey = new UserKey(registerUserInput.getUserId());

            InstanceIdentifier<User> userid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).build();

            t.put(LogicalDatastoreType.CONFIGURATION, userid, user,true);
            CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
            Futures.addCallback(f, new FutureCallback<Void>() {
                @Override
                public void onFailure(Throwable t) {
                    LOG.error("Could not write endpoint base container", t);
                }

                @Override
                public void onSuccess(Void result) {

                }
            });
            try {
                f.get();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                LOG.error("Exception:",e);
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                LOG.error("Exception:",e);
            }
        }
    }

    /**
     * create a space to store all information in one transaction
     */
    public void transactionHandling(UserId userId){
        writeDataStore(userId);
        deleteDataStore(userId);

        userNodeMap.clear();
        userConnectionMap.clear();
        userFlowMap.clear();
        userOperationMap.clear();
        userTemplateDefinitionMap.clear();
        userTemplateInstanceMap.clear();
        userDeleteIntent.clear();
    }

    /**
     * store and get all user node in one transaction into map
     * @param userId
     */
    public void setNode(UserId userId, NodeId nodeId, Node node){
        if (userNodeMap.containsKey(userId)){
            Map<NodeId, Node> nodeMap = userNodeMap.get(userId);
            nodeMap.put(nodeId, node);
        }
        else {
            Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();
            nodeMap.put(nodeId,node);
            userNodeMap.put(userId,nodeMap);
        }
        setUserNameIdMap(userId, node.getNodeName().getValue(),nodeId.getValue());
    }

    public Map<NodeId, Node> getNode(UserId userId){
        if (!userNodeMap.isEmpty()){
            return userNodeMap.get(userId);
        }
        else {
            return null;
        }
    }

    public void setConnection(UserId userId, ConnectionId connectionId, Connection connection){
        if (userConnectionMap.containsKey(userId)){
            Map<ConnectionId, Connection> connectionMap = userConnectionMap.get(userId);
            connectionMap.put(connectionId,connection);
        }
        else {
            Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();
            connectionMap.put(connectionId,connection);
            userConnectionMap.put(userId,connectionMap);
        }
        setUserNameIdMap(userId, connection.getConnectionName().getValue(),connectionId.getValue());
    }

    public Map<ConnectionId, Connection> getConnection(UserId userId){
        if (!userConnectionMap.isEmpty()){
            return userConnectionMap.get(userId);
        }
        else {
            return null;
        }
    }

    public void setFlow(UserId userId, FlowId flowId, Flow flow){
        if (userFlowMap.containsKey(userId)){
            Map<FlowId,Flow> flowMap = userFlowMap.get(userId);
            flowMap.put(flowId,flow);
        }
        else {
            Map<FlowId,Flow> flowMap = new HashMap<FlowId, Flow>();
            flowMap.put(flowId,flow);
            userFlowMap.put(userId,flowMap);
        }
        setUserNameIdMap(userId,flow.getFlowName().getValue(),flowId.getValue());
    }

    public Map<FlowId,Flow> getFlow(UserId userId){
        if (!userFlowMap.isEmpty()){
            return userFlowMap.get(userId);
        }
        else {
            return null;
        }
    }

    public void setOperation(UserId userId, OperationId operationId, Operation operation){
        if (userOperationMap.containsKey(userId)){
            Map<OperationId, Operation> operationMap = userOperationMap.get(userId);
            operationMap.put(operationId,operation);
        }
        else {
            Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();
            operationMap.put(operationId,operation);
            userOperationMap.put(userId,operationMap);
        }
        setUserNameIdMap(userId,operation.getOperationName().getValue(),operationId.getValue());
    }

    public Map<OperationId, Operation> getOperation(UserId userId){
        if (!userOperationMap.isEmpty()){
            return userOperationMap.get(userId);
        }
        else {
            return null;
        }
    }

    public void setTemplateDefinition(UserId userId,TemplateName templateName, TemplateDefinition definition){
        if (userTemplateDefinitionMap.containsKey(userId)){
            Map<TemplateName, TemplateDefinition> definitionMap = userTemplateDefinitionMap.get(userId);
            definitionMap.put(templateName,definition);
        }
        else {
            Map<TemplateName, TemplateDefinition> definitionMap = new HashMap<TemplateName, TemplateDefinition>();
            definitionMap.put(templateName,definition);
            userTemplateDefinitionMap.put(userId,definitionMap);
        }
    }

    public Map<TemplateName, TemplateDefinition> getTempalteDefinition(UserId userId){
        if (!userTemplateDefinitionMap.isEmpty()){
            return userTemplateDefinitionMap.get(userId);
        }
        else {
            return null;
        }
    }

    public void setUserTemplateInstance(UserId userId, TemplateInstanceId instanceId, TemplateInstance instance){
        if (userTemplateInstanceMap.containsKey(userId)){
            Map<TemplateInstanceId, TemplateInstance> instanceMap = userTemplateInstanceMap.get(userId);
            instanceMap.put(instanceId,instance);
        }
        else {
            Map<TemplateInstanceId, TemplateInstance> instanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();
            instanceMap.put(instanceId,instance);
            userTemplateInstanceMap.put(userId,instanceMap);
        }
    }

    public Map<TemplateInstanceId, TemplateInstance> getTemplateInstance(UserId userId){
        if (!userTemplateInstanceMap.isEmpty()){
            return userTemplateInstanceMap.get(userId);
        }
        else {
            return null;
        }
    }

    /**
     * store all intent need to be deleted in the data store
     * @param userId
     * @param type
     * @param objectId
     */
    public void setUserDeleteIntent(UserId userId, String type, String objectId){
        if (userDeleteIntent.containsKey(userId)){
            Map<String, String> deleteObject = userDeleteIntent.get(userId);
            deleteObject.put(objectId,type);
        }
        else {
            Map<String, String> deleteObject = new HashMap<String, String>();
            deleteObject.put(objectId,type);
            userDeleteIntent.put(userId, deleteObject);
        }
    }

    /**
     * store all name-id map
     * @param userId
     * @param name
     * @param objectId
     */
    public void setUserNameIdMap(UserId userId, String name, String objectId){
        if (userNameIdMap.containsKey(userId)){
            Map<String, String> map = userNameIdMap.get(userId);
            map.put(name,objectId);
        }
        else {
            Map<String, String> nameIdMap = new HashMap<String, String>();
            nameIdMap.put(name, objectId);
            userNameIdMap.put(userId, nameIdMap);
        }
    }

    public Map<String, String> getUserNameIdMap(UserId userId){
        if (!userNameIdMap.isEmpty()){
            return userNameIdMap.get(userId);
        }
        else {
            return null;
        }
    }

    public String getObjectId(UserId userId, String name){
        if (userNameIdMap.containsKey(userId)){
            if (userNameIdMap.get(userId).containsKey(name)){
                return userNameIdMap.get(userId).get(name);
            }
        }
        return null;
    }

    public String getName(UserId userId, String objectId){
        if (userNameIdMap.containsKey(userId)){
            for (String name : userNameIdMap.get(userId).keySet()){
                if (objectId.equals(userNameIdMap.get(userId).get(name))){
                    return name;
                }
            }
        }
        return null;
    }

    /**
     * get all information stored in data store
     */

    public Map<NodeId, Node> getNodeDataStore(UserId userId){
        Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();
        fetchVNSpace(userId);
        User user1 = getUser();
        if (user1.getObjects()!=null){
            if (user1.getObjects().getNode()!=null){
                for (Node node : user1.getObjects().getNode()){
                    nodeMap.put(node.getNodeId(),node);
                }
            }
        }
        return nodeMap.isEmpty()?null:nodeMap;
    }

    public Map<ConnectionId, Connection> getConnectionDataStore(UserId userId){
        Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();
        fetchVNSpace(userId);
        User user1 = getUser();
        if (user1.getObjects()!=null){
            if (user1.getObjects().getConnection()!=null){
                for (Connection connection : user1.getObjects().getConnection()){
                    connectionMap.put(connection.getConnectionId(),connection);
                }
            }
        }
        return connectionMap.isEmpty()?null:connectionMap;
    }

    public Map<FlowId, Flow> getFlowDataStore(UserId userId){
        Map<FlowId, Flow> flowMap = new HashMap<FlowId, Flow>();
        fetchVNSpace(userId);
        User user1 = getUser();
        if (user1.getObjects()!=null){
            if (user1.getObjects().getFlow()!=null){
                for (Flow flow : user1.getObjects().getFlow()){
                    flowMap.put(flow.getFlowId(),flow);
                }
            }
        }
        return flowMap.isEmpty()?null:flowMap;
    }

    public Map<OperationId, Operation> getOperationDataStore(UserId userId){
        Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();
        fetchVNSpace(userId);
        User user1 = getUser();
        if (user1.getOperations()!=null){
            if (user1.getOperations().getOperation()!=null){
                for (Operation operation : user1.getOperations().getOperation()){
                    operationMap.put(operation.getOperationId(),operation);
                }
            }
        }
        return operationMap.isEmpty()?null:operationMap;
    }

    public Map<TemplateName, TemplateDefinition> getDefinitionDataStore(UserId userId){
        Map<TemplateName, TemplateDefinition> definitionMap = new HashMap<TemplateName, TemplateDefinition>();
        fetchVNSpace(userId);
        User user1 = getUser();
        if (user1.getTemplateDefinitions()!=null){
            if (user1.getTemplateDefinitions().getTemplateDefinition()!=null){
                for (TemplateDefinition definition : user1.getTemplateDefinitions().getTemplateDefinition()){
                    definitionMap.put(definition.getTemplateName(),definition);
                }
            }
        }
        return definitionMap.isEmpty()?null:definitionMap;
    }

    public Map<TemplateInstanceId, TemplateInstance> getInstanceDataStore(UserId userId){
        Map<TemplateInstanceId, TemplateInstance> instanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();
        fetchVNSpace(userId);
        User user1 = getUser();
        if (user1.getTemplateInstances()!=null){
            if (user1.getTemplateInstances().getTemplateInstance()!=null){
                for (TemplateInstance instance : user1.getTemplateInstances().getTemplateInstance()){
                    instanceMap.put(instance.getTemplateInstanceId(),instance);
                }
            }
        }
        return instanceMap.isEmpty()?null:instanceMap;
    }

    /**
     * write all information in one transaction into data store
     */
    private void writeDataStore(UserId userId){

        UserKey userKey = new UserKey(userId);
        if (getNode(userId)!=null){
            for (NodeId nodeId : getNode(userId).keySet()){
                NodeKey nodeKey = new NodeKey(nodeId);
                WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                InstanceIdentifier<Node> nodeid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Node.class,nodeKey).build();
                t.put(LogicalDatastoreType.CONFIGURATION, nodeid, getNode(userId).get(nodeId),true);
                CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                Futures.addCallback(f, new FutureCallback<Void>() {
                    @Override
                    public void onFailure(Throwable t) {
                        LOG.error("Could not write node instance", t);
                    }
                    @Override
                    public void onSuccess(Void result) {
                    }
                });
                try {
                    f.get();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    LOG.error("Exception:",e);
                } catch (ExecutionException e) {
                    // TODO Auto-generated catch block
                    LOG.error("Exception:",e);
                }
            }

        }
        if (getConnection(userId)!=null){
           for (ConnectionId connectionId : getConnection(userId).keySet()){
                ConnectionKey connectionKey = new ConnectionKey(connectionId);
               WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                InstanceIdentifier<Connection> connectionid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Connection.class,connectionKey).build();
                t.put(LogicalDatastoreType.CONFIGURATION, connectionid, getConnection(userId).get(connectionId),true);
                CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                Futures.addCallback(f, new FutureCallback<Void>() {
                    @Override
                    public void onFailure(Throwable t) {
                        LOG.error("Could not write connection instance", t);
                    }
                    @Override
                    public void onSuccess(Void result) {
                    }
                });
               try {
                   f.get();
               } catch (InterruptedException e) {
                   // TODO Auto-generated catch block
                   LOG.error("Exception:",e);
               } catch (ExecutionException e) {
                   // TODO Auto-generated catch block
                   LOG.error("Exception:",e);
               }
           }
        }
        if (getFlow(userId)!=null){
           for (FlowId flowId : getFlow(userId).keySet()){
                FlowKey flowKey = new FlowKey(flowId);
               WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                InstanceIdentifier<Flow> flowid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Flow.class,flowKey).build();
                t.put(LogicalDatastoreType.CONFIGURATION, flowid, getFlow(userId).get(flowId),true);
                CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                Futures.addCallback(f, new FutureCallback<Void>() {
                    @Override
                    public void onFailure(Throwable t) {
                        LOG.error("Could not write endpoint base container", t);
                    }
                    @Override
                    public void onSuccess(Void result) {
                    }
                });
               try {
                   f.get();
               } catch (InterruptedException e) {
                   // TODO Auto-generated catch block
                   LOG.error("Exception:",e);
               } catch (ExecutionException e) {
                   // TODO Auto-generated catch block
                   LOG.error("Exception:",e);
               }
           }
        }
        if (getOperation(userId)!=null){
            for (OperationId operationId : getOperation(userId).keySet()){
                OperationKey operationKey = new OperationKey(operationId);
                WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                InstanceIdentifier<Operation> operationid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Operations.class).child(Operation.class,operationKey).build();
                t.put(LogicalDatastoreType.CONFIGURATION, operationid, getOperation(userId).get(operationId),true);
                CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                Futures.addCallback(f, new FutureCallback<Void>() {
                    @Override
                    public void onFailure(Throwable t) {
                        LOG.error("Could not write endpoint base container", t);
                    }

                    @Override
                    public void onSuccess(Void result) {

                    }
                });
                try {
                    f.get();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    LOG.error("Exception:",e);
                } catch (ExecutionException e) {
                    // TODO Auto-generated catch block
                    LOG.error("Exception:",e);
                }
            }
        }
        if (getTempalteDefinition(userId)!=null){
            for (TemplateName templateName : getTempalteDefinition(userId).keySet()){
                TemplateDefinitionKey key = new TemplateDefinitionKey(templateName);
                WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                InstanceIdentifier<TemplateDefinition> templateDefinitionId = InstanceIdentifier.builder(Users.class).child(User.class, userKey)
                        .child(TemplateDefinitions.class).child(TemplateDefinition.class, key)
                        .build();
                t.put(LogicalDatastoreType.CONFIGURATION, templateDefinitionId, getTempalteDefinition(userId).get(templateName),true);
                CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                Futures.addCallback(f, new FutureCallback<Void>() {
                    @Override
                    public void onFailure(Throwable t) {
                        LOG.error("Could not write endpoint base container", t);
                    }
                    @Override
                    public void onSuccess(Void result) {
                    }
                });
                try {
                    f.get();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    LOG.error("Exception:",e);
                } catch (ExecutionException e) {
                    // TODO Auto-generated catch block
                    LOG.error("Exception:",e);
                }
            }
        }
        if (getTemplateInstance(userId)!=null){
          for (TemplateInstanceId instanceId : getTemplateInstance(userId).keySet()){
                TemplateInstanceKey key = new TemplateInstanceKey(instanceId);
                WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                InstanceIdentifier<TemplateInstance> templateDefinitionId = InstanceIdentifier.builder(Users.class).child(User.class, userKey)
                        .child(TemplateInstances.class).child(TemplateInstance.class, key)
                        .build();
                t.put(LogicalDatastoreType.CONFIGURATION, templateDefinitionId, getTemplateInstance(userId).get(instanceId),true);
                CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                Futures.addCallback(f, new FutureCallback<Void>() {
                    @Override
                    public void onFailure(Throwable t) {
                        LOG.error("Could not write endpoint base container", t);
                    }
                    @Override
                    public void onSuccess(Void result) {
                    }
                });
              try {
                  f.get();
              } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  LOG.error("Exception:",e);
              } catch (ExecutionException e) {
                  // TODO Auto-generated catch block
                  LOG.error("Exception:",e);
              }
          }
        }
    }

    /**
     * delete intent in data store
     * @param userId
     */
    private void deleteDataStore(UserId userId){
        if (userDeleteIntent.get(userId)!=null){
            Map<String, String> deleteObject = userDeleteIntent.get(userId);

            for (String objectId : deleteObject.keySet()){
                if (deleteObject.get(objectId).equals(NEMOConstants.node)){
                    UserKey userKey = new UserKey(userId);
                    NodeKey nodeKey = new NodeKey(new NodeId(objectId));
                    WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                    InstanceIdentifier<Node> nodeid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Node.class,nodeKey).build();
                    t.delete(LogicalDatastoreType.CONFIGURATION, nodeid);
                    CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                    Futures.addCallback(f, new FutureCallback<Void>() {
                        @Override
                        public void onFailure(Throwable t) {
                            LOG.error("Could not delete node instance", t);
                        }
                        @Override
                        public void onSuccess(Void result) {
                        }
                    });
                }
                if (deleteObject.get(objectId).equals(NEMOConstants.connection)){
                    UserKey userKey = new UserKey(userId);
                    ConnectionKey connectionKey = new ConnectionKey(new ConnectionId(objectId));
                    WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                    InstanceIdentifier<Connection> connectionid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Connection.class,connectionKey).build();
                    t.delete(LogicalDatastoreType.CONFIGURATION, connectionid);
                    CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                    Futures.addCallback(f, new FutureCallback<Void>() {
                        @Override
                        public void onFailure(Throwable t) {
                            LOG.error("Could not delete connection instance", t);
                        }
                        @Override
                        public void onSuccess(Void result) {
                        }
                    });
                }
                if (deleteObject.get(objectId).equals(NEMOConstants.flow)){
                    UserKey userKey = new UserKey(userId);
                    FlowKey flowKey = new FlowKey(new FlowId(objectId));
                    WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                    InstanceIdentifier<Flow> flowid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Flow.class,flowKey).build();
                    t.delete(LogicalDatastoreType.CONFIGURATION, flowid);
                    CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                    Futures.addCallback(f, new FutureCallback<Void>() {
                        @Override
                        public void onFailure(Throwable t) {
                            LOG.error("Could not delete flow instance", t);
                        }
                        @Override
                        public void onSuccess(Void result) {
                        }
                    });
                }
                if (deleteObject.get(objectId).equals(NEMOConstants.operation)){
                    UserKey userKey = new UserKey(userId);
                    OperationKey operationKey = new OperationKey(new OperationId(objectId));
                    WriteTransaction t = dataBroker.newWriteOnlyTransaction();
                    InstanceIdentifier<Operation> operationid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Operations.class).child(Operation.class,operationKey).build();
                    t.delete(LogicalDatastoreType.CONFIGURATION, operationid);
                    CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
                    Futures.addCallback(f, new FutureCallback<Void>() {
                        @Override
                        public void onFailure(Throwable t) {
                            LOG.error("Could not delete operation instance", t);
                        }
                        @Override
                        public void onSuccess(Void result) {
                        }
                    });
                }
            }
        }
    }
}