/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.engine.marketdata.resolver;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.opengamma.engine.marketdata.MarketDataProvider;
import com.opengamma.engine.marketdata.spec.MarketDataSpecification;
import com.opengamma.livedata.UserPrincipal;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.map.HashMap2;
import com.opengamma.util.map.Map2;
import com.opengamma.util.map.WeakValueHashMap2;

/**
 * Caching wrapper around {@link MarketDataProviderResolver} - this can be used when resolvers will create new instances each time when the call with the same user and specification could share the
 * same instance.
 */
public class CachingMarketDataProviderResolver implements MarketDataProviderResolver {

  private static final Logger s_logger = LoggerFactory.getLogger(CachingMarketDataProviderResolver.class);

  private final MarketDataProviderResolver _underlying;
  private final Map2<UserPrincipal, MarketDataSpecification, MarketDataProvider> _cache = new WeakValueHashMap2<UserPrincipal, MarketDataSpecification, MarketDataProvider>(HashMap2.STRONG_KEYS);

  public CachingMarketDataProviderResolver(final MarketDataProviderResolver underlying) {
    ArgumentChecker.notNull(underlying, "underlying");
    _underlying = underlying;
  }

  protected MarketDataProviderResolver getUnderlying() {
    return _underlying;
  }

  protected Map2<UserPrincipal, MarketDataSpecification, MarketDataProvider> getCache() {
    return _cache;
  }

  protected MarketDataProvider resolveCached(final UserPrincipal marketDataUser, final MarketDataSpecification snapshotSpec) {
    s_logger.debug("Looking up {} for {}", snapshotSpec, marketDataUser);
    return getCache().get(marketDataUser, snapshotSpec);
  }

  protected MarketDataProvider resolveUnderlying(final UserPrincipal marketDataUser, final MarketDataSpecification snapshotSpec) {
    s_logger.debug("Resolving {} for {}", snapshotSpec, marketDataUser);
    return getUnderlying().resolve(marketDataUser, snapshotSpec);
  }

  protected MarketDataProvider updateCache(final UserPrincipal marketDataUser, final MarketDataSpecification snapshotSpec, final MarketDataProvider provider) {
    final MarketDataProvider existing = getCache().putIfAbsent(marketDataUser, snapshotSpec, provider);
    if (existing == null) {
      s_logger.debug("Stored cache entry of {} for {}", snapshotSpec, marketDataUser);
      return provider;
    } else {
      s_logger.debug("Using existing cached entry of {} for {}", snapshotSpec, marketDataUser);
      return existing;
    }
  }

  // MarketDataProviderResolver

  @Override
  public MarketDataProvider resolve(final UserPrincipal marketDataUser, final MarketDataSpecification snapshotSpec) {
    MarketDataProvider provider = resolveCached(marketDataUser, snapshotSpec);
    if (provider != null) {
      s_logger.info("Already resolved {} for {}", snapshotSpec, marketDataUser);
      return provider;
    }
    provider = resolveUnderlying(marketDataUser, snapshotSpec);
    s_logger.info("Resolved {} for {}", snapshotSpec, marketDataUser);
    return updateCache(marketDataUser, snapshotSpec, provider);
  }

}