package com.trendmicro.grid.acl.ds;
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
   import javax.xml.bind.annotation.*;
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.List;
  import java.util.Map;
  
  /**
   * Is a helper class used to maintain the selection of an active repository.
   *
   * @author juergen_kellerer, 2010-05-05
   * @version 1.0
   */
  @XmlType
  @XmlAccessorType(XmlAccessType.FIELD)
  public class RepositorySelector<R extends Repository> implements RepositorySelectorMBean {
  
  	private static final Logger log = LoggerFactory.getLogger(RepositorySelector.class);
  
  	private transient Map<String, R> repositories;
  	private transient R selected;
  	private transient long lastModified;
  	transient boolean initialized, autoSelectedKey;
  
  	@XmlAttribute(required = true)
  	private String repositoryClass;
  
  	@XmlElement(required = false)
  	private String selectedKey;
  	@XmlElement(name = "available", required = false)
  	private String[] availableKeys;
  
  	public RepositorySelector() {
  	}
  
  	public RepositorySelector(Map<String, R> repositories, Class<R> repositoryClass) {
  		init(repositories, repositoryClass);
  	}
  
  	public void initFrom(RepositorySelector<R> other) {
  		try {
  			lastModified = other.lastModified;
  			if (!other.autoSelectedKey || !other.repositories.containsKey(selectedKey))
  				selectedKey = other.getSelectedKey();
  			init(other.repositories, other.getRepositoryClass());
  		} finally {
  			String selection = getSelectedKey();
  			try {
  				setSelectedKey(selection);
  			} catch (IllegalArgumentException e) {
  				log.warn("TMACL-00340:Failed to select the implementation '{}' for " +
  						"repository type {}, using default of {} instead.",
  						new Object[]{selection, repositoryClass, getSelectedKey()});
  			}
  		}
  	}
  
  	public void init(Map<String, R> repositories, Class<R> repositoryClass) {
  		init(repositories, repositoryClass.getName());
  	}
  
  	private void init(Map<String, R> repositories, String repositoryClass) {
  		if (repositories == null || repositories.isEmpty()) {
  			log.warn("TMACL-00090:The repository type {} doesn't have any registered implementations.",
  					repositoryClass);
  		}
  
  		this.repositories = repositories;
  		this.repositoryClass = repositoryClass;
  		if (repositories != null)
  			availableKeys = repositories.keySet().toArray(new String[repositories.size()]);
  
  		try {
  			setSelectedKey(getSelectedKey());
  		} catch (IllegalArgumentException e) {
  			// ignore
  		}
  
  		initialized = true;
  	}
  
  	private void assertIsInitialized() {
  		if (!initialized) {
  			log.error("TMACL-00110:The selector for {} repositories was invoked " +
  					"before it got initialized. The result will be 'null'.", repositoryClass);
  			throw new IllegalStateException("Selector for repository " +
  					repositoryClass + " is used before it was initialized.");
  		}
  	}
  
  	public long getLastModified() {
  		return lastModified;
  	}
  
  	public void setLastModified(long time) {
 		lastModified = time;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public String getRepositoryClass() {
 		return repositoryClass;
 	}
 
 	public R getRepository(String key) {
 		assertIsInitialized();
 		return repositories == null ? null : repositories.get(key);
 	}
 
 	/**
 	 * Returns the currently selected repository.
 	 *
 	 * @return the currently selected repository.
 	 */
 	public R getRepository() {
 		assertIsInitialized();
 		return selected;
 	}
 
 	public boolean hasSelection() {
 		return selectedKey != null;
 	}
 
 	public boolean isAutoSelectedKey() {
 		return autoSelectedKey;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public String getSelectedKey() {
 		if (!hasSelection() && repositories != null && !repositories.isEmpty()) {
 			String key = repositories.keySet().iterator().next();
 			log.info("TMACL-00120:No selection present for repository type {}, auto-selecting '{}'",
 					repositoryClass, key);
 			setSelectedKey(key);
 			autoSelectedKey = true;
 		}
 		return selectedKey;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public void setSelectedKey(String selectedKey) {
 		setSelectedKey(selectedKey, false);
 	}
 
 	void setSelectedKey(String selectedKey, boolean autoSelectedKey) {
 		if (repositories != null && selectedKey != null && !repositories.containsKey(selectedKey)) {
 			throw new IllegalArgumentException("Cannot set the selection to '" + selectedKey +
 					"' an implementation of that name does not exist.");
 		}
 
 		if (!String.valueOf(this.selectedKey).equals(selectedKey)) {
 			lastModified = System.currentTimeMillis();
 			this.autoSelectedKey = autoSelectedKey;
 		}
 
 		this.selectedKey = selectedKey;
 		selected = repositories == null ? null : repositories.get(selectedKey);
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public List<String> getAvailableKeys() {
 		if (availableKeys == null)
 			return Collections.emptyList();
 		return Arrays.asList(availableKeys);
 	}
 }