// **************************************************************
// *                                                            *
// *  Spheres -- GridRout.cpp                                   *
// *                                                            *
// *  (C) Christian Scheideler, 2003                            *
// *                                                            *
// **************************************************************

// GridRout.cpp routes packets acc. to problem 12 in an arbitrary nxn-grid

// Special definitions and operations provided by Spheres.h:
//
// - Sphere: class that enables non-blocking method invocations (NMI).
//      To ensure the correct execution of NMIs, every method in a class
//      derived from Sphere that is to be called by NMI has to have the form
//
//         void MethodName(usertype *plist)
//
//      where plist is a pointer to any kind of usertype.
//
// - void Send(SpherePtr, SphereObj::Method, ParList): 
//      This requests to call the method SphereObj::Method in the user object
//      referenced by SpherePtr using the parameter list referenced by ParList.
//
// - void Simulate(Time): 
//      This runs a simulation for Time many rounds.

// The Spheres.h class provides an environment for the simulation of 
// concurrent data structures, where concurrent executions are done at the
// level of method invocations (i.e. each method invocation completes before
// another method is invoked). To avoid inconsistencies in the data structure,
// some general rules have to be obeyed:
//
// - A method may not have any side-effects other than modifying the
//   data inside the object.
//
// - A method must be total, meaning that it is well-defined for
//   EVERY legal state of the object.


#include <stdlib.h>
#include <iostream.h>

#include "Spheres.h"


// parameter list for Node::Sync method
class SPList
{
public:
  int ID;     // origin of sync message
  int round;  // round number of sync
  int dest;   // destination of packet piggybacked by sync message
  SPList *next;  // pointer to next object (for buffering)

  SPList(int i, int r, int d)
  {
    ID = i;
    round = r;
    dest = d;
    next = NULL;
  }
};


class Node: public Sphere
{
private:
  int ID;           // own ID
  int degree;       // own degree
  int length;       // side length of grid
  int round;        // current round
  SPList **current; // neighbor syncs for current round
  SPList **next;    // neighbor syncs for next round
  Node **neighbor;  // pointers to neighbors
  int *neighID;     // IDs of neighbors
  SPList **buffer;  // buffer for packets (works like stack)

public:
    Node(int u, int l)
    {
      ID = u;
      length = l;
    }

    void Connect(int d, Node** np, int *IDs)
    {
      int v;

      degree = d;
      neighbor = np;
      neighID = IDs;

      // initialize sync variables and buffers
      round = 1;
      current = new (SPList *)[degree];
      next = new (SPList *)[degree];
      buffer = new (SPList *)[degree];
      for (v=0; v<degree; v++)
      {
        current[v] = NULL;
        next[v] = NULL;
        buffer[v] = NULL;
      }
    }


    void XYRoute(SPList *p)
    {
      int x, n, v;

      // compute next node n for packet p
      if (ID == p->dest)
        delete p;  // packet reached destination
      else
      {
        x = (ID % length) - (p->dest % length); // difference in x-koord
        if (x<0) n=ID+1;  // move right
        if (x>0) n=ID-1;  // move left
        if (x==0)
        {
          if (ID > p->dest) n=ID-length;  // move down
                       else n=ID+length;  // move up
        }
        for (v=0; v<degree; v++)
          if (n==neighID[v]) // next node found
          {
            p->next = buffer[v]; // move packet to buffer
            buffer[v] = p;
          }
      }
    }


    void printXY(int v)
    {
      cout << "(" << v%length << "," << (v-(v%length))/length << ")";
    }

