package graph;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import feature.StreetSegment;
import feature.StreetSegmentObserver;

/**
 * Base implementation for shortest-path algorithms.
 */
public abstract class AbstractShortestPathAlgorithm implements ShortestPathAlgorithm
{
  private Collection<StreetSegmentObserver> observers;

  /**
   * 
   */
  public AbstractShortestPathAlgorithm()
  {
    observers = new ArrayList<StreetSegmentObserver>();
  }

  @Override
  public abstract Map<String, StreetSegment> findPath(int origin, int destination,
      StreetNetwork net);

  @Override
  public void addStreetSegmentObserver(final StreetSegmentObserver observer)
  {
    if (observer != null)
    {
      observers.add(observer);
    }
  }

  @Override
  public void removeStreetSegmentObserver(final StreetSegmentObserver observer)
  {
    observers.remove(observer);
  }

  @Override
  public void notifyStreetSegmentObservers(final List<String> segmentIDs)
  {
    for (StreetSegmentObserver observer : observers)
    {
      observer.handleStreetSegments(segmentIDs);
    }
  }

  /**
   * @param segmentID the segment id
   */
  protected void notifyStreetSegmentObservers(final String segmentID)
  {
    List<String> one = new ArrayList<String>();
    one.add(segmentID);
    notifyStreetSegmentObservers(one);
  }

  /**
   * @param labels the labels
   * @param origin the origin id
   * @param destination the destination id
   * @return ordered path map
   */
  protected Map<String, StreetSegment> buildPath(final LabelManager labels, final int origin,
      final int destination)
  {
    LinkedHashMap<String, StreetSegment> path =
        new LinkedHashMap<String, StreetSegment>();

    if (labels == null)
    {
      return path;
    }

    Label destinationLabel = labels.getLabel(destination);
    if (destinationLabel == null || Double.isInfinite(destinationLabel.getValue()))
    {
      return path;
    }

    ArrayList<StreetSegment> reversed = new java.util.ArrayList<StreetSegment>();
    Label current = destinationLabel;
    while (current != null && current.getID() != origin)
    {
      StreetSegment predecessor = current.getPredecessor();
      if (predecessor == null)
      {
        break;
      }
      reversed.add(predecessor);
      current = labels.getLabel(predecessor.getTail());
    }

    for (int i = reversed.size() - 1; i >= 0; i--)
    {
      StreetSegment segment = reversed.get(i);
      path.put(segment.getID(), segment);
    }

    return path;
  }
}