/**
 * Simple Train Router
 *
 * @author ab
 */
package btools.memrouter;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import btools.mapaccess.OsmPos;
import btools.router.OsmPathElement;
import btools.router.OsmTrack;
import btools.router.RoutingContext;
import btools.router.RoutingEngine;
import btools.util.SortedHeap;


final class ScheduledRouter
{
	private GraphLoader graph;
	
	private int solutionCount = 0;
	
	public long linksProcessed = 0L;
	public long linksReProcessed = 0L;
	public long closedSkippedChained = 0L;
	public long skippedChained = 0L;
	
	private RoutingContext rc;
	private RoutingEngine re;
	
	private long time0;
	private OsmNodeP start;
	private OsmNodeP end;

    SortedHeap<ScheduledTrip> openSet = new SortedHeap<ScheduledTrip>();

	ScheduledRouter( GraphLoader graph, RoutingContext rc, RoutingEngine re )
	{
		this.graph = graph;
		this.rc = rc;
		this.re = re;
	}
	
	
	public OsmTrack findRoute( OsmPos startPos, OsmPos endPos, String startTime, int alternativeIdx ) throws Exception
	{
	    OsmTrack track = null;
		
		start = graph.matchNodeForPosition( startPos, rc.expctxWay );
		if ( start == null ) throw new IllegalArgumentException( "unmatched start: " + startPos );
		end = graph.matchNodeForPosition( endPos, rc.expctxWay );
		if ( end == null ) throw new IllegalArgumentException( "unmatched end: " + endPos );

//		SimpleDateFormat df = new SimpleDateFormat( "dd.MM.yyyy-HH:mm" );
//		time0 = df.parse(startTime).getTime();
time0 = System.currentTimeMillis() + (long)(rc.starttimeoffset * 60000L );
long minutes0 = (time0 + 59999L) / 60000L;
time0 = minutes0 * 60000L;

		OffsetSet finishedOffsets = OffsetSet.emptySet();
		
		OsmLinkP startLink = new OsmLinkP( null, start );
		
		ScheduledTrip startTrip = new ScheduledTrip( OffsetSet.fullSet(), startLink, null, null );
		openSet.add( 0, startTrip );
		for(;;)
		{
			if ( re.isTerminated() )
			{
				throw new RuntimeException( "operation terminated" );
			}
			if ( linksProcessed + linksReProcessed > 5000000 )
			{
				throw new RuntimeException( "5 Million links limit reached" );
			}
			
			// get cheapest trip from heap
			ScheduledTrip trip = openSet.popLowestKeyValue();
			if ( trip == null )
			{
			  break;
			}
			OsmLinkP currentLink = trip.link;
			OsmNodeP currentNode = trip.getTargetNode();
			if ( currentNode == null )
			{
				System.out.println( "ups: " + trip );
				continue;
			}
			
			if ( currentLink.isVirgin() )
			{
			  linksProcessed++;
			}
			else
			{
			  linksReProcessed++;
			}
			
	        // check global closure
			OffsetSet offsets = finishedOffsets.filter( trip.offsets );
			if ( offsets == null ) continue;

			// check local closure for links:
			offsets = currentLink.filterAndClose( offsets, trip.arrival, currentLink instanceof ScheduledLink );
			if ( offsets == null ) continue;
			
			
			// check for arrival
			if ( currentNode == end )
			{
			  for( int offset = 0; offset<trip.offsets.size(); offset++ )
			  {
				  if ( trip.offsets.contains( offset ) )
				  {
				    track = compileTrip( trip, offset );
				    System.out.println( "---- begin route ------ (cost " + track.cost + ")" );
				    for( String s : track.iternity ) System.out.println( s );
				    System.out.println( "---- end route ------" );
				    break; // + plus more offsets..
				  }
			  }
			  finishedOffsets = finishedOffsets.add( offsets );
			  if ( solutionCount++ >= alternativeIdx ) return track;
			}
	        for( OsmLinkP link = currentNode.getFirstLink(); link != null; link = link.getNext( currentNode ) )
			{
	          addNextTripsForLink(trip, currentNode, currentLink, link, offsets, 0 );
			}
		}
	    return track;
	}
	
