package com.trendmicro.grid.acl.ds;
   
   import static com.trendmicro.grid.acl.ds.config.DataSourcePropertySection.KEY_AUTOSELECT_IMPLEMENTATION_BY_NAMES;
   import static com.trendmicro.grid.acl.ds.config.DataSourcePropertySection.getPropertySection;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Component;
   
  import javax.annotation.PostConstruct;
  import javax.annotation.Resource;
  import java.util.*;
  
  /**
   * Is a central context that allows accessing all registered data repositories.
   * <p/>
   * <b>Note:</b> Avoid using the context directly, instead just implement {@link SelectorAware},
   * inside your spring beans and an implementation of {@link RepositorySelectorsRepository} is
   * injected whenever selector instances have changed.
   *
   * @author juergen_kellerer, 2010-05-05
   * @version 1.0
   */
  @Component
  public class RepositoriesContext implements RepositorySelectorsRepository {
  
  	private static final Logger log = LoggerFactory.getLogger(RepositoriesContext.class);
  
  	@SuppressWarnings("unchecked")
  	private static void extractRepositoryInterfaces(Class cls, List<Class<? extends Repository>> interfaces) {
  		if (cls != null) {
  			for (Class<?> ifCls : cls.getInterfaces()) {
  				if (Repository.class.isAssignableFrom(ifCls))
  					interfaces.add((Class<? extends Repository>) ifCls);
  			}
  			extractRepositoryInterfaces(cls.getSuperclass(), interfaces);
  		}
  	}
  
  	private RepositorySelectorsFile selectorsFile = new RepositorySelectorsFile();
  
  	@Resource
  	private Map<String, ? extends Repository> repositoryImplementations;
  
  	@Autowired(required = false)
  	private Collection<SelectorAware> selectorAwareBeans = Collections.emptyList();
  
  	@PostConstruct
  	@SuppressWarnings("unchecked")
  	public void initializeAllSelectors() {
  		selectorsFile.loadRepositorySelection();
  		RepositorySelectors selectors = selectorsFile.getSelectors();
  
  		// Register / create selectors
  		String[] autoSelectNames = getPropertySection().
  				getPropertyValue(KEY_AUTOSELECT_IMPLEMENTATION_BY_NAMES, "").split("\\s+");
  		Map<Class<? extends Repository>, Map<String, ? extends Repository>> selectorsInputMap = getRepositories();
  		for (Map.Entry<Class<? extends Repository>,
  				Map<String, ? extends Repository>> entry : selectorsInputMap.entrySet()) {
  			RepositorySelector<?> selector = new RepositorySelector(entry.getValue(), entry.getKey());
  			autoSelect(selector, autoSelectNames);
  			selectors.addSelector(selector);
  		}
  
  		// Persist final config
  		selectorsFile.storeRepositorySelection();
  
  		// Log final selection
  		if (log.isDebugEnabled()) {
  			for (RepositorySelector<?> selector : selectors.getAllSelectors()) {
  				log.debug("Initially selected repository {} ({})",
  						selector.getSelectedKey(), selector.getRepositoryClass());
  			}
  		}
  
  		// Handle injection into dependent beans.
  		for (SelectorAware bean : selectorAwareBeans)
  			bean.refreshSelectors(this);
  	}
  
  	private void autoSelect(RepositorySelector<?> selector, String[] names) {
  		if (names != null && names.length > 0 && selector.isAutoSelectedKey()) {
  			for (String key : names) {
  				for (String availableKey : selector.getAvailableKeys())
  					if (availableKey.contains(key)) {
  						selector.setSelectedKey(availableKey, true);
  						break;
  					}
  			}
  		}
  	}
  
  	@SuppressWarnings("unchecked")
  	Map<Class<? extends Repository>, Map<String, ? extends Repository>> getRepositories() {
  		// Sort repository implementations by interface class.
  		Map<Class<? extends Repository>, Map<String, ? extends Repository>> selectorsInputMap =
  				new HashMap<Class<? extends Repository>, Map<String, ? extends Repository>>();
  		for (Map.Entry<String, ? extends Repository> entry : repositoryImplementations.entrySet()) {
  			Repository r = entry.getValue();
 
 			List<Class<? extends Repository>> interfaces = new ArrayList<Class<? extends Repository>>();
 			extractRepositoryInterfaces(r.getClass(), interfaces);
 
 			if (interfaces.isEmpty()) {
 				String msg = "Couldn't find valid repository interface on " + r.getClass() +
 						". This is a bug, not continuing with the startup process.";
 				log.error("TMACL-00480:" + msg);
 				throw new RuntimeException(msg);
 			}
 
 			for (Class<? extends Repository> ifClass : interfaces) {
 				Map m = selectorsInputMap.get(ifClass);
 				if (m == null)
 					selectorsInputMap.put(ifClass, m = new HashMap());
 				m.put(entry.getKey(), r);
 			}
 		}
 		return selectorsInputMap;
 	}
 
 	public List<RepositorySelector<?>> getAllSelectors() {
 		return selectorsFile.getSelectors().getAllSelectors();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public <R extends Repository> RepositorySelector<R> getSelector(Class<R> repositoryClass) {
 		return selectorsFile.getSelectors().getSelector(repositoryClass);
 	}
 
 	/**
 	 * Returns the selected repository implementation for the given repository interface.
 	 *
 	 * @param repositoryClass the repository interface of the repository to return.
 	 * @param <R>             the type of repository interface to return.
 	 * @return the selected repository implementation for the given repository
 	 *         interface or 'null' if no implementation is registered.
 	 */
 	public <R extends Repository> R getRepository(Class<R> repositoryClass) {
 		return getSelector(repositoryClass).getRepository();
 	}
 }