//Tasha Wallage
//Period 7

   import java.util.HashMap;
   import java.util.ArrayList;
   import java.util.Iterator;
    public class World
   {
      private HashMap<Location, Species> specLocs;
      private HashMap<Integer, Integer> defVals;
      private HashMap<Integer, Integer> aggVals;
      private double defAve, aggAve; 	
      private int counter, numFood, numOrg, numPred, worldSize;
   
       public World()
      {
         defAve = aggAve = 0.0;
         counter =0;
         specLocs = new HashMap<Location, Species>();
      }  
      //returns the HashMap that contains all the Species in the World
       public HashMap<Location, Species> getHMS()
      {
         return specLocs;
      }
      public int getF()
      {
      	return numFood;
      }
      public int getO()
      {
      	return numOrg;
      }
      public int getP()
      {
      	return numPred;
      }
      //adds a Species to the World and updates population count
       public void add(Species s)
      {
         String t = s.getName();
         //System.out.println(t);
	 if(t.equals("Food"))
            numFood++;
         else if(t.equals("Organism"))
            numOrg++;
         else if(t.equals("Predator"))
            numPred++;
         else
            System.out.println("Problem adding: **"+t+"**");
         specLocs.put(s.getLoc(), s);
      }
      //returns the average aggresion values of the Predators in the World
       public double aggAve()
      {
      	if(aggVals==null)
		return 0.0;
         double sum = 0;
         double ave = 0;
         Iterator it = aggVals.keySet().iterator();
         while(it.hasNext())
         {
            int d = Integer.parseInt((it.next().toString()));
            int t = aggVals.get(d);
            sum+=t;
            ave+=d*t;
         }
         double temp = ave/sum;
         if(temp > 0 && temp!=aggAve){
            System.out.println("**********AGGRESSION VALUE CHANGE*********");
            System.out.println("Iteration: "+counter);
            System.out.println("Average AGGRESSION: "+(ave/sum));
            aggAve = temp;
         }
	 return temp;
      }
      //returns the average defense values of the Organisms in the World
       public double defAve()
      {
	 if(defVals == null)
	 	return 0.0;
	 double sum = 0;
         double ave = 0;
         Iterator it = defVals.keySet().iterator();
         while(it.hasNext())
         {
            int d = Integer.parseInt((it.next().toString()));
            int t = defVals.get(d);
            //System.out.println(d+": "+t);
            sum+=t;
            ave+=d*t;
         }
         double temp = ave/sum;
         if(temp>0 && temp!=defAve){
            System.out.println("**********DEFENSE VALUE CHANGE*********");
            System.out.println("Iteration: "+counter);
            System.out.println("Average Defense: "+(ave/sum));
            defAve = temp;
         }
	 return temp;      
      }
      //if the HashMap contains a certain Location, it will return that Location
       public Location contains(String name, Location loc)
       {
       		Iterator it = specLocs.keySet().iterator();
		while(it.hasNext())
		{
			Location l = (Location) it.next();
			if(l.equals(loc) && specLocs.get(l).getName().equals(name))
				return l;
		}
		return null;
	}       
	//calls act on all of the Species and keeps track of the number of iterations (time)
       public void step()
      {	
         counter++;
         Iterator it = specLocs.keySet().iterator();
         ArrayList<Species> a = new ArrayList<Species>();
         defVals = new HashMap<Integer, Integer>();
         aggVals = new HashMap<Integer, Integer>();
      	
         while(it.hasNext()){
            Location temp = (Location) it.next();
            Species s = (Species)specLocs.get(temp);
            a.add(s);
            String t = s.getClass().getName();
            if(t.equals("Organism"))
            {
               int def = ((Organism)s).getDefense();
               if(defVals.containsKey(def)){
                  int w = defVals.get(def);
                  defVals.put(def, w+1);
               }
               else
                  defVals.put(def, 1);
            }
            else if(t.equals("Predator"))
            {	
               int agg = ((Predator)s).getAggression();
               if(aggVals.containsKey(agg)){
                  int q = aggVals.get(agg);
                  aggVals.put(agg, q+1);
               }
               else
                  aggVals.put(agg, 1);
            }
         }         
         
         aggAve();     
         defAve(); 	
        
         for(int k=0; k<a.size(); k++){
            Species s = a.get(k);
	    int spd = s.getSpeed();
	    for(int x=0;x<spd; x++)
	    	s.act();
	}
      		
      }
      //called by Organisms or Predators when they are consuming a Food or Organism, respectively
      //the World can then remove the appropriate Species that has been eaten and transfer the energy
       public boolean consume(Species prey, Species s1)
      {
         ArrayList<Location> al = getNeighbors(s1.getLoc());
         for(int k=0; k<al.size(); k++){
            //System.out.println(al.get(k));
            Location x = prey.getLoc();
            {
               Species s2 = specLocs.get(x);   
               if(s1.getName().equals("Organism") && s2.getName().equals("Food")){
                  remove(s2);
                  numFood--;
                  return true;
               }
               else if(s1.getName().equals("Predator") && s2.getName().equals("Organism")){
                  remove(s2);
                  numOrg--;
                  return true;
               }
               else
                  System.out.println(s1.getName()+" cannot consume "+s2.getName());
            }
         }
         return false;
      }
      //returns the Species specified closest to the specified Location
       public Species getClosest(String s, Location loc)
      {
         double minDist = 10000;
         double dist = 0.0;
         Location retLoc = null;
         Location tempLoc = null;
      
         Iterator it = specLocs.keySet().iterator();
         while(it.hasNext()){
            tempLoc = (Location)it.next();
            if(specLocs.get(tempLoc).getName().equals(s)){
               dist = dist(loc, tempLoc);
               if(dist < minDist)
               {
                  minDist = dist;
                  retLoc = tempLoc;
               }
            }
         }
         return specLocs.get(retLoc);
      }
      //returns the distance from one Location to another
       public double dist(Location loc1, Location loc2)
      {
         double x1 = (double)loc1.getX();
         double y1 = (double)loc1.getY();
         double x2 = (double)loc2.getX();
         double y2 = (double)loc2.getY();
      
         double dist = (double)(Math.pow((Math.pow((x1-x2), 2) + Math.pow((y1-y2), 2)), 0.5));
         return dist;
      }
      //returns a spot that is unoccupied near the given Location
       public Location getVacantSpot(Location loc)
      {
         ArrayList<Location> al = getNeighbors(loc);
         for(int k=0; k<al.size(); k++){
	    Location temp = al.get(k);
            if(specLocs.containsKey(temp) || !inBounds(temp))
               al.remove(k);  
         }
         return al.get((int)(Math.random()*al.size()));
      }
      public boolean inBounds(Location loc)
      {
      	int x = loc.getX();
	int y = loc.getY();
	if(x < 0 || y < 0 || x > worldSize || y > worldSize)
		return false;
	return true;
      }
      //returns all the neighbors of a given Location
       public ArrayList<Location> getNeighbors(Location loc)
      {
         int x = loc.getX();
         int x1 = x+1;
         int x2 = x-11;
      
         int y = loc.getY();
         int y1 = y+1;
         int y2 = y-1;
      
         ArrayList<Location> list = new ArrayList<Location>();
         Location a = new Location(x2, y2);
         list.add(a);
         Location b = new Location(x, y2);
         list.add(b);
         Location c = new Location(x1, y2);
         list.add(c);
         Location d = new Location(x2, y);
         list.add(d);
         Location e = new Location(x1, y);
         list.add(e);
         Location f = new Location(x2, y1);
         list.add(f);
         Location g = new Location(x, y1);
         list.add(g);
         Location h = new Location(x1, y1);
         list.add(h);
      
         return list;
      }
      //removes the given Species and updates the population count
       public boolean isNum(String s)
       {
       		if(s==null || s=="" || s=="NaN")
			return false;
		for(int k=0; k<s.length(); k++)
			if(!"0123456789.".contains(s))
				return false;
		return true;
	}
       public void remove(Species s)
      {
         //System.out.println(s);
	 String t = s.getName();
         if(t.equals("Food"))
            numFood--;
         else if(t.equals("Organism"))
            numOrg--;
         else if(t.equals("Predator"))
            numPred--;
         else
            System.out.println("Problem removing: "+t);
         specLocs.remove(s.getLoc());
      }
      public void setLimit(int x)
      {
      	worldSize = x;
      }
      public int getLimit()
      {
      	return worldSize;
      }
       public String toString()
      {
         return "World"+"F: "+numFood+" O: "+numOrg+" P: "+numPred;
      }
   }