class Pedestrian/**********************************************************************/
{
  int x;
  int y;
  int xOld;
  int yOld;
  ArrayList pedestrianList;
  ArrayList doorList;
  DynamicField    dField;
  DynamicField    privateDField;
  ObstacleField   oField;
  PedestrianField pField;
  StaticField     sField;
  float weightD; 
  float weightE;
  float weightS;
  
  
/************constructor************************************/
  
  Pedestrian(int x, int y, 
             ArrayList pedestrianList,
             ArrayList doorList,
             DynamicField dyField, 
             ObstacleField obField, 
             PedestrianField peField, 
             StaticField stField,
             float weightD,float weightE, float weightS
            )
  {
    initNeighborhood();
    setPosition(x,y); 
    setPedestrianList(pedestrianList);
    setDoorList(doorList);
    setDynamicField(dyField);
    setObstacleField(obField);
    setPedestrianField(peField);
    setStaticField(stField);
    this.weightD=weightD;
    this.weightE=weightE;
    this.weightS=weightS;
    privateDField= new DynamicField(x,y);
  } 
  
 /*******************methods*************************************************************    
 boolean isOnDoor()
 void die()
 void move() 
 float calculateProbabilities()
 void setPedestrianList(ArrayList pedestrianList)
 void setDoorList(ArrayList doorList)
 void setDynamicField(DynamicField dynField)
 void setObstacleField(ObstacleField obsField)
 void setPedestrianField(PedestrianField pedField)
 void setStaticField(StaticField staField)
 void display(int cellSize,int windowPositionColumn,int windowPositionLine)
 void setPosition( int x, int y)
 void setX(int x)
 void setY(int y)
 int getX ( )
 int getY ( )
 void printlnProbability(float probability[])
 
 void initNeighborhood()
  
 */
  
  boolean isOnDoor()/****************************************/
  {
    for (int j=0; j<doorList.size(); j++)
      {
        Door newDoor= (Door) doorList.get(j);
        if(this.getX()==newDoor.getX() && this.getY()==newDoor.getY() )
        {
          return true;
        }
      }
    return false;
  }
  
  void die()/************************************************/
  {
    pField.removePed(this.getX(), this.getY());
    pedestrianList.remove(this );
  }
  
  
  void move(float diffusion)/******************************/
  {
    float[] cumulativeProb = calculateProbabilities();            //call method calculateProbabilities()
    float rand= random(cumulativeProb[5]); //generate random number between 0 and sum of probabilities
    
    for(int i=0; i<neigh.length; i++)        //move according to probabilities
    {
      if(rand>=cumulativeProb[i] && rand<cumulativeProb[i+1])
      {
        xOld=x;
        yOld=y;
        x = x + neigh[i][0];
        y = y + neigh[i][1];
        pField.placePed(x,y);
        if((xOld != x) || (yOld != y)) //increase dynamic field only when not staying on old cell
        {
          dField.increaseValue(xOld,yOld);
          privateDField.increaseValue(xOld,yOld);
        }
        //if (frameCount % 4 == 0 ) privateDField.diffuse(diffusion);
      }
    }
  }
  
  
  
