// executeplan.c
// 
// Version	Date	 Author	 Description
//	--------------------------------------------------------------------------
//  0.01	29/07/01 BWW	 Execute the current plan

#include <c:\psx\include\libps.h>
#include "planner.h"
#include "funcprototypes.h"

extern	Plan_Struct					Plan;
extern	UnmetPreconditions_Struct	UnmetPreconditions;
extern	Orderings_Struct			Orderings;
//extern  AvailablePrecons_Struct		AvailablePrecons;
//extern  AvailableActions_Struct		AvailableActions;
extern	ActionEffects_Struct		ActionEffects;
extern	CausalLinks_Struct			CausalLinks;
extern  SearchGoalNodes_Struct		SearchGoalNodes;
extern	Agent_Struct				Agent;
extern	Route_Struct				Route;

extern	Key_Struct					Key;
extern	Door_Struct					Door[];
extern	CausalLinks_Struct			CausalLinks;
extern	Orderings_Struct			Orderings;

extern 	Metrics_Struct				Metrics;



extern	int	startx, starty,destinationx, destinationy;



//	--------------------------------------------------------------------------
// 	Select the next ActionEffect to execute
//	--------------------------------------------------------------------------
//	Description:	Select the next action effect from the plan, considering
//					which of the outstanding preconditions are available to be 
//					addressed.
//
//	Parameters:		None	
//							
//	Returns:		None

void GetNextActionEffect()
	{

	static AvailablePrecons_Struct		AvailablePrecons;
	static AvailableActions_Struct		AvailableActions;

	int index, index2, count, lowestcost, selectedindex;
	
	// Initialise the AvailablePrecons structure.  All preconditions are initially available
	for (index=0;index<UnmetPreconditions.numpreconditions;index++)
		{
		AvailablePrecons.available[index] = true;
		}
	AvailablePrecons.numpreconditions = UnmetPreconditions.numpreconditions;
	
	// Make preconditions unavailable if they still have unexecuted orderings is predecessor preconditions
	for (index=0;index<Orderings.numorderings;index++)
		{
		if (Orderings.executed[index]==false)
			{
			AvailablePrecons.available[Orderings.successor[index]] = false;
			}
		}
	
	// Count the number of available precons
	count = 0;
	for (index=0;index<AvailablePrecons.numpreconditions;index++)
		{
		if (AvailablePrecons.available[index]==true)
			{
			count++;
			}
		}
	
	// Fail if there aren't any, otherwise look for ActionEffects that can be applied next
	if (count==0) 
		{
		Plan.status=FAILEDPLAN;
		}
	else
		{
		
		// Initialise all of the ActionEffects to false
		for (index=0;index<ActionEffects.numeffects;index++)
			{
			AvailableActions.available[index]=false;
			}
		AvailableActions.numeffects=ActionEffects.numeffects;
		
		// Loop through the available precons and identify the actions to be applied using
		// the causal link structure
		for (index=0;index<AvailablePrecons.numpreconditions;index++)
			{
			if (AvailablePrecons.available[index]==true)
				{
				
				// Loop through the causal links
				for (index2=0;index2<CausalLinks.numcausallinks;index2++)			
					{
					
					if ((CausalLinks.unmetprecondition[index2]==index)&&
						(CausalLinks.executed[index2]==false))
						{
						AvailableActions.available[CausalLinks.actioneffect[index2]]=true;
						}
					}
				}
			}
			
		// Loop through and choose the lowest cost action to apply	
		lowestcost = 50000;
		selectedindex = -1;
		
		for (index=0;index<AvailableActions.numeffects;index++)
			{
			
			if ((AvailableActions.available[index]==true)&&
				(ActionEffects.executed[index]==false)&&
				(ActionEffects.duration[index] < lowestcost))
				{
				lowestcost=ActionEffects.duration[index];
				selectedindex=index;
				}
			}
		
		// If we haven't found any actions at all that can be applied, then fail.  Otherwise set up
		// the lowest cost one
		if (selectedindex == -1)
			{
			Plan.status=FAILEDPLAN;
			}
		else
			{
			
			Plan.actioneffectindex = selectedindex;
			Route.numsteps = 0;
						
			// If the action we have selected is MOVETO then we have to set up the route
			if (ActionEffects.effect[selectedindex].condition==EFFECT_MOVETO)
				{			
			
				// (Use globals to pass the start/destination XY)
				startx = Agent.x;
				starty = Agent.y;
				destinationx = ActionEffects.effect[selectedindex].value2;
				destinationy = ActionEffects.effect[selectedindex].value3;
				GenerateSearchTree(true);

				// Check whether a valid route exists, else fail
				if (SearchGoalNodes.numgoalnodes > 0)
					{
			
					// Select the best route 
					SelectRoute();
					
					// Set up the Plan attributes
					Plan.duration = Route.cost[1];
					
//					printf("Route No. steps:  %d\n", Route.numsteps); 
//					printf("Route Step 0 X: %d  Y: %d Cost: %d\n", Route.x[0], Route.y[0],Route.cost[0]); 
//					printf("Route Step 1 X: %d  Y: %d Cost: %d\n", Route.x[1], Route.y[1],Route.cost[1]); 
//					printf("Route Step 2 X: %d  Y: %d Cost: %d\n", Route.x[2], Route.y[2],Route.cost[2]); 
//					printf("Route Step 3 X: %d  Y: %d Cost: %d\n", Route.x[3], Route.y[3],Route.cost[3]); 
//					printf("Route Step 4 X: %d  Y: %d Cost: %d\n", Route.x[4], Route.y[4],Route.cost[4]); 
//					printf("Route Step 5 X: %d  Y: %d Cost: %d\n", Route.x[5], Route.y[5],Route.cost[5]); 
//					printf("Route Step 6 X: %d  Y: %d Cost: %d\n", Route.x[6], Route.y[6],Route.cost[6]); 
//					printf("Route Step 7 X: %d  Y: %d Cost: %d\n", Route.x[7], Route.y[7],Route.cost[7]); 
//					printf("Route Step 8 X: %d  Y: %d Cost: %d\n", Route.x[8], Route.y[8],Route.cost[8]); 
//					printf("Route Step 9 X: %d  Y: %d Cost: %d\n", Route.x[9], Route.y[9],Route.cost[9]); 
					
					Plan.currentstep = 1;		
					}
				else
					{
					Plan.status=FAILEDPLAN;
					}
				}
			else
				{
				Plan.duration = ActionEffects.duration[selectedindex];
				}
			}
		}
	}




