import java.util.*;
import java.awt.*;

/**
   The Environment class is used to represent the environment for the
   simulation.  It provides the core of the simulation, which cycles
   through all of the Things in the simulation, asking each Thing to
   act out its life cycle.  In more detail, a simulation cycle consists of
   the following phases.
   <ol>
   <li>Checking for interactions:  every thing that is situated in the
   same cell is asked to possibly consume its neighbors.
   <li>Spawning:  every thing is asked to spawn children, if it wishes.
   <li>Movement:  every thing is asked to move, if it wishes to.
   <li>Screen update:  every thing is asked to display itself onto a
   graphics window.
   <li>
   </ol>
   @author Ben Dugan, Hal Perkins
   CSE 142 Summer 2001, Homework 6
*/
public class Environment {
  // constant
  private static int CELL_SIZE = 10;    // the environment is subdivided into
                                        // cells of this size for bookkeeping

  // instance variables
  private GWindow theWindow = new GWindow();            // drawing window
  private WorldMap things = new WorldMap(CELL_SIZE);    // collection of things
                                                        //    in this simulation

  // Internal interface used to implement operations like spawn and consumes.
  // Not used directly by Thing code - used by class Environment to process
  // each Thing every time the clock ticks.
  private interface CallBack {
    public void action(Thing t, ArrayList neighbors);
  }

  /** A WorldMap is a relatively efficient representation of the world.
      The world is chopped up into a number of cells so that interactions
      can be efficiently computed. */
  private class WorldMap {
    private HashMap cells = new HashMap();
    int cellSize = CELL_SIZE;

    /** Make a new worldmap with the given cellsize. */
    WorldMap(int cellSize) {
      this.cellSize = cellSize;
    }

    /** Answer the key (cell) for this thing. */
    String getKey(Thing t) {
      String pos = (t.getX() / cellSize) + ":" + (t.getY() / cellSize);
      return pos;
    }

    /** Answer the key (cell) for this location. */
    String getKey(int x, int y) {
      String pos = (x / cellSize) + ":" + (y / cellSize);
      return pos;
    }

    /** Answer the cell at this location. */
    public ArrayList getCell(int x, int y) {
      String key = getKey(x, y);
      return (ArrayList)cells.get(key);
    }

    /** Add a thing to the world map. */
    public void add(Thing t) {
      String pos = getKey(t);
      ArrayList cell = (ArrayList)cells.get(pos);
      if (cell == null) {
        ArrayList newCell = new ArrayList();
        newCell.add(t);
        cells.put(pos, newCell);
      }
      else {
        cell.add(t);
      }
    }
    
    /** Remove a thing from the world map. */
    public void remove(Thing t) {
      String pos = getKey(t);
      ArrayList cell = (ArrayList)cells.get(pos);
      if (cell != null) {
        cell.remove(t);
      }
    }
    
    /** Map this call back over the world. */
    public void map(CallBack cb) {
      Iterator cellIter = cells.values().iterator();
      while (cellIter.hasNext()) {
        ArrayList cell = (ArrayList)cellIter.next();
        for (int i=0; i<cell.size(); i++) {
          Thing t = (Thing)cell.get(i);
          cb.action(t, cell);
        }
      }
    }

    /** Dump statistics about the contents of the world map. */
    public void dumpStats() {
      final HashMap types = new HashMap();
      map(new CallBack() {
          public void action(Thing t, ArrayList cell) {
            Class c = t.getClass();
            Integer i = (Integer)types.get(c);
            if (i == null) {
              types.put(c, new Integer(1));
            }
            else {
              types.put(c, new Integer(i.intValue() + 1));
            }
          }
        });
      Iterator i = types.keySet().iterator();
      while (i.hasNext()) {
        Object o = i.next();
        System.out.println(o + " " + types.get(o));
      }
    }
  }     // end of WorldMap inner class

  // Methods of class Environment:

  /** Answer how many of the given kinds of things live in the cell at
      the given coordinates. */
  public int thingsHere(String kindOfThing, int x, int y) {
    int count = 0;
    ArrayList cell = this.things.getCell(x, y);
    if (cell != null) {
      Iterator i = cell.iterator();
      while (i.hasNext()) {
        Thing t = (Thing)i.next();
        if (t.kindOfThing().equals(kindOfThing))
          count++;
      }
    }
    return count;
  }

