/*
 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.idmanager;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.concurrent.Future;

import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.DeleteIdPoolInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.AvailableIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.AvailableIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ReleasedIdsHolder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ReleasedIdsHolderBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.released.ids.DelayedIdEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.released.ids.DelayedIdEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockManagerService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;

public class IdManager implements IdManagerService, AutoCloseable{
    private static final Logger LOG = LoggerFactory.getLogger(IdManager.class);

    private static final long DEFAULT_IDLE_TIME = 24 * 60 * 60;

    private ListenerRegistration<DataChangeListener> listenerRegistration;
    private final DataBroker broker;
    private LockManagerService lockManager;

    @Override
    public void close() throws Exception {
        if (listenerRegistration != null) {
            try {
                listenerRegistration.close();
            } catch (final Exception e) {
                LOG.error("Error when cleaning up DataChangeListener.", e);
            }
            listenerRegistration = null;
        }
        LOG.info("IDManager Closed");
    }

    public IdManager(final DataBroker db) {
        broker = db;
    }

    public void setLockManager(LockManagerService lockManager) {
        this.lockManager = lockManager;
    }

    @Override
    public Future<RpcResult<Void>> createIdPool(CreateIdPoolInput input) {
        LOG.debug("createIdPool called with input {}", input);
        String poolName = input.getPoolName();
        long low = input.getLow();
        long high = input.getHigh();
        long blockSize = IdUtils.computeBlockSize(low, high);
        RpcResultBuilder<Void> createIdPoolRpcBuilder;
        IdUtils.lockPool(lockManager, poolName);
        try {
            InstanceIdentifier<IdPool> idPoolInstanceIdentifier = IdUtils.getIdPoolInstance(poolName);
            poolName = poolName.intern();
            IdPool idPool;
            idPool = createGlobalPool(poolName, low, high, blockSize, idPoolInstanceIdentifier);
            String localPoolName = IdUtils.getLocalPoolName(poolName);
            if (createLocalPool(localPoolName, idPool)) {
                LOG.debug("Updating global id pool {} with childPool {}", poolName, localPoolName);
                updateChildPool(poolName, localPoolName);
            }
            createIdPoolRpcBuilder = RpcResultBuilder.success();
        } catch (Exception ex) {
            LOG.error("Creation of Id Pool {} failed due to {}", poolName, ex);
            createIdPoolRpcBuilder = RpcResultBuilder.failed();
            createIdPoolRpcBuilder.withError(ErrorType.APPLICATION, ex.getMessage());
        } finally {
            IdUtils.unlockPool(lockManager, poolName);
        }
        return Futures.immediateFuture(createIdPoolRpcBuilder.build());
    }

    @Override
    public Future<RpcResult<AllocateIdOutput>> allocateId(AllocateIdInput input) {
        LOG.debug("AllocateId called with input {}", input);
        String idKey = input.getIdKey();
        String poolName = input.getPoolName();
        String localPoolName = IdUtils.getLocalPoolName(poolName);
        RpcResultBuilder<AllocateIdOutput> allocateIdRpcBuilder;
        long newIdValue = -1;
        AllocateIdOutputBuilder output = new AllocateIdOutputBuilder();
        try {
            newIdValue = allocateIdFromLocalPool(poolName, localPoolName, idKey);
            output.setIdValue(newIdValue);
            allocateIdRpcBuilder = RpcResultBuilder.success();
            allocateIdRpcBuilder.withResult(output.build());
        } catch (Exception ex) {
            LOG.error("Allocate id in pool {} failed due to {}", poolName, ex);
            allocateIdRpcBuilder = RpcResultBuilder.failed();
            allocateIdRpcBuilder.withError(ErrorType.APPLICATION, ex.getMessage());
        }
        return Futures.immediateFuture(allocateIdRpcBuilder.build());
    }

    @Override
    public Future<RpcResult<Void>> deleteIdPool(DeleteIdPoolInput input) {
        LOG.debug("DeleteIdPool called with input {}", input);
        String poolName = input.getPoolName();
        RpcResultBuilder<Void> deleteIdPoolRpcBuilder;
        try {
            InstanceIdentifier<IdPool> idPoolToBeDeleted = IdUtils.getIdPoolInstance(poolName);
            poolName = poolName.intern();
            synchronized(poolName) {
                IdPool idPool = getIdPool(idPoolToBeDeleted);
                List<ChildPools> childPoolList = idPool.getChildPools();
                if (childPoolList != null) {
                    for (ChildPools childPoolName : childPoolList) {
                        deletePool(childPoolName.getChildPoolName());
                    }
                }
                MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, idPoolToBeDeleted);
                LOG.debug("Deleted id pool {}", poolName);
            }
            deleteIdPoolRpcBuilder = RpcResultBuilder.success();
        }
        catch (Exception ex) {
            LOG.error("Delete id in pool {} failed due to {}", poolName, ex);
            deleteIdPoolRpcBuilder = RpcResultBuilder.failed();
            deleteIdPoolRpcBuilder.withError(ErrorType.APPLICATION, ex.getMessage());
        }
        return Futures.immediateFuture(deleteIdPoolRpcBuilder.build());
    }

    @Override
    public Future<RpcResult<Void>> releaseId(ReleaseIdInput input) {
        String poolName = input.getPoolName();
        String idKey = input.getIdKey();
        RpcResultBuilder<Void> releaseIdRpcBuilder;
        try {
            releaseIdFromLocalPool(IdUtils.getLocalPoolName(poolName), idKey);
            releaseIdRpcBuilder = RpcResultBuilder.success();
        } catch (Exception ex) {
            LOG.error("Release id {} from pool {} failed due to {}", idKey, poolName, ex);
            releaseIdRpcBuilder = RpcResultBuilder.failed();
            releaseIdRpcBuilder.withError(ErrorType.APPLICATION, ex.getMessage());
        }
        return Futures.immediateFuture(releaseIdRpcBuilder.build());
    }

    private long allocateIdFromLocalPool(String parentPoolName, String localPoolName, String idKey) {
        LOG.trace("Allocating id from local pool {}. Parent pool {}. Idkey {}", localPoolName, parentPoolName, idKey);
        long newIdValue = -1;
        InstanceIdentifier<IdPool> localIdPoolInstanceIdentifier = IdUtils.getIdPoolInstance(localPoolName);
        localPoolName = localPoolName.intern();
        synchronized (localPoolName) {
            InstanceIdentifier<IdPool> parentIdPoolInstanceIdentifier = IdUtils.getIdPoolInstance(parentPoolName);
            IdPool parentIdPool = getIdPool(parentIdPoolInstanceIdentifier);
            IdPool localPool = null;
            try {
                localPool = getIdPool(localIdPoolInstanceIdentifier);
            } catch (NoSuchElementException e){
                LOG.trace("Creating local pool {} since it was not present", localPoolName);
                localPool = IdUtils.createLocalIdPool(localPoolName, parentIdPool);
                MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, localIdPoolInstanceIdentifier, localPool);
                IdUtils.lockPool(lockManager, parentPoolName);
                try {
                    updateChildPool(parentPoolName, localPoolName);
                } finally {
                    IdUtils.unlockPool(lockManager, parentPoolName);
                }
                LOG.debug("Updating global id pool {} with childPool {}", parentPoolName, localPoolName);
            }
            IdEntries newIdEntry;
            List<IdEntries> idEntries = parentIdPool.getIdEntries();
            AvailableIdsHolderBuilder availableIds = IdUtils.getAvailableIdsHolderBuilder(localPool);
            ReleasedIdsHolderBuilder releasedIds = IdUtils.getReleaseIdsHolderBuilder(localPool);
            //Calling cleanupExcessIds since there could be excessive ids.
            cleanupExcessIds(availableIds, releasedIds, parentPoolName, localPool.getBlockSize());
            if (idEntries == null) {
                idEntries = new LinkedList<IdEntries>();
            } else {
                InstanceIdentifier<IdEntries> existingId = IdUtils.getIdEntry(parentIdPoolInstanceIdentifier, idKey);
                Optional<IdEntries> existingIdEntry = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, existingId);
                if (existingIdEntry.isPresent()) {
                    newIdValue = existingIdEntry.get().getIdValue();
                    LOG.debug("Existing id {} for the key {} ", idKey, newIdValue);
                    InstanceIdentifier<ReleasedIdsHolder> releasedIdsHolderInstanceIdentifier = InstanceIdentifier
                            .builder(IdPools.class).child(IdPool.class, new IdPoolKey(localPoolName)).child(ReleasedIdsHolder.class).build();
                    MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, releasedIdsHolderInstanceIdentifier, releasedIds.build());
                    return newIdValue;
                }
            }
            newIdValue = getIdFromPool(localPool, availableIds, releasedIds);
            LOG.debug("The newIdValue {} for the idKey {}", newIdValue, idKey);
            newIdEntry = IdUtils.createIdEntries(idKey, newIdValue);
            idEntries.add(newIdEntry);
            LOG.debug("The availablelIds are {}", availableIds.build());
            localPool = new IdPoolBuilder(localPool).setAvailableIdsHolder(availableIds.build())
                    .setReleasedIdsHolder(releasedIds.build()).build();
            MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, localIdPoolInstanceIdentifier, localPool);
            updateChildPool(localPool.getParentPoolName(), localPoolName);
            //Updating id entries in the parent pool. This will be used for restart scenario
            IdUtils.lockPool(lockManager, parentPoolName);
            try {
                parentIdPool = getIdPool(parentIdPoolInstanceIdentifier);
                IdPool parentPool = new IdPoolBuilder(parentIdPool).setIdEntries(idEntries).build();
                MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, parentIdPoolInstanceIdentifier, parentPool);
            } catch (Exception ex) {
                LOG.error("Saving of Id entries to parent pool {} failed due to {}", parentPoolName, ex);
            } finally {
                IdUtils.unlockPool(lockManager, parentPoolName);
            }
        }
        return newIdValue;
    }

    private long getIdFromPool(IdPool pool, AvailableIdsHolderBuilder availableIds, ReleasedIdsHolderBuilder releasedIds) {
        long newIdValue = -1;
        while (true) {
            newIdValue = IdUtils.getIdFromReleaseIdsIfAvailable(releasedIds);
            if (newIdValue != -1) {
                LOG.debug("Retrieved id value {} from released id holder", newIdValue);
                return newIdValue;
            }
            newIdValue = IdUtils.getIdFromAvailableIds(availableIds);
            if (newIdValue != -1) {
                LOG.debug("Creating a new id {} for the pool: {} ", newIdValue, pool.getPoolName());
                return newIdValue;
            }
            long idCount = allocateIdBlockFromParentPool(pool.getParentPoolName(), availableIds, releasedIds);
            if (idCount <= 0) {
                LOG.debug("Unable to allocate Id block from global pool");
                throw new RuntimeException(String.format("Ids exhausted for pool : %s", pool.getPoolName()));
            }
        }
    }

    /**
     * Changes made to releaseIds and AvailableIds are not persisted.
     * @param availableIds
     * @param releasedIds
     * @param parentPoolName
     * @param blockSize
     */
    private void cleanupExcessIds(AvailableIdsHolderBuilder availableIds, ReleasedIdsHolderBuilder releasedIds, String parentPoolName, int blockSize) {
        IdUtils.processDelayList(releasedIds);
        long totalAvailableIdCount = releasedIds.getAvailableIdCount() + IdUtils.getAvailableIdsCount(availableIds);
        if (totalAvailableIdCount > blockSize * 2) {
            parentPoolName = parentPoolName.intern();
            InstanceIdentifier<ReleasedIdsHolder> releasedIdInstanceIdentifier = IdUtils.getReleasedIdsHolderInstance(parentPoolName);
            IdUtils.lockPool(lockManager, parentPoolName);
            try {
                Optional<ReleasedIdsHolder> releasedIdsHolder = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, releasedIdInstanceIdentifier);
                ReleasedIdsHolderBuilder releasedIdsParent;
                if (!releasedIdsHolder.isPresent()) {
                    LOG.error("ReleasedIds not present in parent pool. Unable to cleanup excess ids");
                    return;
                }
                releasedIdsParent = new ReleasedIdsHolderBuilder(releasedIdsHolder.get());
                LOG.debug("Releasing excesss Ids from local pool");
                IdUtils.freeExcessAvailableIds(releasedIds, releasedIdsParent, blockSize);
                MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, releasedIdInstanceIdentifier, releasedIdsParent.build());
            } finally {
                IdUtils.unlockPool(lockManager, parentPoolName);
            }
        }
    }

    /**
     * Changes made to availableIds and releasedIds will not be persisted to the datastore
     * @param parentPoolName
     * @param availableIdsBuilder
     * @param releasedIdsBuilder
     * @return
     */
    private long allocateIdBlockFromParentPool(String parentPoolName,
            AvailableIdsHolderBuilder availableIdsBuilder, ReleasedIdsHolderBuilder releasedIdsBuilder) {
        LOG.debug("Allocating block of id from parent pool {}", parentPoolName);
        InstanceIdentifier<IdPool> idPoolInstanceIdentifier = IdUtils.getIdPoolInstance(parentPoolName);
        parentPoolName = parentPoolName.intern();
        long idCount = -1;
        IdUtils.lockPool(lockManager, parentPoolName);
        try {
            IdPool parentIdPool = getIdPool(idPoolInstanceIdentifier);
            ReleasedIdsHolderBuilder releasedIdsBuilderParent = IdUtils.getReleaseIdsHolderBuilder(parentIdPool);
            while (true) {
                idCount = allocateIdBlockFromReleasedIdsHolder(releasedIdsBuilder, releasedIdsBuilderParent, parentIdPool);
                if (idCount > 0) {
                    return idCount;
                }
                idCount = allocateIdBlockFromAvailableIdsHolder(availableIdsBuilder, parentIdPool);
                if (idCount > 0) {
                    return idCount;
                }
                idCount = getIdsFromOtherChildPools(releasedIdsBuilderParent, parentIdPool);
                if (idCount <= 0) {
                    LOG.debug("Unable to allocate Id block from global pool");
                    throw new RuntimeException(String.format("Ids exhausted for pool : %s", parentPoolName));
                }
            }
        }
        finally {
            IdUtils.unlockPool(lockManager, parentPoolName);
        }
    }

    private long getIdsFromOtherChildPools(ReleasedIdsHolderBuilder releasedIdsBuilderParent, IdPool parentIdPool) {
        List<ChildPools> childPoolsList = parentIdPool.getChildPools();
        // Sorting the child pools on last accessed time so that the pool that was not accessed for a long time comes first.
        Collections.sort(childPoolsList, new Comparator<ChildPools>() {
            @Override
            public int compare(ChildPools childPool1, ChildPools childPool2) {
                return childPool1.getLastAccessTime().compareTo(childPool2.getLastAccessTime());
            }
        });
        long currentTime = System.currentTimeMillis() / 1000;
        for (ChildPools childPools : childPoolsList) {
            if (childPools.getLastAccessTime() + DEFAULT_IDLE_TIME < currentTime) {
                break;
            }
            if (!childPools.getChildPoolName().equals(IdUtils.getLocalPoolName(parentIdPool.getPoolName()))) {
                InstanceIdentifier<IdPool> idPoolInstanceIdentifier = IdUtils.getIdPoolInstance(childPools.getChildPoolName());
                IdPool otherChildPool = getIdPool(idPoolInstanceIdentifier);
                ReleasedIdsHolderBuilder releasedIds = IdUtils.getReleaseIdsHolderBuilder(otherChildPool);
                AvailableIdsHolderBuilder availableIds = IdUtils.getAvailableIdsHolderBuilder(otherChildPool);
                long totalAvailableIdCount = releasedIds.getDelayedIdEntries().size() + IdUtils.getAvailableIdsCount(availableIds);
                List<DelayedIdEntries> delayedIdEntriesChild = releasedIds.getDelayedIdEntries();
                List<DelayedIdEntries> delayedIdEntriesParent = releasedIdsBuilderParent.getDelayedIdEntries();
                if (delayedIdEntriesParent == null) {
                    delayedIdEntriesParent = new LinkedList<>();
                }
                delayedIdEntriesParent.addAll(delayedIdEntriesChild);
                delayedIdEntriesChild.removeAll(delayedIdEntriesChild);
                while (IdUtils.isIdAvailable(availableIds)) {
                    long cursor = availableIds.getCursor() + 1;
                    delayedIdEntriesParent.add(new DelayedIdEntriesBuilder().setId(cursor).setReadyTimeSec(System.currentTimeMillis()).build());
                    availableIds.setCursor(cursor);
                }
                long count = releasedIdsBuilderParent.getAvailableIdCount() + totalAvailableIdCount;
                releasedIdsBuilderParent.setDelayedIdEntries(delayedIdEntriesParent).setAvailableIdCount(count);
                MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, idPoolInstanceIdentifier,
                        new IdPoolBuilder(otherChildPool).setAvailableIdsHolder(availableIds.build()).setReleasedIdsHolder(releasedIds.build()).build());
                return totalAvailableIdCount;
            }
        }
        return 0;
    }

    private long allocateIdBlockFromReleasedIdsHolder(ReleasedIdsHolderBuilder releasedIdsBuilderChild, ReleasedIdsHolderBuilder releasedIdsBuilderParent, IdPool parentIdPool) {
        if (releasedIdsBuilderParent.getAvailableIdCount() == 0) {
            LOG.debug("Ids unavailable in releasedIds of parent pool {}", parentIdPool);
            return 0;
        }
        List<DelayedIdEntries> delayedIdEntriesParent = releasedIdsBuilderParent.getDelayedIdEntries();
        List<DelayedIdEntries> delayedIdEntriesChild = releasedIdsBuilderChild.getDelayedIdEntries();
        if (delayedIdEntriesChild == null) {
            delayedIdEntriesChild = new LinkedList<DelayedIdEntries>();
        }
        int idCount = Math.min(delayedIdEntriesParent.size(), parentIdPool.getBlockSize());
        List<DelayedIdEntries> idEntriesToBeRemoved = delayedIdEntriesParent.subList(0, idCount);
        delayedIdEntriesChild.addAll(0, idEntriesToBeRemoved);
        delayedIdEntriesParent.removeAll(idEntriesToBeRemoved);
        releasedIdsBuilderParent.setDelayedIdEntries(delayedIdEntriesParent);
        releasedIdsBuilderChild.setDelayedIdEntries(delayedIdEntriesChild);
        releasedIdsBuilderChild.setAvailableIdCount(releasedIdsBuilderChild.getAvailableIdCount() + idCount);
        InstanceIdentifier<ReleasedIdsHolder> releasedIdsHolderInstanceIdentifier = InstanceIdentifier
                .builder(IdPools.class).child(IdPool.class,
                        new IdPoolKey(parentIdPool.getPoolName())).child(ReleasedIdsHolder.class).build();
        releasedIdsBuilderParent.setAvailableIdCount(releasedIdsBuilderParent.getAvailableIdCount() - idCount);
        LOG.debug("Allocated {} ids from releasedIds of parent pool {}", idCount, parentIdPool);
        MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, releasedIdsHolderInstanceIdentifier, releasedIdsBuilderParent.build());
        return idCount;
    }

    private long allocateIdBlockFromAvailableIdsHolder(AvailableIdsHolderBuilder availableIdsBuilder, IdPool parentIdPool) {
        long idCount = 0;
        AvailableIdsHolderBuilder availableIdsBuilderParent = IdUtils.getAvailableIdsHolderBuilder(parentIdPool);
        long end = availableIdsBuilderParent.getEnd();
        long cur = availableIdsBuilderParent.getCursor();
        if (!IdUtils.isIdAvailable(availableIdsBuilderParent)) {
            LOG.debug("Ids exhausted in parent pool {}", parentIdPool);
            return idCount;
        }
        // Update availableIdsHolder of Local Pool
        availableIdsBuilder.setStart(cur + 1);
        idCount = Math.min(end - cur, parentIdPool.getBlockSize());
        availableIdsBuilder.setEnd(cur + idCount);
        availableIdsBuilder.setCursor(cur);
        // Update availableIdsHolder of Global Pool
        InstanceIdentifier<AvailableIdsHolder> availableIdsHolderInstanceIdentifier = InstanceIdentifier
                .builder(IdPools.class).child(IdPool.class,
                        new IdPoolKey(parentIdPool.getPoolName())).child(AvailableIdsHolder.class).build();
        availableIdsBuilderParent.setCursor(cur + idCount);
        LOG.debug("Allocated {} ids from availableIds of global pool {}", idCount, parentIdPool);
        MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, availableIdsHolderInstanceIdentifier, availableIdsBuilderParent.build());
        return idCount;
    }

    private void releaseIdFromLocalPool(String poolName, String idKey) {
        InstanceIdentifier<IdPool> localIdPoolInstanceIdentifier = IdUtils.getIdPoolInstance(poolName);
        poolName = poolName.intern();
        synchronized (poolName) {
            IdPool localPool = getIdPool(localIdPoolInstanceIdentifier);
            String parentPoolName = localPool.getParentPoolName();
            InstanceIdentifier<IdPool> parentIdPoolInstanceIdentifier = IdUtils.getIdPoolInstance(parentPoolName);
            IdPool parentIdPool = getIdPool(parentIdPoolInstanceIdentifier);
            List<IdEntries> idEntries = parentIdPool.getIdEntries();
            List<IdEntries> newIdEntries = idEntries;
            if (idEntries == null) {
                throw new RuntimeException("Id Entries does not exist");
            }
            InstanceIdentifier<IdEntries> existingId = IdUtils.getIdEntry(parentIdPoolInstanceIdentifier, idKey);
            Optional<IdEntries> existingIdEntryObject = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, existingId);
            if (!existingIdEntryObject.isPresent()) {
                throw new RuntimeException(String.format("Specified Id key %s does not exist in id pool %s", idKey, poolName));
            }
            IdEntries existingIdEntry = existingIdEntryObject.get();
            long idValue = existingIdEntry.getIdValue();
            boolean isRemoved = newIdEntries.remove(existingIdEntry);
            LOG.debug("The entry {} is removed {}", existingIdEntry, isRemoved);
            ReleasedIdsHolderBuilder releasedIds = IdUtils.getReleaseIdsHolderBuilder(localPool);
            AvailableIdsHolderBuilder availableIds = IdUtils.getAvailableIdsHolderBuilder(localPool);
            long delayTime = System.currentTimeMillis() / 1000 + releasedIds.getDelayedTimeSec();
            DelayedIdEntries delayedIdEntry = IdUtils.createDelayedIdEntry(idValue, delayTime);
            List<DelayedIdEntries> delayedIdEntries = releasedIds.getDelayedIdEntries();
            if (delayedIdEntries == null) {
                delayedIdEntries = new LinkedList<DelayedIdEntries>();
            }
            delayedIdEntries.add(delayedIdEntry);
            long availableIdCount = releasedIds
                    .getAvailableIdCount() == null ? 0
                            : releasedIds.getAvailableIdCount();
            releasedIds.setDelayedIdEntries(delayedIdEntries);
            releasedIds.setAvailableIdCount(availableIdCount);
            //Calling cleanupExcessIds since there could be excessive ids.
            cleanupExcessIds(availableIds, releasedIds, parentPoolName, localPool.getBlockSize());
            localPool = new IdPoolBuilder(localPool)
                    .setAvailableIdsHolder(availableIds.build())
                    .setReleasedIdsHolder(releasedIds.build()).build();
            MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, localIdPoolInstanceIdentifier, localPool);
            LOG.debug("Released id ({}, {}) from pool {}", idKey, idValue, poolName);
            //Updating id entries in the parent pool. This will be used for restart scenario
            IdUtils.lockPool(lockManager, parentPoolName);
            try {
                parentIdPool = getIdPool(parentIdPoolInstanceIdentifier);
                IdPool parentPool = new IdPoolBuilder(parentIdPool).setIdEntries(newIdEntries).build();
                MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, parentIdPoolInstanceIdentifier, parentPool);
            } catch (Exception ex) {
                LOG.error("Saving of Id entries to parent pool {} failed due to {}", parentPoolName, ex);
            } finally {
                IdUtils.unlockPool(lockManager, parentPoolName);
            }
        }
    }

    private IdPool createGlobalPool(String poolName, long low, long high,
            long blockSize, InstanceIdentifier<IdPool> idPoolInstanceIdentifier) {
        IdPool idPool;
        Optional<IdPool> existingIdPool = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, idPoolInstanceIdentifier);
        if (!existingIdPool.isPresent()) {
            LOG.debug("Creating new global pool {}", poolName);
            idPool = IdUtils.createGlobalPool(poolName, low, high, blockSize);
            MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, idPoolInstanceIdentifier, idPool);
        }
        else {
            idPool = existingIdPool.get();
            LOG.debug("GlobalPool exists {}", idPool);
        }
        return idPool;
    }

    private boolean createLocalPool(String localPoolName, IdPool idPool) {
        localPoolName = localPoolName.intern();
        synchronized (localPoolName) {
            InstanceIdentifier<IdPool> localIdPoolInstanceIdentifier = IdUtils.getIdPoolInstance(localPoolName);
            Optional<IdPool> localIdPool = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, localIdPoolInstanceIdentifier);
            if (!localIdPool.isPresent()) {
                LOG.debug("Creating new local pool");
                IdPool newLocalIdPool = IdUtils.createLocalIdPool(localPoolName, idPool);
                MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, localIdPoolInstanceIdentifier, newLocalIdPool);
                LOG.debug("Local pool created {}", newLocalIdPool);
                return true;
            }
        }
        return false;
    }

    private void deletePool(String poolName) {
        InstanceIdentifier<IdPool> idPoolToBeDeleted = IdUtils.getIdPoolInstance(poolName);
        synchronized (poolName) {
            Optional<IdPool> idPool = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, idPoolToBeDeleted);
            if (idPool.isPresent()) {
                MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, idPoolToBeDeleted);
                LOG.debug("Deleted local pool {}", poolName);
            }
        }
    }

    private IdPool getIdPool(InstanceIdentifier<IdPool> idPoolInstanceIdentifier) {
        Optional<IdPool> idPool = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, idPoolInstanceIdentifier);
        if (!idPool.isPresent()) {
            throw new NoSuchElementException(String.format("Specified pool %s does not exist" , idPool));
        }
        LOG.trace("GetIdPool : Read id pool {} ", idPool);
        return idPool.get();
    }

    private void updateChildPool(String poolName, String localPoolName) {
        ChildPools childPool = IdUtils.createChildPool(localPoolName);
        InstanceIdentifier<ChildPools> childPoolInstanceIdentifier = IdUtils.getChildPoolsInstanceIdentifier(poolName, localPoolName);
        MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, childPoolInstanceIdentifier, childPool);
    }
}