package agent.four;

public class Main {
  public static void main (String[] args) {
    World w = WorldF.instance(100,100);
    int i = 0;
    while (i<20) {
      try {
        new Tiger
        (Integer.toString(i), Util.random(w.maxx()), Util.random(w.maxy()));
        i++;
      } catch (SpaceOccupiedException e) {
      }
    }
    w.run(1000);
  }
}

class Util {
  private Util() {}
  private final static long SEED = 2497;
  private final static java.util.Random r = new java.util.Random(SEED);
  static int random(int n) { return r.nextInt(n); }
  static boolean randomBoolean() { return r.nextBoolean(); }
}

interface World extends TimeServer {
  public int maxx();
  public int maxy();
  public Visible get(int i, int j);
  public boolean set(int i, int j, Visible a);
}

class WorldF {
  private static World W;
  public static World instance(int maxx, int maxy) {
    if (W != null)
      throw new IllegalStateException();
    W = new WorldObj(maxx, maxy);
    return W;
  }
  public static World instance() {
    if (W == null)
      throw new IllegalStateException();
    return W;
  }
}

class WorldObj implements World {
  private final int maxx;
  private final int maxy;
  private final TimeServer time;
  private final Visible[][] space;

  WorldObj(int maxx, int maxy) {
    this.maxx = maxx;
    this.maxy = maxy;
    time = new TimeServerLinked();
    space = new Visible[maxx][maxy];
    for (int x = 0; x < maxx; x++ )
      for (int y = 0; y < maxy; y++ )
        space[x][y] = NullVisible.instance;
  }
  public int maxx() { return maxx; }
  public int maxy() { return maxy; }
  public Visible get(int x, int y) {
    return space[(x+maxx)%maxx][(y+maxy)%maxy];
  }
  public boolean set(int x, int y, Visible a){
    if (a == null) {
      a = NullVisible.instance;
    } else if (get(x,y) != NullVisible.instance) {
      return false;
    }
    space[(x+maxx)%maxx][(y+maxy)%maxy] = a;
    return true;
  }
  public long currentTime()              { return time.currentTime(); }
  public void enqueue(long t, Agent a)   { time.enqueue(t,a); }
  public void run(int d)                 { time.run(d); }
}

interface Visible {
  public final static int NULL = 0;
  public final static int TIGER = 1;
  public int type();
}

class NullVisible implements Visible {
  private NullVisible() {}
  public final static Visible instance = new NullVisible();
  public int type() { return Visible.NULL; }
  public String toString() { return "Null"; }
}

class SpaceOccupiedException extends RuntimeException {
  private static final long serialVersionUID = 2008L;
};

class Tiger implements Agent, Visible {
  private String name;
  private int x;
  private int y;
  private World w = WorldF.instance();

  public Tiger(String name, int x, int y)
      throws SpaceOccupiedException
  {
    this.name = name;
    if (!w.set(x,y,this))
      throw new SpaceOccupiedException();
    this.x = x;
    this.y = y;
    w.enqueue(1+w.currentTime(), this);
  }

  public String toString() { return name + "@(" + x + "," + y + ")"; }

  public int type() { return Visible.TIGER; }
  public void check() {
    checkAjacent();
  }
  public void run() {
    //System.out.print(this + " moves to ");
    moveRandom();
    //System.out.println(this);
    w.enqueue(10+w.currentTime(), this);
  }

  private void checkAjacent() {
    for (int i=-1; i<=1; i++) {
      for (int j=-1; j<=1; j++) {
        if (i==0 && j==0)
          continue;
        if (w.get(x+i,y+j).type() == Visible.TIGER)
          System.out.println(this + " roars at " + w.get(x+i,y+j) + " at " + w.currentTime());
      }
    }
  }
  private void moveRandom() {
    w.set(x,y,null);
    int xNew, yNew;
    do {
      xNew = (w.maxx() + this.x -1 + Util.random(2)) % w.maxx();
      yNew = (w.maxy() + this.y -1 + Util.random(2)) % w.maxy();
      //System.out.println("Trying (" + x + "," + y + ")");
    } while (!w.set(xNew,yNew,this));
    this.x = xNew; this.y = yNew;
  }
}