	private void addToOpenSet( ScheduledTrip nextTrip )
    {
	  int distance = nextTrip.getTargetNode().calcDistance( end );
	  nextTrip.adjustedCost = nextTrip.cost + (int)(distance * rc.pass1coefficient + 0.5);
	  openSet.add( nextTrip.adjustedCost, nextTrip );
    }
	
	
    private void addNextTripsForLink( ScheduledTrip trip, OsmNodeP currentNode, OsmLinkP currentLink, OsmLinkP link, OffsetSet offsets, int level )
	{
	  if ( link == currentLink ) 
	  {
	    return; // just reverse, ignore
	  }
	  OsmNodeP node = link.getTarget(currentNode);
		if ( node == null )
		{
			System.out.println( "ups2: " + link );
			return;
		}

	  // calc distance and check nogos
	  rc.nogomatch = false;
	  int distance = rc.calcDistance( currentNode.ilon, currentNode.ilat, node.ilon, node.ilat );
      if ( rc.nogomatch )
      {
        return;
      }

	  if ( link instanceof ScheduledLink )
      {
// System.out.println( "next trip for link: " + link + " at offset " + offsets );		  
		  
        ScheduledLink slink = (ScheduledLink)link;
      	ScheduledLine line = slink.line;
      	
      	// line change delay
      	long delay = 0L;
      	if ( currentLink instanceof ScheduledLink )
      	{
      	  delay = ((ScheduledLink)currentLink).line == line ? 0L : (long)(rc.changetime * 1000.); // 3 minutes
      	}
        long changePenalty = delay > 0 ? 60000L : 0L;
      	
		List<ScheduledDeparture> nextDepartures = line.getScheduledDepartures( slink.indexInLine, time0 + trip.arrival + delay, offsets );
		for( ScheduledDeparture nextDeparture : nextDepartures )
		{
		  ScheduledTrip nextTrip = new ScheduledTrip( nextDeparture.offsets, link, currentNode, trip );
		  long waitTime = nextDeparture.waitTime + delay;
		  long rideTime = nextDeparture.rideTime;
				
	      nextTrip.cost = trip.cost + (int)( ( rideTime + changePenalty + waitTime*rc.waittimeadjustment ) * rc.cost1speed / 3600. ); // 160ms / meter = 22km/h
	      nextTrip.departure = trip.arrival + waitTime;
	      nextTrip.arrival = nextTrip.departure + rideTime;

			addToOpenSet( nextTrip );

//	      System.out.println( "found: " + nextTrip );		  
	    }
      }
      else if ( link.isWayLink() )
      {
    	  // get costfactor
          rc.expctxWay.evaluate( link.isReverse(currentNode), link.descriptionBitmap, null );
    	    
          // *** penalty for distance
          float costfactor = rc.expctxWay.getCostfactor();
          if ( costfactor > 9999. )
          {
            return;
          }
          int waycost = (int)(distance * costfactor + 0.5f);

          // *** add initial cost if factor changed
          float costdiff = costfactor - trip.lastcostfactor;
          if ( costdiff > 0.0005 || costdiff < -0.0005 )
          {
              waycost += (int)rc.expctxWay.getInitialcost();
          }

          
          if ( node.getNodeDecsription() != null )
          {
              rc.expctxNode.evaluate( rc.expctxWay.getNodeAccessGranted() != 0. , node.getNodeDecsription(), null );
              float initialcost = rc.expctxNode.getInitialcost();
              if ( initialcost >= 1000000. )
              {
                return;
              }
              waycost += (int)initialcost;
          }

          // *** penalty for turning angles
          if ( trip.originNode != null )
          {
            // penalty proportional to direction change
        	double cos = rc.calcCosAngle( trip.originNode.ilon, trip.originNode.ilat, currentNode.ilon, currentNode.ilat, node.ilon, node.ilat );
            int turncost = (int)(cos * rc.expctxWay.getTurncost() + 0.2 ); // e.g. turncost=90 -> 90 degree = 90m penalty
            waycost += turncost;
          }

          ScheduledTrip nextTrip = new ScheduledTrip( offsets, link, currentNode, trip );

		  // *** penalty for elevation
          short ele2 = node.selev;
          short ele1 = trip.selev;
          int elefactor = 250000;
          if ( ele2 == Short.MIN_VALUE ) ele2 = ele1;
          nextTrip.selev = ele2;
          if ( ele1 != Short.MIN_VALUE )
          {
            nextTrip.ehbd = trip.ehbd + (ele1 - ele2)*elefactor - distance * rc.downhillcutoff;
            nextTrip.ehbu = trip.ehbu + (ele2 - ele1)*elefactor - distance * rc.uphillcutoff;
          }

          if ( nextTrip.ehbd > rc.elevationpenaltybuffer )
          {
             int excess = nextTrip.ehbd - rc.elevationpenaltybuffer;
             int reduce = distance * rc.elevationbufferreduce;
             if ( reduce > excess )
             {
               reduce = excess;
             }
             excess = nextTrip.ehbd - rc.elevationmaxbuffer;
             if ( reduce < excess )
             {
               reduce = excess;
             }
             nextTrip.ehbd -= reduce;
             if ( rc.downhillcostdiv > 0 )
             {
               int elevationCost = reduce/rc.downhillcostdiv;
               waycost += elevationCost;
             }
          }
          else if ( nextTrip.ehbd < 0 )
          {
        	  nextTrip.ehbd = 0;
          }

          if ( nextTrip.ehbu > rc.elevationpenaltybuffer )
          {
            int excess = nextTrip.ehbu - rc.elevationpenaltybuffer;
            int reduce = distance * rc.elevationbufferreduce;
            if ( reduce > excess )
            {
              reduce = excess;
            }
            excess = nextTrip.ehbu - rc.elevationmaxbuffer;
            if ( reduce < excess )
            {
              reduce = excess;
            }
            nextTrip.ehbu -= reduce;
            if ( rc.uphillcostdiv > 0 )
            {
              int elevationCost = reduce/rc.uphillcostdiv;
              waycost += elevationCost;
            }
          }
          else if ( nextTrip.ehbu < 0 )
          {
        	  nextTrip.ehbu = 0;
          }
          
      	  nextTrip.lastcostfactor = costfactor;
		  nextTrip.cost = trip.cost + (int)(waycost*rc.additionalcostfactor + 0.5);
		  nextTrip.departure = trip.arrival;
		  nextTrip.arrival = nextTrip.departure + (long) ( waycost * 3600. / rc.cost1speed ); // 160ms / meter = 22km/h

			addToOpenSet( nextTrip );
      }
      else // connecting link
      {
		  ScheduledTrip nextTrip = new ScheduledTrip( offsets, link, currentNode, trip );

			long delay = (long)(rc.buffertime * 1000.); // 2 min
		    nextTrip.cost = trip.cost + (int)( delay*rc.waittimeadjustment * rc.cost1speed / 3600. );
			nextTrip.departure = trip.arrival;
			nextTrip.arrival = nextTrip.departure + delay; 
			
			addToOpenSet( nextTrip );
        }
	}
	
