#define ArrLen(x)         (sizeof(x)/sizeof(x[0]))

const byte preset0[][2] = {{64,32}}; // default
const byte preset1[][2] = {{60,30},{62,30},{61,29},{63,31},{62,32}};
const byte preset2[][2] = {{11,22},{33,44},{55,66},{77,88}};

struct prst {
  const byte (*pixels)[2];
  const uint16_t length;
}
presets[] = {
  {preset0, ArrLen(preset0)},
  {preset0, ArrLen(preset0)},
  {preset1, ArrLen(preset1)},
  {preset2, ArrLen(preset2)},
};

void testNode(struct prst *preset) {
  Serial1.println(preset->length);
  
}

void getPixels(const byte pos[2]) {
  byte x = pos[0];
  byte y = pos[1];
  Serial1.print("x: "); Serial1.println(x);
  Serial1.print("y: "); Serial1.println(y);
}

void getPixelArr(const byte (*pixels)[2], int len) {
  Serial1.println(len);
  for (int i=0; i<len; i++) {
    Serial1.print(i); Serial1.print(" -> ");
    Serial1.print(pixels[i][0]);
    Serial1.print(", "); Serial1.println(pixels[i][1]);
  }
}

void setup() {
  Serial1.begin(115200);
  Serial1.println("");

  struct prst *preset = &presets[0];
  preset = &presets[2];
  getPixelArr(preset->pixels, preset->length);
  /*
  Serial1.println(preset->length);
  Serial1.println(preset->pixels[0][0]);
  Serial1.println(preset->pixels[0][1]);
  */
  //testNode(&presets[2]);

  //for (int i=0; i<ArrLen(presets); i++) Serial1.print(i); Serial1.print(" "); Serial1.println(presets[i].length);

  /*
  for (int i=0; i<ArrLen(presets); i++) {
    const byte (*positions)[2] = presets[i];
    Serial1.print(i); Serial1.print(" "); Serial1.println(ArrLen(preset1));
    //Serial1.print(ArrLen(positions)); Serial1.print(" "); Serial1.println(positions[0][0]);
  }
  */
}
/*
// Array of pointers to each preset
const byte (*presets[])[2] = { preset0, preset1, preset2 };

struct _cfg {
  const char*    name;
  const uint8_t (*pixels)[2];
  const uint16_t length;
}
matrix_cfg[] = {
  {"preset0", preset0, ArrLen(preset0)},
  {"preset1", preset1, ArrLen(preset1)},
  {"preset2", preset2, ArrLen(preset2)},
};

void setup() {
  Serial1.begin(115200);
  Serial1.println("");

  const byte (*cfg[])[2] = preset0;
  const uint8_t (*pixels)[2];
  Serial1.print("ptr: "); Serial1.println(ptr[0][0]);

  for (int i =0; i<ArrLen(matrix_cfg); i++) {
    //struct _cfg *cfg = &matrix_cfg[i]; Serial1.println(cfg.name);
    Serial1.print("name:   ");Serial1.println(matrix_cfg[i].name);
    Serial1.print("length: ");Serial1.println(matrix_cfg[i].length);
    Serial1.println();
  }
}
*/

void loop() { delay(1); }

/*
void setup() {
  uint8_t preset = 4;
  
  // Define each preset as a separate array
  static const byte preset0[][2] = {{64,32}}; // default
  static const byte preset2[][2] = {{56,37},{58,37},{58,36},{60,35},{60,34},{60,33},{62,34},{62,33},{62,32},{63,33}};
  static const byte preset3[][2] = {{62,30},{62,31},{62,32},{64,32},{63,33},{64,30},{65,30},{66,30},{67,31},{66,32},{66,33}};
  static const byte preset4[][2] = {{48,8},{49,8},{66,8},{67,8},{48,9},{49,9},{57,9},{58,9},{66,9},{67,9},{57,10},{58,10},{32,15},{33,15},{82,15},{83,15},{32,16},{33,16},{82,16},{83,16},{50,19},{65,19},{50,20},{51,20},{52,20},{63,20},{64,20},{65,20},{51,22},{52,22},{53,22},{62,22},{63,22},{64,22},{40,27},{41,27},{74,27},{75,27},{40,28},{41,28},{74,28},{75,28},{40,32},{41,32},{74,32},{75,32},{40,33},{41,33},{74,33},{75,33},{51,38},{52,38},{53,38},{62,38},{63,38},{64,38},{50,40},{51,40},{52,40},{63,40},{64,40},{65,40},{50,41},{65,41},{32,44},{33,44},{82,44},{83,44},{32,45},{33,45},{82,45},{83,45},{57,50},{58,50},{48,51},{49,51},{57,51},{58,51},{66,51},{67,51},{48,52},{49,52},{66,52},{67,52}};
  static const byte preset5[][2] = {{60,30},{62,30},{61,29},{63,31},{62,32}};

  
  // Array of pointers to each preset
  static const byte (*presetPointers[])[2] = {
    presetDefault,  // index 0
    presetDefault,  // index 1 
    preset2,        // index 2
    preset3,        // index 3
    preset4,        // index 4
    preset5         // index 5
  };
  
  // Array of sizes
  static const uint16_t presetSizes[] = {
    sizeof(presetDefault) / sizeof(presetDefault[0]),
    sizeof(presetDefault) / sizeof(presetDefault[0]),
    sizeof(preset2) / sizeof(preset2[0]),
    sizeof(preset3) / sizeof(preset3[0]),
    sizeof(preset4) / sizeof(preset4[0]),
    sizeof(preset5) / sizeof(preset5[0])
  };
  
  uint8_t index = (preset >= 0 && preset <= 5) ? preset : 0;
  const byte (*positions)[2] = presetPointers[index];
  uint16_t numPositions = presetSizes[index];
  
  Serial1.begin(115200);
  Serial1.println("");
  
  for (uint16_t i = 0; i < numPositions; i++) {
    getPixels(positions[i]);
  }
}
*/
/*
void getPixels(const byte pos[2]) {
  byte x = pos[0];
  byte y = pos[1];
  Serial1.print("x: "); Serial1.println(x);
  Serial1.print("y: "); Serial1.println(y);
}

void setup() {
  uint8_t myNum = 2;
  const byte positions[][2] = (
    (myNum == 1) ? {{1,2},{3,4}} :
    (myNum == 2) ? {{5,6},{7,8}} : {}
  );
  Serial1.begin(115200);
  Serial1.println("");
  getPixels(positions[0]);
}

void loop() { delay(1); }
*/