/**
    * Investor, the open-source investment library
    *
    * (C) Copyright 2008, by individual contributors as indicated by the @author tag.
    *
    * This library is free software; you can redistribute it and/or modify it
    * under the terms of the GNU Lesser General Public License as
    * published by the Free Software Foundation; either version 2.1 of
    * the License, or (at your option) any later version.
   *
   * This software is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this software; if not, write to the Free
   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
   */
  package com.nickokiss.investor.fin.element;
  
  import java.math.BigDecimal;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  
  import org.apache.commons.lang.builder.EqualsBuilder;
  import org.apache.commons.lang.builder.HashCodeBuilder;
  
  import com.nickokiss.investor.calc.MathCalc;
  import com.nickokiss.investor.fin.element.creator.StreamElementCreator;
  import com.nickokiss.investor.fin.env.Env;
  
  /**
   * 
   * @author Tomasz Koscinski <tomasz.koscinski@nickokiss.com>
   */
  public class CashFlowStream implements FinElement {
  
    private MathCalc mathCalc = new MathCalc();
    
    private BigDecimal STARTING_TIME = mathCalc.ZERO;
  
    private List<StreamElement> elements = new ArrayList<StreamElement>();
  
    public CashFlowStream() {
    };
  
    public CashFlowStream(CashFlowStream cashFlowStream) {
      add(cashFlowStream);
    }
  
    public void sort() {
      Collections.sort(elements, new TimeComparator());
    }
    
    public void addElement(StreamElement streamElement) {
      elements.add(streamElement);
    }
  
    public List<StreamElement> getElements() {
      return elements;
    }
  
    public BigDecimal getEndTime() {
      return Collections.max(elements, new TimeComparator()).getTime();
    }
  
    public BigDecimal getStartTime() {
      return Collections.min(elements, new TimeComparator()).getTime();
    }
  
    private class TimeComparator implements Comparator<StreamElement> {
      public int compare(StreamElement se1, StreamElement se2) {
        return se1.getTime().compareTo(se2.getTime());
      }
    }
  
    public List<StreamElement> getElements(StreamElementType streamElementType) {
      List<StreamElement> selectedElements = new ArrayList<StreamElement>();
      for (StreamElement streamElement : elements) {
        if (streamElement.getType().equals(streamElementType)) {
          selectedElements.add(streamElement);
        }
      }
      return selectedElements;
    }
  
    public void repeat(int times) {
      if (times <= 0) {
        return;
      }
      CashFlowStream repeatablePart = new CashFlowStream();
      repeatablePart.add(this);
      for (int i = 0; i < times; i++) {
        add(repeatablePart);
      }
   }
 
   public void add(CashFlowStream cashFlowStream) {
     CashFlowStream partToAdd = cashFlowStream.getCopy();
     if (elements.size() > 0) {
       partToAdd.move(this.length());
     }
     elements.addAll(partToAdd.getElements());
   }
 
   public int hashCode() {
     return HashCodeBuilder.reflectionHashCode(this);
   }
 
   public boolean equals(Object obj) {
     return EqualsBuilder.reflectionEquals(this, obj);
   }  
 
   public BigDecimal length() {
     return getEndTime().subtract(getStartTime());
   }
 
   public void move(BigDecimal time) {
     for (StreamElement streamElement : elements) {
       streamElement.setTime(streamElement.getTime().add(time));
     }
   }
 
   public CashFlowStream getCopy() {
     CashFlowStream copy = new CashFlowStream();
     for (StreamElement se : elements) {
       copy.addElement(new StreamElement(se.getValue(), se.getTime()));
     }
     return copy;
   }
 
   public void addElements(StreamElementCreator streamElementCreator, int quantity) {
     for (int i = 0; i < quantity; i++) {
       StreamElement streamElement = streamElementCreator.create(this);
       addElement(streamElement);
     }
 
   }
 
   public BigDecimal getFirstValue() {
     return Collections.min(elements, new TimeComparator()).getValue();
   }
 
   public BigDecimal getLastValue() {
     return Collections.max(elements, new TimeComparator()).getValue();
   }
 
   private BigDecimal getStartingTime() {
     if (elements.size() == 0) {
       return STARTING_TIME;
     } else {
       return getEndTime();
     }
   }
 
   public void addElements(BigDecimal value, int quantity, BigDecimal distance) {
     BigDecimal time = getStartingTime();
     for (int i = 1; i <= quantity; i++) {
       time = time.add(distance);
       addElement(new StreamElement(value, time));
     }
   }
 
   public BigDecimal getValue(Env env, BigDecimal time) {
     BigDecimal value = mathCalc.ZERO;
     for (StreamElement finElement : elements) {
       value = value.add(finElement.getValue(env, time));
     }
     return value;
   }
 
   public BigDecimal getDuration(Env env) {
     BigDecimal presentValue = getValue(env, mathCalc.ZERO);
     BigDecimal weightedSum = mathCalc.ZERO;
     for (StreamElement element : elements) {
       BigDecimal timeValue = element.getValue().multiply(element.getTime());
       BigDecimal durationMultiplicand = env.getDurationMultiplicand(element.getTime());
       BigDecimal weightedElement = timeValue.multiply(durationMultiplicand);
       weightedSum = weightedSum.add(weightedElement);
     }
     BigDecimal duration = mathCalc.div(weightedSum, presentValue);
     return duration;
   }
 
 }