/*
    * AccountPoolMapper.java
    *
    * Created on June 16, 2004, 3:10 PM
    */
   
   package gov.bnl.gums.account;
   
   import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Date;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Set;
  import java.util.StringTokenizer;
  import java.util.TreeMap;
  
  import gov.bnl.gums.Mapping;
  import gov.bnl.gums.SiteUser;
  import gov.bnl.gums.configuration.Configuration;
  
  import javax.persistence.*;
  
  /** 
   * Provides the mapping by assigning user accounts from a pool provided by
   * the AccountPoolMapperDB.
   * <p>
   * The accounts are mapped when the mapUser function is called for that
   * particular user. Accounts are never deleted from the pool
   *
   * @author  Gabriele Carcassi, Jay Packard
   */
  @Entity
  public class AccountPoolMapper extends ManualAccountMapper {
  	protected String assignments = null;
  	protected String pool;
  	protected String primaryGroup;
  	protected Set<String> secondaryGroups = new HashSet<String>();
  
  	// persistent fields
  	protected String accountPool;
  	
      public AccountPoolMapper() {
      	super();
      }
      
      public AccountPoolMapper(Configuration configuration, String name) {
      	super(configuration, name);
      }
      
      public String getAccountPool() {
      	return accountPool;
      }
      
      @Transient
      public String getAccountPoolRoot() {
      	int index = accountPool.indexOf(".");
      	if (index != -1)
      		return accountPool.substring(0, index);
      	else
      		return accountPool;
      } 
  
      /**
       * @return String representation of how many accounts are assigned in database for each root account
       */
      @SuppressWarnings("unchecked")
      @Transient
  	public String getAssignments() {
  		if (assignments==null || getLastUpdate().after(new Date())) {
  	    	String retStr = new String();
  
  	    	TreeMap<String, Object> accountRoots = new TreeMap<String, Object>();
  	    	Iterator<Mapping> it = mappings.iterator();
  	    	while (it.hasNext()) {
  	    		String account = it.next().getSiteUser().getAccount();
  	    		String accountRoot = getRoot(account);
  	    		String accountNumber = getNumber(account);
  	    		Object[] stats = (Object[])accountRoots.get(accountRoot);
  	    		if (stats==null) {
  	    			stats = new Object[3];
  	    			stats[0] = new Integer(0); // total
  	   				stats[1] = new Integer(0); // assigned
  	   				stats[2] = new ArrayList<String>(); // number list
  	    		}
      			stats[0] = new Integer(((Integer)stats[0]).intValue() + 1); // total
      			if (mapSiteUser(new SiteUser(account)).size() != 0)
      				stats[1] = new Integer(((Integer)stats[1]).intValue() + 1); // assigned
     				((ArrayList<String>)stats[2]).add(accountNumber); // number list
  	    		accountRoots.put(accountRoot, stats);
  	    	}
  	    	Iterator<String> rootIt = accountRoots.keySet().iterator();
  	    	while (rootIt.hasNext()) {
  	    		String accountRoot = rootIt.next();
  	    		retStr += accountRoot;
  	    		ArrayList<String> numbers = (ArrayList<String>)((Object[])accountRoots.get(accountRoot))[2];
  	    		Collections.sort(numbers);
  	    		Iterator<String> numIt = numbers.iterator();
  	    		String lastNumber = null;
 	    		while(numIt.hasNext()) {
 	    			String number = (String)numIt.next();
 	    			if(lastNumber==null)
     					retStr += number;
 	    			else if(greaterThanOne(lastNumber, number))
     					retStr += "-" + lastNumber + "," + number;
 	    			else if(!numIt.hasNext())
 	    				retStr += "-" + number;
 	    			lastNumber = number;
 	    		}
 	    		retStr += "(" + 
 	    			((Object[])accountRoots.get(accountRoot))[1] + "/" + 
 	    			((Object[])accountRoots.get(accountRoot))[0] + ")";
 	    		if (it.hasNext())
 	    			retStr += ", ";
 	    	}
 	    	assignments = retStr;
 	    	return retStr;
     	}
 		else {
 			return assignments;
 		}
     }
 
 	public SiteUser mapDn(String dn, boolean createNew){
 		SiteUser siteUser = super.mapDn(dn, createNew);
 		synchronized(mappings) {
 			if (siteUser == null && createNew) {
 				for (Mapping m: mappings) {
 					if (m.getDn() == null) {
 						m.setDn(dn);
 						siteUser = m.getSiteUser();
 						refreshMaps();
 						break;
 					}
 				}
 			}
 		}
 		return siteUser;
 	}
 	
 	@ConfigFieldAnnotation(label="Pool Name / Groups", example="myPool.myPrimaryGroup.mySecondaryGroup1.mySecondaryGroup2... ")
     public void setAccountPool(String accountPool) {
     	this.accountPool = accountPool;
 
     	if (accountPool!=null) {
 	    	StringTokenizer tokens = new StringTokenizer(accountPool, ".");
 	    	pool = tokens.nextToken();
 	    	if (tokens.hasMoreTokens())
 	    		primaryGroup = tokens.nextToken();
 	        while (tokens.hasMoreTokens())
 	        	secondaryGroups.add(tokens.nextToken());
     	}
     }
     
     public void setLastUpdate(Date lastUpdate) {
 		this.lastUpdate = lastUpdate;
 	}    
     
     protected String getNumber(String account) {
     	int i = account.length()-1;
     	while (i>=0 && account.charAt(i)>=48 && account.charAt(i)<=57)
     		i--;
     	i++;
     	return new String( account.substring(i) );
     }
 
     protected String getRoot(String account) {
     	int i = account.length()-1;
     	while (i>=0 && account.charAt(i)>=48 && account.charAt(i)<=57)
     		i--;
     	i++;
     	return new String( account.substring(0,i) );
     }
 
 	protected boolean greaterThanOne(String smaller, String larger) {
     	if (smaller.length() != larger.length())
     		return true;
     	int i1 = Integer.parseInt(smaller);
     	int i2 = Integer.parseInt(larger);
     	return (i2 > i1+1);
     }
 	
 }