/** SquareRing.cpp - define, load and test a ring of data
 */
#include <string>	// for printf etc.
//#include <iostream>	// for cout etc.

/* define static data per linuxquestions 'amazing circle' thread */
typedef char rType;
#define RingSize 32
rType LinearData[RingSize] = {1, 8, 28, 21, 4, 32, 17, 19, 30, 6, 3, 13, 12, 24, 25, 11, 5, 31, 18, 7, 29, 20, 16, 9, 27, 22, 14, 2, 23, 26, 10, 15};
#define SquareCount 6
rType Squares[SquareCount] = {4, 9, 16, 25, 36, 49};

/** Ring class: define and process Ring (circular array) data type */
class Ring {
public:
 int rSize;
 int rHead;			// arbitrary start point in ring
 bool rClockwise;		// true=Clockwise, false=Counter-clockwise
 rType rElement[RingSize];	// store ring as linear array

bool rInit() {			// do almost nothing (future: alloc dynamically)
 srand(time(0));
 Randomize();
 return true;
 };

void Randomize() {
 rHead = rand()%RingSize;	// randomize rHead offset
 rClockwise = rand()%2;		// and direction of flow
 return;
 };

bool LoadRingData() {		// load ring from static array
 int c0, c1;
 rSize = 0;
 c1 = rHead;			// starting from rHead
 for (c0 = 0; c0 < RingSize; c0++) {
  rElement[c1] = LinearData[c0];
  c1 = AdvanceIndex(c1);
  rSize++;
  }
 return true;
 };

int AdvanceIndex(int Index) {
// Step index clockwise or counter, wrapping as needed
 if (rClockwise) {		// clockwise (normal order)
  Index++;
  if (Index == RingSize)
   Index = 0;			// wrap to 0 in linear array
  }
 else {				// counter-clockwise (descending order)
  if (!Index)
   Index = RingSize;		// wrap to end of linear array
  Index--;
  }
 return (Index);
 }

bool TestRing() {		// test each adjacent pair in ring
 int sum;
 int c0, c1, c2, c3;
 rType inarray[RingSize];
 memset(inarray,0,(sizeof(rType)*RingSize));
 c1 = rHead;			// starting from rHead
 for (c0 = 0; c0 < RingSize; c0++) {
  c2 = AdvanceIndex(c1);	// point to next element
// validate both elements within range
  if (rElement[c2] < 1 || rElement[c2] > RingSize) {
   printf("%d is not between 1 and %d\n",rElement[c2],RingSize);
   return false;
   }
  if (rElement[c1] < 1 || rElement[c1] > RingSize) {
   printf("%d is not between 1 and %d\n",rElement[c1],RingSize);
   return false;
   }
// and they're not already in array
  if (inarray[rElement[c1]-1]) {
   printf("element '%d' occurs more than once\n",rElement[c1]);
   return false;
   }
  if (inarray[rElement[c2]-1] && (c0 < (RingSize-1))) {
   printf("element '%d' occurs more than once\n",rElement[c2]);
   return false;
   }
  inarray[rElement[c1]-1] = rElement[c1];
  sum = rElement[c1] + rElement[c2];
  printf("%d + %d = %d", rElement[c1], rElement[c2], sum);
// and that the adjacent pair sums to a perfect square
  for (c3 = 0; c3 < SquareCount; c3++)
   if (sum == Squares[c3]) break;
  if (c3 == SquareCount) {	// square test failure
   printf(": NOT A PERFECT SQUARE\n");
   return false;
   }
  printf(": OK\n");
  c1 = AdvanceIndex(c1);
  }
 return true;
 };

bool DumpRing() {
 int c0, c1;
 c1 = rHead;
 for (c0 = 0; c0 < RingSize; c0++) {
  printf("%d ",rElement[c1]);
  c1 = AdvanceIndex(c1);
  }
 printf("\n");
 return true;
 };
};

int main(void) {
 Ring r0;
 r0.rInit();
 r0.LoadRingData();
 r0.Randomize();
 if (r0.TestRing())
  printf("Ring tests OK\n");
 else
  printf("Ring doesn't test OK\n");
// r0.DumpRing();
 exit(0);
}