    void Sync(SPList *p)
    {
      int v, complete;
      SPList *lp;

      if (p->dest>=0)
      {
        printXY(ID);
        cout << ": received in round " << p->round << " from ";
        printXY(p->ID);
        cout << " packet to destination ";
        printXY(p->dest);
        cout << "\n";
      }

      // locate neighbor in list
      v=0;
      while (neighID[v] != p->ID) v++;

      // sync
      if (p->round == round)
      {
        current[v] = p;
        complete = 1;
        for (v=0; v<degree; v++)
          if (current[v]==NULL) complete = 0;

        if (complete) // received syncs from all neighbors?
        {
          // go to next round
          // printXY(ID);
          // cout << ": all syncs for round " << round << " received \n";
          round++;
          // move packets from current to buffer
          for (v=0; v<degree; v++)
          {
            if (current[v]->dest<0)
              delete current[v];  // only sync packet
            else
              XYRoute(current[v]);
          }

          // reset sync indicators
          for (v=0; v<degree; v++)
          {
            current[v] = next[v];
            next[v] = NULL;
          }
          // send new sync messages to neighbors
          for (v=0; v<degree; v++)
          {
            if (buffer[v] == NULL) // buffer to v empty?
              lp = new SPList(ID, round, -1);  // just sync packet
            else
            {
              lp = buffer[v];
              buffer[v] = buffer[v]->next;
              // update ID and round and reset next pointer
              lp->ID = ID;
              lp->round = round;
              lp->next = NULL;
            }
            Send(neighbor[v], Node::Sync, lp);
          }
        }
      }
      else next[v] = p;
    }

   void Start(void *p)
   {
     int d, v;
     SPList *lp;

     // put initial packets in buffers
     d = ID+length-2*(ID % length)-1; // (n-x-1,y)
     lp = new SPList(ID, round, d);
     XYRoute(lp);
     d = length*length-ID-1;          // (n-x-1, n-y-1)
     lp = new SPList(ID, round, d);
     XYRoute(lp);

     // send syncs (plus packets) to all neighbors
     for (v=0; v<degree; v++)
     {
       if (buffer[v] == NULL) // buffer to v empty?
         lp = new SPList(ID, round, -1);  // just sync packet
       else
       {
         lp = buffer[v];
         buffer[v] = buffer[v]->next;
         lp->next = NULL;
       }
       Send(neighbor[v], Node::Sync, lp);
     }
   }

};


void GridSync()
{
  int n;                      // side length of grid
  Node **List;                // list of all nodes
  int x,y;                    // node (x,y)
  int left, right, up, down;  // all possible edges
  int deg;                    // degree
  Node **NL;                  // neighbor pointers
  int *NID;                   // neighbor IDs
  int v;

  // input n
  cout << "Side length of grid: ";
  cin >> n;

  // generate set of node objects
  List = new (Node *)[n*n];
  for (v=0; v<n*n; v++)
        List[v] = new Node(v,n);

  // connect nodes to nxn-grid
  for (x=0; x<n; x++)    // x-dimension
  {
    for (y=0; y<n; y++)  // y-dimension
    {
      deg = 4;
      left = right = up = down = 1;  // all edges active
      if (x==0) {left = 0; deg--;}
      if (x==n-1) {right = 0; deg--;}
      if (y==0) {down = 0; deg--;}
      if (y==n-1) {up = 0; deg--;}

      NL = new (Node *)[deg];   // create list of neighbor pointers
      NID = new int[deg];       // create list of neighbor IDs
      v = 0;
      if (left)
        { NL[v] = List[y*n+x-1]; NID[v] = y*n+x-1; v++; }
      if (right)
        { NL[v] = List[y*n+x+1]; NID[v] = y*n+x+1; v++; }
      if (down)
        { NL[v] = List[(y-1)*n+x]; NID[v] = (y-1)*n+x; v++; }
      if (up)
        { NL[v] = List[(y+1)*n+x]; NID[v] = (y+1)*n+x; }

      List[y*n+x]->Connect(deg, NL, NID);
    }
  }

  // generate requests to call Node::Start in every node of the list
  for (v=0; v<n*n; v++)
  {
    Send(List[v], Node::Start, NULL);
  }

  // run the simulation for 10 rounds
  Simulate(30);
}


void main()
{
  int i;

  GridSync();

  cin >> i; // just to see the output
}