package net.sourceforge.finmodel.account;
   
   import java.io.Serializable;
   import java.math.BigDecimal;
   import java.util.Calendar;
   import java.util.HashSet;
   import java.util.Set;
   import java.util.SortedMap;
   import java.util.TreeMap;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import net.sourceforge.finmodel.asset.AssetImpl;
  import net.sourceforge.finmodel.rules.Rule;
  
  import org.jfin.date.Period;
  import org.jfin.date.ScheduleException;
  
  public class AccountImpl implements Account, Serializable {
  	private static Logger log = Logger.getLogger("net.sourceforge.finmodel.account.AccountImpl");
  	// private static DateFormat dateFormat = new SimpleDateFormat( "MM/dd/yyyy" );
  	
  	private String name = "";
  	private AssetImpl asset = null;
  	private Set<Rule> sourceRules = new HashSet<Rule>();
  	private Set<Rule> destRules = new HashSet<Rule>();
  	
  	// transient private MathContext dollarCtx = new MathContext(2, RoundingMode.HALF_DOWN);
  	private long id = 0L;
  	static final long serialVersionUID = 1L;
  	
  	public AccountImpl() {
  	}
  	
  	public AccountImpl( String name, AssetImpl asset ) {
  		this.name = name;
  		this.asset = asset;
  	}
  	
  	public long getId() {
  		return id;
  	}
  	
  	public void setId( long id ) {
  		this.id = id;
  	}
  	
  	/**
  	 * @TODO:  Implement this properly.
  	 */
  	public BigDecimal getAverageDailyBalance(Period period) {
  		return getBalance(period.getEndCalendar());
  	}
  
  	public BigDecimal getBalance(Calendar calendar) {
  		BigDecimal shares = getShares(calendar);
  		BigDecimal cost = getAsset().getEstimatedValue( calendar );
  		BigDecimal rc = shares.multiply(cost);
  		
  		return rc;
  	}
  	
  	private SortedMap<Calendar, BigDecimal> getTransfers(Calendar when)
  	{
  		SortedMap<Calendar, BigDecimal> transfers = new TreeMap<Calendar, BigDecimal>();
  		for (Rule source: getSourceRules()) {
  			try {
  				for (Calendar cal: source.getSchedule()) {
  					System.err.println("Comparing " + cal + " to " + when);
  					if (cal.before(when)) {
  						transfers.put( cal, source.createTransaction(cal).getAmount().negate());
  					}
  				}
  			} catch (ScheduleException sched) {
  				log.log(Level.WARNING, "ScheduleException for rule: ", sched);
  			}
  		}
  		
  		for (Rule dest: getDestinationRules()) {
  			try {
  				for (Calendar cal: dest.getSchedule()) {
  					if (cal.before(when)) {
  						transfers.put( cal, dest.createTransaction(cal).getAmount());
  					}
  				}
  			} catch (ScheduleException sched) {
  				log.log(Level.WARNING, "ScheduleException for rule: ", sched);
  			}
  		}
  		
  		return transfers;
  	}
  	
  	/**
  	 * @TODO getShares should start at zero, and apply transactions until the
  	 * calendar date.  Although, now that I think about it, we may have trouble
  	 * with some of the percentage rules as their values change depending on what
  	 * the account says it has.  
  	 */
 	public BigDecimal getShares( Calendar calendar ) {
 		SortedMap<Calendar, BigDecimal> transfers = getTransfers( calendar );
 		BigDecimal shares = BigDecimal.ZERO;
 		
 		for (Calendar date: transfers.keySet()) {
 			shares = shares.add(transfers.get(date).divide(getAsset().getEstimatedValue(date)));
 		}
 		
 		return shares;
 	}
 
 	public void setName(String name) {
 		this.name = name;
 	}
 	
 	public String getName() {
 		return name;
 	}
 	
 	public void setAsset(AssetImpl asset) {
 		this.asset = asset;
 	}
 	
 	public AssetImpl getAsset() {
 		return this.asset;
 	}
 	
 	public Set<Rule> getSourceRules() {
 		return sourceRules;
 	}
 	
 	public void addSourceRule( Rule rule ) {
 		sourceRules.add( rule );
 	}
 	
 	public void removeSourceRule( Rule rule ) {
 		sourceRules.remove(rule);
 	}
 	
 	public Set<Rule> getDestinationRules() {
 		return destRules;
 	}
 	
 	public void addDestinationRule( Rule rule ) {
 		destRules.add( rule );
 	}
 	
 	public void removeDestinationRule( Rule rule ) {
 		destRules.remove( rule );
 	}
 }