package net.sourceforge.finmodel.rules;
   
   import java.io.Serializable;
   import java.math.BigDecimal;
   import java.util.ArrayList;
   import java.util.Calendar;
   import java.util.HashSet;
   import java.util.List;
   import java.util.Set;
  
  import org.jfin.date.ScheduleException;
  
  import net.sourceforge.finmodel.account.Account;
  import net.sourceforge.finmodel.plan.FinancialPlan;
  import net.sourceforge.finmodel.plan.Transaction;
  import net.sourceforge.finmodel.plan.TransactionImpl;
  
  public class RuleImpl implements Rule, Serializable {
  	public static final long serialVersionUID = 1L;
  	
  	private long id;
  	private Account source;
  	private Account dest;
  	private FinancialPlan plan;
  	private Set<RuleListener> listeners = new HashSet<RuleListener>();
  
  	protected BigDecimal amount = BigDecimal.ZERO;
  	
  	public RuleImpl() {
  		super();
  	}
  
  	public void setSource(Account source) {
  		Account oldSource = this.source;
  		this.source = source;
  		source.addSourceRule( this );
  		if (oldSource != null) {
  			oldSource.removeSourceRule( this );
  		}
  		
  		if (oldSource == null || !oldSource.equals(source)) {
  			notifySourceChange(oldSource);
  		}
  	}
  
  	public Account getSource() {
  		return source;
  	}
  
  	public void setDestination(Account dest) {
  		Account oldDest = this.dest;
  		this.dest = dest;
  		dest.addDestinationRule( this );
  		if (oldDest != null) {
  			oldDest.removeDestinationRule( this );
  		}
  		
  		if (oldDest == null || !oldDest.equals(dest)) {
  			notifyDestinationChange(oldDest);
  		}
  	}
  
  	public Account getDestination() {
  		return dest;
  	}
  
  	protected void notifyScheduleChange() {
  		for (RuleListener listener: listeners) {
  			listener.eventScheduleChange(this);
  		}
  	}
  
  	protected void notifySourceChange(Account oldSource) {
  		for (RuleListener listener: listeners) {
  			listener.eventSourceChange(this, oldSource);
  		}		
  	}
  
  	protected void notifyDestinationChange(Account oldDest) {
  		for (RuleListener listener: listeners) {
  			listener.eventDestinationChange(this, oldDest);
  		}				
  	}
  
  	public void addRuleListener(RuleListener listener) {
  		listeners.add(listener);
  	}
  
  	public void removeRuleListener(RuleListener listener) {
  		listeners.remove(listener);
  	}
  
  	/**
  	 * @param dest the dest to set
  	 */
  	protected void setDest(Account dest) {
  		this.dest = dest;
  	}
  
 	/**
 	 * @return the dest
 	 */
 	protected Account getDest() {
 		return dest;
 	}
 
 	/**
 	 * @param id the id to set
 	 */
 	public void setId(long id) {
 		this.id = id;
 	}
 
 	/**
 	 * @return the id
 	 */
 	public long getId() {
 		return id;
 	}
 
 	public List<Calendar> getSchedule() throws ScheduleException {
 		return new ArrayList<Calendar>();
 	}
 
 	/**
 	 * @param plan the plan to set
 	 */
 	public void setPlan(FinancialPlan plan) {
 		this.plan = plan;
 	}
 
 	/**
 	 * @return the plan
 	 */
 	public FinancialPlan getPlan() {
 		return plan;
 	}
 
 	protected Transaction makeTransaction(Calendar date, BigDecimal value) {
 		return new TransactionImpl(getSource(), getDestination(), date, value );
 	}
 	
 	/**
 	 * This method is called by createTransaction, only
 	 * after it has established that there is a scheduled
 	 * payment - so it is safe to do whatever calculations
 	 * are required in here, without worrying to see if 
 	 * we have a scheduled transaction on this day.
 	 * 
 	 * @param day
 	 * @return
 	 */
 	protected BigDecimal getAmount(Calendar day) {
 		return amount;
 	}
 	
 	/**
 	 * This will create a transaction for the specific day
 	 * passed in.  If the day is not in the schedule, it will
 	 * return ZERO in the amount field.
 	 * 
 	 * @param day - Day to create the Transaction for.
 	 * @throws ScheduleException - If we are unable to create our schedule.
 	 */
 	public Transaction createTransaction(Calendar day) 
 		throws ScheduleException
 	{
 		List<Calendar> sched = getSchedule();
 		if (sched.contains(day)) {
 			return makeTransaction(day, amount);
 		} else {
 			return makeTransaction(day, BigDecimal.ZERO);
 		}
 	}
 }