  /** Answer how many of the given kinds of things live in the cell to 
      the north of the given coordinates. */
  public int thingsNorth(String kindOfThing, int x, int y) {
    int northY = ((y / CELL_SIZE) - 1) * CELL_SIZE;
    return this.thingsHere(kindOfThing, x, northY);
  }

  /** Answer how many of the given kinds of things live in the cell to 
      the south of the given coordinates. */
  public int thingsSouth(String kindOfThing, int x, int y) {
    int southY = ((y / CELL_SIZE) + 1) * CELL_SIZE;
    return this.thingsHere(kindOfThing, x, southY);
  }

  /** Answer how many of the given kinds of things live in the cell to 
      the east of the given coordinates. */
  public int thingsEast(String kindOfThing, int x, int y) {
    int eastX = ((x / CELL_SIZE) + 1) * CELL_SIZE;
    return this.thingsHere(kindOfThing, eastX, y);
  }

  /** Answer how many of the given kinds of things live in the cell to 
      the west of the given coordinates. */
  public int thingsWest(String kindOfThing, int x, int y) {
    int westX = ((x / CELL_SIZE) - 1) * CELL_SIZE;
    return this.thingsHere(kindOfThing, westX, y);
  }

  /** Ask each thing in the simulation to move. */
  public void move() {
    // Give them each a turn
    things.map(new CallBack() {
        public void action(Thing t, ArrayList cell) {
          t.move();
        }
      });
  }

  /** Ask each thing in the simulation to spawn. */
  public void spawn() {
    final ArrayList newThings = new ArrayList();
    // Give them each a turn
    things.map(new CallBack() {
        public void action(Thing t, ArrayList cell) {
          t.spawn(newThings);
        }
      });

    Iterator e = newThings.iterator();
    while (e.hasNext()) {
      things.add((Thing)e.next());
    }
  }

  /** Check for collisions.  For each thing in the same cell, we ask
      it if it consumes each other thing in the same cell.  If so, the
      other thing is removed from the simulation.  */
  public void checkCollisions() {
    final Set deadGuys = new HashSet();

    // Check for collisions
    things.map(new CallBack() {
        public void action(Thing t, ArrayList cell) {
          for (int i=0; i<cell.size(); i++) {
            Thing other = (Thing)cell.get(i);
            if (t != other && t.consumes(other.kindOfThing())) {
              deadGuys.add(other);
              t.consume(other.kindOfThing());
            }
          }
        }
      });

    // Remove the dead guys.
    Iterator i = deadGuys.iterator();
    while (i.hasNext()) {
      things.remove((Thing)i.next());
    }

    // Now resort the collection:
    WorldMap old = things;
    things = new WorldMap(CELL_SIZE);
    old.map(new CallBack() {
        public void action(Thing t, ArrayList cell) {
          things.add(t);
        }
      });
  }

  /** Ask each thing in the simulation to display itself. */
  public void updateScreen() {
    // Give them each a turn
    things.map(new CallBack() {
        public void action(Thing t, ArrayList cell) {
          t.display(theWindow);
        }
      });
    theWindow.repaint();
  }

  /** Sleep the simulation for a while. */
  public void sleep(int msecs) {
    try {
      Thread.sleep(msecs);             
    }
    catch (Exception e) {}
  }

  /** Add the given thing to the environment. */
  public void add(Thing t) {
    things.add(t);
  }

  /** Create a new simulation. */
  public void go() {
    things = new WorldMap(CELL_SIZE);

    // Add a tanker to the world
    //Tanker tanker = new Tanker(2, 0, 200);
    //this.add(tanker);

    // seed the world with 200 algaes...
    Random rand = new Random();
    for (int i=0; i<200; i++) {
      this.add(new Algae(rand.nextInt(400), rand.nextInt(400)));
    }

    // seed the world with 50 fish
    for (int i=0; i<50; i++) {
      this.add(new Fish(rand.nextInt(400), rand.nextInt(400)));
    }

    // Now run the simulation for 400 cycles.
    int turns = 0;
    while (turns <= 400) {
      this.updateScreen();                    // update the screen
      this.checkCollisions();                 // check for interactions
      this.spawn();                           // spawning
      this.move();                            // movement
      if (turns % 50 == 0) {                 // sometimes dump stats.
        System.out.println(turns + " ----------------------------------");
        this.things.dumpStats();
      }
      turns++;
      this.sleep(50);
    }
  }
    
  /** Create an environment, seed it with Things and run the simulation. */
  public void startSimulation() {
    Environment env = new Environment();
    env.go();
  }
}