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

// Grid.cpp generates an arbitrary nxn-grid and sends sync messages in it

// 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

	SPList(int i, int r)
	{
      ID = i;
	  round = r;
	}
};


class Node: public Sphere
{
private:
    int ID;           // own ID
    int degree;       // own degree
    int round;        // current round
    int *current;     // neighbor syncs for current round
    int *next;        // neighbor syncs for next round
    Node **neighbor;  // pointers to neighbors
    int *neighID;     // IDs of neighbors

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

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

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

      // initialize sync variables
      round = 1;
      current = new int[degree];
      next = new int[degree];
      for (v=0; v<degree; v++)
      {
        current[v] = 0;
        next[v] = 0;
      }
    }

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

      cout << ID << ": received sync(" << p->round << ") from " << p->ID << "\n";

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

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

        if (complete) // received syncs from all neighbors?
        {
          // go to next round
          cout << ID << ": all syncs for round " << round << " received \n";
          round++;
          // reset sync indicators
          for (v=0; v<degree; v++)
          {
            current[v] = next[v];
            next[v] = 0;
          }
          // send new sync messages to neighbors
          for (v=0; v<degree; v++)
          {
            lp = new SPList(ID, round);
            Send(neighbor[v], Node::Sync, lp);
          }
        }
      }
      else next[v] = 1;
      delete p;
    }

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

     // send syncs to all neighbors
     for (v=0; v<degree; v++)
     {
       lp = new SPList(ID, round);
       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);

  // 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(10);
}


void main()
{
  int i;

  GridSync();

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