//	--------------------------------------------------------------------------
// 	Initialise plan execution parameters
//	--------------------------------------------------------------------------
//	Description:	Initialise the parameters that will be used during the 
//					execution of the plan
//
//	Parameters:		None	
//							
//	Returns:		None

void InitExecution()
	{
	Plan.status = NOPLAN;
	Plan.actioneffectindex = -1;
	Plan.duration = 0;
	Plan.goalachieved = false;
	
	}
	

//	--------------------------------------------------------------------------
// 	Execute the plan
//	--------------------------------------------------------------------------
//	Description:	Execute the current plan
//
//	Parameters:		None	
//							
//	Returns:		None

void ExecutePlan()
	{
	
	int index, index2, count;
	
	// Check for a valid plan, if there isn't one, then create one
	if ((Plan.status==NOPLAN)||(Plan.status==FAILEDPLAN))
		{
		InitExecution();
		BuildPlan();
		Plan.status=PLAN;
		
		// Capture metrics
		Metrics.p_plannumber++;
		Metrics.p_numpreconditions = UnmetPreconditions.numpreconditions;
		Metrics.p_numactioneffects = ActionEffects.numeffects;
		Metrics.p_numcausallinks = CausalLinks.numcausallinks;
		Metrics.p_numorderings = Orderings.numorderings;
		Metrics.p_totplannumber++ ;
		Metrics.p_totnumpreconditions += UnmetPreconditions.numpreconditions;
		Metrics.p_totnumactioneffects += ActionEffects.numeffects;
		Metrics.p_totnumcausallinks += CausalLinks.numcausallinks;
		Metrics.p_totnumorderings += Orderings.numorderings;
		
		MetricPlan();

		}
		
	// Check for a current ActionEffect, get the next if there isn't one
	if (Plan.actioneffectindex==-1)
		{
		GetNextActionEffect();
		}
	
	// Check to see that we still have a valid plan and excute the current step
	if (Plan.status == PLAN)
		{
		
		// Decrement the counter that indicates the length of time an actioneffect
		// takes to apply.  Endeavour to apply the effects of the action to the
		// environment if it has reached zero.
		Plan.duration--;
		if (Plan.duration == 0)
			{
			
			// Check whether the current ActionEffect is a MOVETO.  If it is then it has
			// multiple parts that need to be applied before it is considered complete
			if (ActionEffects.effect[Plan.actioneffectindex].condition == EFFECT_MOVETO)
				{
				
				// If the location is inaccessible, then the plan has failed.  Otherwise move there
				if (CheckLocationForAccess(Route.x[Plan.currentstep],Route.y[Plan.currentstep],true)==0)
					{
					Plan.status = FAILEDPLAN;
					Metrics.e_preconditionsfailed++;
					}
				else
					{
										
					Agent.x = Route.x[Plan.currentstep];
					Agent.y = Route.y[Plan.currentstep];

					// If the agent has the key then set it's location as well
					if (Agent.gotkey==true)
						{
						Key.x = Agent.x;
						Key.y = Agent.y;
						}
					}
				
				// Imcrement the current location along the route.  Check for the end and get the duration
				// of the next step
				Plan.currentstep++;
				if (Plan.currentstep == Route.numsteps)
					{
//					Plan.actioneffectindex = -1;
					}
				else
					{
					Plan.duration = Route.cost[Plan.currentstep];
					}
				}
						
			// Check again that the duration is still zero to see whether we have
			// reached the end of the MOVETO.  MOVETO may also have failed, so also
			// check for plan failure
			if ((Plan.duration == 0)&&(Plan.status==PLAN))
				{

				Metrics.e_preconditionsmet++;

				
				// Apply the effects of the action to the environment				
				switch(ActionEffects.effect[Plan.actioneffectindex].condition)
					{
					case EFFECT_MOVETO:
						break;
					case EFFECT_UNLOCK:
						Door[ActionEffects.effect[Plan.actioneffectindex].value1].lockstatus=DOORUNLOCKED;
						break;
					case EFFECT_OPEN:
						Door[ActionEffects.effect[Plan.actioneffectindex].value1].doorstatus=DOOROPEN;						
						break;
					case EFFECT_PICKUP:
						Agent.gotkey=true;
						break;
					case EFFECT_PLAN:			
						break;
					case EFFECT_WAIT:			
						break;
					}
					
				// Update the Causal Links
				for (index=0;index<CausalLinks.numcausallinks;index++)
					{
					if (Plan.actioneffectindex == CausalLinks.actioneffect[index])
						{
						CausalLinks.executed[index] = true;

						// For any causal link found, update the UnmetPreconditions it meets	
						UnmetPreconditions.met[CausalLinks.unmetprecondition[index]] = true;
						
						// Update any Orderings that have this UnmetPreconditions as a predecessor.
						for (index2=0;index2<Orderings.numorderings;index2++)
							{
							if (Orderings.predecessor[index2] == CausalLinks.unmetprecondition[index])
								{
								Orderings.executed[index2] = true;
								}
							}					
						}
					}
						
				// Indicate that there is no current actioneffect selected
				Plan.actioneffectindex = -1;
				
				// Count the number of unmet preconditions.  If there aren't any then flag the agent's
				// goal has having been achieved.
				count = 0;
				for (index=0;index<UnmetPreconditions.numpreconditions;index++)
					{
					if (UnmetPreconditions.met[index]==false)
						{
						count++;
						}
					}
				if (count==0)
					{
					Plan.goalachieved=true;
					Route.numsteps = 0;
					
					// Output summary metric information
					MetricPlanSummary();

					}
				
				}
			}		
		}
	}