package io.netty.channel.pool;

/**
 * Allows to map {@link ChannelPool} implementations to a specific key.
 *
 * @param <K> the type of the key
 * @param <P> the type of the {@link ChannelPool}
 */
public interface ChannelPoolMap<K, P extends ChannelPool> {
    /**
     * Return the {@link ChannelPool} for the {@code code}. This will never return {@code null},
     * but create a new {@link ChannelPool} if non exists for they requested {@code key}.
     *
     * Please note that {@code null} keys are not allowed.
     */
    P get(K key);

    /**
     * Returns {@code true} if a {@link ChannelPool} exists for the given {@code key}.
     *
     * Please note that {@code null} keys are not allowed.
     */
    boolean contains(K key);
}

    private final ConcurrentMap<K, P> map = PlatformDependent.newConcurrentHashMap();

    @Override
    public final P get(K key) {
      //獲取ChannelPool
        P pool = map.get(checkNotNull(key, "key"));
        if (pool == null) {
          //創(chuàng)建一個(gè)新的ChannelPool
            pool = newPool(key);
          //如果集合中存在ChannelPool,則返回老的ChannelPool對(duì)象
            P old = map.putIfAbsent(key, pool);
           //若果老的ChannelPool真實(shí)存在
            if (old != null) {
               //異步銷毀新創(chuàng)建的ChannelPool
                // We need to destroy the newly created pool as we not use it.
                poolCloseAsyncIfSupported(pool);
                pool = old;
            }
        }
        return pool;
    }

    /**
     * Called once a new {@link ChannelPool} needs to be created as non exists yet for the {@code key}.
     */
    protected abstract P newPool(K key);

    /**
     * If the pool implementation supports asynchronous close, then use it to avoid a blocking close call in case
     * the ChannelPoolMap operations are called from an EventLoop.
     *
     * @param pool the ChannelPool to be closed
     */
    private static Future<Void> poolCloseAsyncIfSupported(ChannelPool pool) {
        if (pool instanceof SimpleChannelPool) {
            return ((SimpleChannelPool) pool).closeAsync();
        } else {
            try {
                pool.close();
                return GlobalEventExecutor.INSTANCE.newSucceededFuture(null);
            } catch (Exception e) {
                return GlobalEventExecutor.INSTANCE.newFailedFuture(e);
            }
        }
    }

    public final boolean remove(K key) {
      //移除指定key的ChannelPool
        P pool =  map.remove(checkNotNull(key, "key"));
        if (pool != null) {
          //如果移除成功，則異步的關(guān)閉ChannelPool，避免阻塞方法
            poolCloseAsyncIfSupported(pool);
            return true;
        }
        return false;
    }