	private OsmTrack compileTrip( ScheduledTrip trip, int offset )
	{
	  OsmTrack track = new OsmTrack();
	  track.iternity = new ArrayList<String>();
      ScheduledTrip current = trip;
      ScheduledLine lastLine = new ScheduledLine();
      ScheduledLine dummyLine = new ScheduledLine();
      List<ScheduledTrip> list = new ArrayList<ScheduledTrip>();
      
	  int distance = 0;

	  ScheduledTrip itrip = null;
	  
	  String profile = extractProfile( rc.localFunction );

      OsmNodeP nextNode = null;      
      while( current != null )
      {
System.out.println( "trip=" + current );
    	  OsmNodeP node = current.getTargetNode();
    	  OsmPathElement pe = OsmPathElement.create(node.ilon, node.ilat, node.selev, null, false );
    	  track.addNode(pe);

	      if ( nextNode != null )
	      {
	        distance += node.calcDistance( nextNode );
	      }
    	  
    	  boolean isScheduled = current.link instanceof ScheduledLink;
    	  boolean isConnection = current.link.descriptionBitmap == null && !isScheduled;
    	  ScheduledLine line = isScheduled ? ((ScheduledLink)current.link).line : isConnection ? dummyLine : null;

    	    if ( line != lastLine && !isConnection )
    	    {
    	      itrip = new ScheduledTrip();
    	      itrip.departure = current.departure;
    	      itrip.arrival = current.arrival;
    	      itrip.originNode = current.originNode;
    	      itrip.link = current.link;
    	      
    	      if ( isScheduled && list.size() > 0 )
    	      {
    	    	  list.get( list.size()-1 ).originNode = current.getTargetNode();
    	      }
        	  list.add(itrip);
    	    }
    	    else if ( itrip != null && !isConnection )
    	    {
        	  itrip.departure = current.departure;
        	  itrip.originNode = current.originNode;
    	   }
    	   lastLine = line;
    	  current = current.origin;
    	  nextNode = node;
      }
	  track.distance = distance;
	  track.cost = trip.cost;

      for( int i=list.size()-1; i>=0; i-- )
      {
    	  current = list.get(i);
    	  String lineName = profile;

    	  boolean isScheduled = current.link instanceof ScheduledLink;
    	  if ( isScheduled )
    	  {
    		  lineName = ((ScheduledLink)current.link).line.name;
    	  }
    	  String stationName = "*position*";
    	  if ( current.originNode instanceof StationNode )
    	  {
		    stationName = ((StationNode)current.originNode).name;
    	  }
    	  String nextStationName = "*position*";
    	  if ( i > 0 && list.get(i-1).originNode instanceof StationNode )
    	  {
    		  nextStationName = ((StationNode)list.get(i-1).originNode).name;
    	  }
    	  {
      		Date d0 = new Date( time0 + 60000L * offset + current.departure );
    		Date d1 = new Date( time0 + 60000L * offset + current.arrival );
	        if ( track.iternity.size() > 0 ) track.iternity.add( "" );
	        track.iternity.add( "depart: " + d0 + " " + stationName );
	        track.iternity.add( "                                     --- " + lineName + " ---" );
	        track.iternity.add( "arrive: " + d1 + " " + nextStationName  );
    	  }
      }

      return track;
	}
	
	private String extractProfile( String s )
	{
		int idx = s.lastIndexOf( '/' );
		if ( idx >= 0 ) s = s.substring(  idx+1 );
	    idx = s.indexOf( '.' );
		if ( idx >= 0 ) s = s.substring(  0,idx );
        return s;		
	}
}