/************************************
 * Umass Amherst
 * CS377 Operating System
 * Lab2:
 * Author: Qi Li, Andrew Fagg
 * Date: 9/22/2002
 *
 * Class in this file: Abstract_Robot
 * Compile: javac Abstract_Robot.java
 * Run: n/a
 ***********************************/

import java.util.*;
import java.lang.*;


/***********************************
*  ClassName: Abstract_Robot
*  SuperClass: Thread
*  Description: Beginnings of the Robot Thread
*  Methods:
*    GetPosX() GetPosY(): get the robot position
*    SetPosX() SetPosY(): set the robot position
*    SetDist():           Set the Dist array
*    initDist():          Create the distance array.  Must be called
*                          before SetDist() is called.
*    getNofEat():         Return the number of edible goals
*
*  Methods required to be implemented:
*    run():               Top level thread code
*  
************************************/
abstract class Abstract_Robot extends Thread
{
    private int X;       //the robot's X Position 
    private int Y;       //the robot's Y Position 
    char cColor; //the Robot 's Color 
    int id;      //Identity of the robot
    Map_Data myGrid;  // Refer to the Map_Data in which the robot lives

    public void setColor(char inC){ cColor=inC ;} //set color to the robots
    int nMaxX,nMaxY; // the size of map, which is equal to nSizeX,nSizeY in Map 
    protected int Dist[][];  //The Distance Array of this Robot. The attribte is protected ,so 
                             // it can only be accessed by the class method and its subclass method.
    int nEatable;        // the number of eatable goals.
    boolean bDead=false; // False if the Robot is alive

    final int GetPosX(){return X;}  //get x
    final int GetPosY(){return Y;}  //get y
    final char GetColor(){return cColor;} //get color

    // Set the X-coordinate of the robot
    final void SetPosX(int newx)
    {
	// Do not remove this sleep
	try
	    {
		sleep(1);
	    }
	catch(InterruptedException e){};
        X = newx;
    };

    // Set the Y-coordinate of the robot
    final void SetPosY(int newy)
    {
	// Do not remove this sleep
	try
	    {
		sleep(1);
	    }
	catch(InterruptedException e){};
	Y = newy;

    };
    
    ///////////////////////////////////
    // Fill in the Dist[][] array.  One of:
    //  MAX_VALUE if an obstacle or the location of a dead robot
    //  0 if a goal that is edible for this robot (as long as it is not
    //        covered by a dead robot).
    //  -1 if a goal is not reachable for the robot
    //  # number of grid squares away from the closest edible goal location
    //
    //
    // ASSUMPTIONS:
    // - Dead Robots will stay dead (so no synchronization is necessary)
    // - Goals do not move (so reading goal state does not require synchronization)
    // 
    ///////////////////////////////
    public void SetDist()
    {
	// Set all the obstacles to MAX_VALUE in distance array; every other cell to -1.
	for (int i=0;i<nMaxX;i++)
	    for (int j=0;j<nMaxY;j++)
		{
                    if (myGrid.Grid[i][j]==1 )Dist[i][j]=Integer.MAX_VALUE; 
                    else Dist[i][j]=-1;
		}

	// Set edible goal locations to distance 0.
	for (int i=0;i<myGrid.nGoals;i++)
	    {
		if (!myGrid.Goals[i].isEaten)
		    if ((myGrid.Goals[i].cColor==cColor)||(myGrid.Goals[i].cColor=='k'))
			//Robots may only eat goals that are either black or their own color
			Dist[myGrid.Goals[i].GetPosX()][myGrid.Goals[i].GetPosY()]=0; 
	    };

	// Consider all "dead robots" as obstacles (note that they may cover existing goals)
	for (int i=0;i<myGrid.nRobots;i++)
	    if (myGrid.Robots[i].bDead)
		Dist[myGrid.Robots[i].X][myGrid.Robots[i].Y]=Integer.MAX_VALUE;

               
	boolean done=false;
	//int minVal=Integer.MAX_VALUE;

	// Fill in the distance for the remaining cells
	while (!done)
	    {
		// We know that we are done when we make an entire pass over
		//  the grid and do not change a distance value.

		done=true;
		// Loop over every cell
		for (int i=0;i<nMaxX;i++)
		    for (int j=0;j<nMaxY;j++)
			if (Dist[i][j]==-1)
			    {
				// Cell distance has not been set
				Dist[i][j]=fromNeighbor(i,j);
				if(Dist[i][j] != -1)
				    {
					// Has been now set: make sure we do another pass over
					//  the entire grid
					done=false;
				    };
			    }
		// Give processor to another thread if one is waiting
		yield();
	    }
    }   


    ///////////////////////////////////
    // Initialize the Distance array
    // Assumptions:
    //   nMaxX and nMaxY have already been set
    //
    ///////////////////////////////    
    public void initDist(){
	Dist=new int[nMaxX][nMaxY];        
    }

    //////////////////////////////////////////////////
    // Compute the distance from the minval of neigbor
    // the Method is called by SetDist
    //////////////////////////////////
    private int fromNeighbor(int i,int j)
    {
  	int minVal=Integer.MAX_VALUE;
  	if (i+1<nMaxX){
  		if ((Dist[i+1][j]!=-1)&&(Dist[i+1][j]<Integer.MAX_VALUE))
  			minVal=Dist[i+1][j];
  		
  	}
  	if (j+1<nMaxY){
  		if ((Dist[i][j+1]!=-1)&&(Dist[i][j+1]<Integer.MAX_VALUE))
  			if (minVal>Dist[i][j+1]) minVal=Dist[i][j+1];
  		
  	}
  	if (i-1>=0){
  		if ((Dist[i-1][j]!=-1)&&(Dist[i-1][j]<Integer.MAX_VALUE))
  			if (minVal>Dist[i-1][j]) minVal=Dist[i-1][j];
  		
  	}
  	if (j-1>=0){
  		if ((Dist[i][j-1]!=-1)&&(Dist[i][j-1]<Integer.MAX_VALUE))
  			if (minVal>Dist[i][j-1]) minVal=Dist[i][j-1];
  		
  	}
  	if (minVal==Integer.MAX_VALUE) return Dist[i][j];
  	else {
  		
  		return minVal+1;
	}
  }

    //////////////////////////////////////////////////////////////////////
    // Get the number of current edible goals by this color robot
    /////////////////////////////////////////  	
    public int getNofEat(){
  	int nCanEat=0;
  	for (int i=0;i<myGrid.nGoals;i++)
	    if (!myGrid.Goals[i].isEaten)
		if ((myGrid.Goals[i].cColor==cColor)||(myGrid.Goals[i].cColor=='k'))
		    nCanEat++;
        return nCanEat;
    }


    ////////////////////////////////////////////////////////////////////////////
    // Methods that must be implemented
    //

    abstract public void run();
    
};