  float[] calculateProbabilities()/*************************/
  {
    float probability[] = new float [neigh.length+1];
    float cumulativeProb[] = new float[neigh.length+1];
    float[] neighValue = new float[neigh.length];
    float[] neighProbability = new float[neigh.length];
    int maxNeighbor=int(random(1,5));
    float maxValue;
    int minNeighbor=int(random(1,5));
    float minValue;
    pField.removePed(x,y);                                 //change PedestrianField to zero for current cell
        
    for (int k=0;k<neigh.length;k++) 
    {
      int neighcolumnPos   = x + neigh[k][0];
      int neighlinePos     = y + neigh[k][1];
      neighValue[k]=sField.getValue(neighcolumnPos,neighlinePos); 
    }
    
    for (int k=0;k<neigh.length;k++)                       //iterating over neighbors to get probabilities for neighbors of pedestrian
    {
        neighProbability[k]=3.5; 
        
        if (neighValue[k]>neighValue[maxNeighbor])
        {
        maxNeighbor=k;
        maxValue=neighValue[k];
        }
        if (neighValue[k]<neighValue[minNeighbor])
        {
        minNeighbor=k;
        minValue=neighValue[k];
        }
    }
    
       neighProbability[0]=3;
       neighProbability[maxNeighbor]=4.6;
       neighProbability[minNeighbor]=2.5;
       //println("prob"+neighProbability[0]+" "+neighProbability[1]+" "+neighProbability[2]+" "+neighProbability[3]+" "+neighProbability[4]);  
       for(int k=0;k<neigh.length;k++)                       //iterating over neighbors to get probabilities for neighbors of pedestrian
        {
          int neighcolumnPos   = x + neigh[k][0];
          int neighlinePos     = y + neigh[k][1];
          
          probability[k+1] =             (oField.getValue(neighcolumnPos,neighlinePos))
                            *exp(weightD*(dField.getValue(neighcolumnPos,neighlinePos)-privateDField.getValue(neighcolumnPos,neighlinePos)))
                            *            (pField.getValue(neighcolumnPos,neighlinePos))
                            *exp(weightS*neighProbability[k])
                            *exp(weightE*eField.getValue(neighcolumnPos,neighlinePos));
          //println((oField.getValue(neighcolumnPos,neighlinePos)));
          //println (weightD*(dField.getValue(neighcolumnPos,neighlinePos)));//-privateDField.getValue(neighcolumnPos,neighlinePos)));
          //println ((pField.getValue(neighcolumnPos,neighlinePos)));
          //println(probability[k+1]);
        }
        cumulativeProb[5] = probability[1] + probability[2] + probability[3] + probability[4] + probability[5];
        for (int k=0;k<neigh.length;k++)                       //iterating over neighbors to get normalized probabilities for neighbors of pedestrian
        {
        probability[k+1]  = (probability[k+1])/cumulativeProb[5];
        }
        //printlnProbability(probability);
        
        cumulativeProb[0] = 0;
        cumulativeProb[1] = probability[1];
        cumulativeProb[2] = probability[1] + probability[2];
        cumulativeProb[3] = probability[1] + probability[2] + probability[3];
        cumulativeProb[4] = probability[1] + probability[2] + probability[3] + probability[4];
        cumulativeProb[5] = probability[1] + probability[2] + probability[3] + probability[4] + probability[5];
        return cumulativeProb;
   }    
        
  void setPedestrianList(ArrayList pedestrianList)/***********************************/
  {
    this.pedestrianList= pedestrianList;
  }
  
  void setDoorList(ArrayList doorList)/***********************************************/
  {
    this.doorList= doorList;
  }
  
  void setDynamicField(DynamicField dynField)/***************************************/
  {
    dField= dynField;
  }
  
  void setObstacleField(ObstacleField obsField)/************************************/
  {
    oField= obsField;
  }
  
  void setPedestrianField(PedestrianField pedField)/*********************************/
  {
    pField= pedField;
  }
  
  void setStaticField(StaticField staField)/*****************************************/
  {
    sField= staField;
  }

  
  void display(int cellSize,int windowPositionColumn,int windowPositionLine)/********/
  {
    fill (255,0, 0);
    noStroke();
    rect(x*cellSize+windowPositionColumn,y*cellSize+windowPositionLine, cellSize, cellSize);
  }
  
  void setPosition( int x, int y)/***************************************************/
  {
    setX (x);
    setY (y);
  }
  
  void setX(int x) /********************************************/
  {
    this.x=x;
  }
  
  void setY(int y)/*********************************************/
  {
    this.y=y;
  }
  
  int getX ( )/************************************************/
  {
    return this.x;
  }
  
  int getY ( )/************************************************/
  {
    return this.y;
  }
  
  
  void printlnProbability(float probability[])/***************/
 {
   NumberFormat nf = NumberFormat.getNumberInstance();
   nf.setMaximumFractionDigits(5);
   nf.setMinimumFractionDigits(5);
   
   for(int i=0; i<=neigh.length; i++)
   {
     print(  nf.format( probability[i] )  +"  ");
   }
   println();
 }
    
  //Define the von Neumann neighborhood, i.e. the 4 nearest cells*************************************
  //rename in final static int [][]NEIGH
  int[][]neigh = new int [5][2]; //i and j for 4 closest cells and middle
  
  void initNeighborhood()
  {
  neigh[0][0]= 0;   //           3                    0,1
  neigh[0][1]= 0;   //        2  1  4           -1,0  0,0  1,0
                    //           5                   0,-1
  neigh[1][0]=-1;   
  neigh[1][1]= 0;
  
  neigh[2][0]= 0;
  neigh[2][1]= 1;
  
  neigh[3][0]= 1;
  neigh[3][1]= 0;
  
  neigh[4][0]= 0;
  neigh[4][1]=-1;
  }
  
  
}