#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#include <FastLED.h>
#include <maps.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
// The pins for I2C are defined by the Wire-library. 
// On an arduino UNO:       A4(SDA), A5(SCL)
// On an arduino MEGA 2560: 20(SDA), 21(SCL)
// On an arduino LEONARDO:   2(SDA),  3(SCL), ...
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define NUMFLAKES     10 // Number of snowflakes in the animation example

#define LOGO_HEIGHT   16
#define LOGO_WIDTH    16
static const unsigned char PROGMEM logo_bmp[] =
{ 0b00000000, 0b11000000,
  0b00000001, 0b11000000,
  0b00000001, 0b11000000,
  0b00000011, 0b11100000,
  0b11110011, 0b11100000,
  0b11111110, 0b11111000,
  0b01111110, 0b11111111,
  0b00110011, 0b10011111,
  0b00011111, 0b11111100,
  0b00001101, 0b01110000,
  0b00011011, 0b10100000,
  0b00111111, 0b11100000,
  0b00111111, 0b11110000,
  0b01111100, 0b11110000,
  0b01110000, 0b01110000,
  0b00000000, 0b00110000 };

// ============ LED definitions ================

// How many leds in your strip?
#define NUM_LEDS 512

#define DATA_PIN 5
#define CLOCK_PIN 13

// Define the array of leds
CRGB leds[NUM_LEDS];
CRGB _leds[NUM_LEDS];
uint8_t shouldClear = 1;   // clear all leds between frames


class Effect
{
public:
  virtual void setup(void) {};
  virtual void draw(void) {};
};

void remap()
{
  for (int i = 0; i < NUM_LEDS; i++)
  {
    _leds[ledsOnPCBMap[i]] = leds[i];
  }
}

class FTest : public Effect
{
public:
  void draw()
  {
    static uint8_t x = 0;
    x++;
    fill_rainbow(leds, NUM_LEDS, x, 1);
  }
};

class Effect2D : public Effect
{
public:
  virtual void setup(void) {};
  void draw(void) override
  {
    this->beforeRender();
    for (int i = 0; i < NUM_LEDS; i++)
    {
      leds[i] = this->render(i, ledsXYMap[i][0], ledsXYMap[i][0]);
    }
  };
  virtual void beforeRender(void) {};
  virtual CRGB render(int idx, float x, float y) { return CRGB::Black; }
};

class EffectPolar : public Effect
{
public:
  virtual void setup(void) {};
  void draw(void) override
  {
    this->beforeRender();
    for (int i = 0; i < NUM_LEDS; i++)
    {
      leds[i] = this->render(i, ledsPolarMap[i][0], ledsPolarMap[i][0]);
    }
  };
  virtual void beforeRender(void) {};
  virtual CRGB render(int idx, float r, float deg) { return CRGB::Black; }
};

class PolarTest : public EffectPolar
{
  float r = 0;
  uint8_t hue = 0;
  void beforeRender() override
  {
    this->r = beatsin8(20, 0, 255) / 255.0;
    this->hue++;
  }
  CRGB render(int idx, float r, float deg) override
  {
    float delta = abs(r - this->r);
    if (delta < 0.2)
      return CHSV(this->hue, 200 - (0.2 - delta) * 600, 200);
    return CRGB::Black;
  }
};

class VariableArmsDemo : public Effect
{
  void draw(void) override
  {
    static uint8_t hueOffset = 0;
    static uint8_t numArms = 1;
    EVERY_N_SECONDS(1) { numArms++; }
    for (int i = 0; i < NUM_LEDS; i++)
    {
      uint16_t armIndex = i % numArms;
      uint8_t hue = (map(armIndex, 0, numArms, 0, 255) + hueOffset) % 255;
      leds[ledsAsSpiralMap[i]] = CHSV(hue, 255, 255);
    }
  }
};

class PlanarDemo : public Effect
{
  void draw(void) override
  {
    for(int i=0;i<PLANAR_COLS;i++) {
      for(int j=0;j<PLANAR_ROWS;j++) {
        int idx = planarMap[i*PLANAR_COLS+j];
        if(idx==1000)
          continue;
        leds[idx] = CHSV(i*20, 255, 255);
      }
    }
  
  }
};


class PolarDemo : public Effect
{
  void draw(void) override
  {
      uint16_t  a = millis()/7;
     static int n = 0;
  //EVERY_N_MILLIS(259) { n++; n = n%POLAR_COLS;}
  
  for (int j = 0; j < POLAR_ROWS; j++) {
    for (int i = 0; i < POLAR_COLS; i++) {
     uint16_t idx = polarMap[POLAR_COLS*j+i]; 

      if (idx==1000) continue;
       leds[idx].setHue(i*54+(a>>2)+(sin8(j*16+a))>>1);       
      
      //leds[idx] = CHSV(i*4,200,200);
    }
  } 

  
  }
};

class PolarCaleidoscope : public Effect
{
  void draw(void) override
  {
      uint16_t  a = millis()/7;
     static int n = 0;
  //EVERY_N_MILLIS(259) { n++; n = n%POLAR_COLS;}
  
  for (int j = 0; j < POLAR_ROWS; j++) {
    for (int i = 0; i < POLAR_COLS; i++) {
     uint16_t idx = polarMap[POLAR_COLS*j+i]; 

      if (idx==1000) continue;

      int jj = POLAR_ROWS - j;

      byte r = (sin8(i*16+a)+cos8(jj*16+a/2))/2;
      byte g = sin8(jj*16+a/2+sin8(leds[idx].r+a)/16);
      byte b = cos8(i*16+jj*16-a/2+leds[idx].g);

      leds[idx].setRGB (r,g,b);


      
    }
  } 

  
  }
};

class PolarFireFly : public Effect
{
  void draw(void) override
  {
      uint16_t  a = millis()/3;
     static int n = 0;
  //EVERY_N_MILLIS(259) { n++; n = n%POLAR_COLS;}
  
  for (int j = 0; j < POLAR_ROWS; j++) {
    for (int i = 0; i < POLAR_COLS; i++) {
     uint16_t idx = polarMap[POLAR_COLS*j+i]; 

     int jj = POLAR_ROWS - j;

      if (idx==1000) continue;
           leds[idx]= HeatColor (qsub8 (inoise8 (i * 60+a , jj * 5+ a , a /3), abs8(jj - (POLAR_ROWS-1)) * 255 / (POLAR_ROWS+2)));

      
      //leds[idx] = CHSV(i*4,200,200);
    }
  } 

  
  }
};


class Spiral : public Effect
{
  void draw(void) override
  {
    static uint8_t hueOffset = 0;
    static uint8_t numArms = 2;
    
    for (int i = 0; i < NUM_LEDS; i++)
    {
      uint16_t armIndex = i % numArms;
      if(armIndex == 0)
        leds[ledsAsSpiralMap[i]] = CRGB::Red;
      else
        leds[ledsAsSpiralMap[i]] = CRGB::White;
    }
  }
};

void testdrawline() {
  int16_t i;

  display.clearDisplay(); // Clear display buffer

  for(i=0; i<display.width(); i+=4) {
    display.drawLine(0, 0, i, display.height()-1, SSD1306_WHITE);
    display.display(); // Update screen with each newly-drawn line
    delay(1);
  }
  for(i=0; i<display.height(); i+=4) {
    display.drawLine(0, 0, display.width()-1, i, SSD1306_WHITE);
    display.display();
    delay(1);
  }
  delay(250);

  display.clearDisplay();

  for(i=0; i<display.width(); i+=4) {
    display.drawLine(0, display.height()-1, i, 0, SSD1306_WHITE);
    display.display();
    delay(1);
  }
  for(i=display.height()-1; i>=0; i-=4) {
    display.drawLine(0, display.height()-1, display.width()-1, i, SSD1306_WHITE);
    display.display();
    delay(1);
  }
  delay(250);

  display.clearDisplay();

  for(i=display.width()-1; i>=0; i-=4) {
    display.drawLine(display.width()-1, display.height()-1, i, 0, SSD1306_WHITE);
    display.display();
    delay(1);
  }
  for(i=display.height()-1; i>=0; i-=4) {
    display.drawLine(display.width()-1, display.height()-1, 0, i, SSD1306_WHITE);
    display.display();
    delay(1);
  }
  delay(250);

  display.clearDisplay();

  for(i=0; i<display.height(); i+=4) {
    display.drawLine(display.width()-1, 0, 0, i, SSD1306_WHITE);
    display.display();
    delay(1);
  }
  for(i=0; i<display.width(); i+=4) {
    display.drawLine(display.width()-1, 0, i, display.height()-1, SSD1306_WHITE);
    display.display();
    delay(1);
  }

  delay(2000); // Pause for 2 seconds
}

void testdrawrect(void) {
  display.clearDisplay();

  for(int16_t i=0; i<display.height()/2; i+=2) {
    display.drawRect(i, i, display.width()-2*i, display.height()-2*i, SSD1306_WHITE);
    display.display(); // Update screen with each newly-drawn rectangle
    delay(1);
  }

  delay(2000);
}

void testfillrect(void) {
  display.clearDisplay();

  for(int16_t i=0; i<display.height()/2; i+=3) {
    // The INVERSE color is used so rectangles alternate white/black
    display.fillRect(i, i, display.width()-i*2, display.height()-i*2, SSD1306_INVERSE);
    display.display(); // Update screen with each newly-drawn rectangle
    delay(1);
  }

  delay(2000);
}

void testdrawcircle(void) {
  display.clearDisplay();

  for(int16_t i=0; i<max(display.width(),display.height())/2; i+=2) {
    display.drawCircle(display.width()/2, display.height()/2, i, SSD1306_WHITE);
    display.display();
    delay(1);
  }

  delay(2000);
}

void testfillcircle(void) {
  display.clearDisplay();

  for(int16_t i=max(display.width(),display.height())/2; i>0; i-=3) {
    // The INVERSE color is used so circles alternate white/black
    display.fillCircle(display.width() / 2, display.height() / 2, i, SSD1306_INVERSE);
    display.display(); // Update screen with each newly-drawn circle
    delay(1);
  }

  delay(2000);
}

void testdrawroundrect(void) {
  display.clearDisplay();

  for(int16_t i=0; i<display.height()/2-2; i+=2) {
    display.drawRoundRect(i, i, display.width()-2*i, display.height()-2*i,
      display.height()/4, SSD1306_WHITE);
    display.display();
    delay(1);
  }

  delay(2000);
}

void testfillroundrect(void) {
  display.clearDisplay();

  for(int16_t i=0; i<display.height()/2-2; i+=2) {
    // The INVERSE color is used so round-rects alternate white/black
    display.fillRoundRect(i, i, display.width()-2*i, display.height()-2*i,
      display.height()/4, SSD1306_INVERSE);
    display.display();
    delay(1);
  }

  delay(2000);
}

void testdrawtriangle(void) {
  display.clearDisplay();

  for(int16_t i=0; i<max(display.width(),display.height())/2; i+=5) {
    display.drawTriangle(
      display.width()/2  , display.height()/2-i,
      display.width()/2-i, display.height()/2+i,
      display.width()/2+i, display.height()/2+i, SSD1306_WHITE);
    display.display();
    delay(1);
  }

  delay(2000);
}

void testfilltriangle(void) {
  display.clearDisplay();

  for(int16_t i=max(display.width(),display.height())/2; i>0; i-=5) {
    // The INVERSE color is used so triangles alternate white/black
    display.fillTriangle(
      display.width()/2  , display.height()/2-i,
      display.width()/2-i, display.height()/2+i,
      display.width()/2+i, display.height()/2+i, SSD1306_INVERSE);
    display.display();
    delay(1);
  }

  delay(2000);
}

void testdrawchar(void) {
  display.clearDisplay();

  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(0, 0);     // Start at top-left corner
  display.cp437(true);         // Use full 256 char 'Code Page 437' font

  // Not all the characters will fit on the display. This is normal.
  // Library will draw what it can and the rest will be clipped.
  for(int16_t i=0; i<256; i++) {
    if(i == '\n') display.write(' ');
    else          display.write(i);
  }

  display.display();
  delay(2000);
}

void testdrawstyles(void) {
  display.clearDisplay();

  display.setTextSize(1);             // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE);        // Draw white text
  display.setCursor(0,0);             // Start at top-left corner
  display.println(F("Hello, world!"));

  display.setTextColor(SSD1306_BLACK, SSD1306_WHITE); // Draw 'inverse' text
  display.println(3.141592);

  display.setTextSize(2);             // Draw 2X-scale text
  display.setTextColor(SSD1306_WHITE);
  display.print(F("0x")); display.println(0xDEADBEEF, HEX);

  display.display();
  delay(2000);
}

void testscrolltext(void) {
  display.clearDisplay();

  display.setTextSize(2); // Draw 2X-scale text
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 0);
  display.println(F("scroll"));
  display.display();      // Show initial text
  delay(100);

  // Scroll in various directions, pausing in-between:
  display.startscrollright(0x00, 0x0F);
  delay(2000);
  display.stopscroll();
  delay(1000);
  display.startscrollleft(0x00, 0x0F);
  delay(2000);
  display.stopscroll();
  delay(1000);
  display.startscrolldiagright(0x00, 0x07);
  delay(2000);
  display.startscrolldiagleft(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  delay(1000);
}

void testdrawbitmap(void) {
  display.clearDisplay();

  display.drawBitmap(
    (display.width()  - LOGO_WIDTH ) / 2,
    (display.height() - LOGO_HEIGHT) / 2,
    logo_bmp, LOGO_WIDTH, LOGO_HEIGHT, 1);
  display.display();
  delay(1000);
}

#define XPOS   0 // Indexes into the 'icons' array in function below
#define YPOS   1
#define DELTAY 2

void testanimate(const uint8_t *bitmap, uint8_t w, uint8_t h) {
  int8_t f, icons[NUMFLAKES][3];

  // Initialize 'snowflake' positions
  for(f=0; f< NUMFLAKES; f++) {
    icons[f][XPOS]   = random(1 - LOGO_WIDTH, display.width());
    icons[f][YPOS]   = -LOGO_HEIGHT;
    icons[f][DELTAY] = random(1, 6);
    Serial.print(F("x: "));
    Serial.print(icons[f][XPOS], DEC);
    Serial.print(F(" y: "));
    Serial.print(icons[f][YPOS], DEC);
    Serial.print(F(" dy: "));
    Serial.println(icons[f][DELTAY], DEC);
  }

  for(;;) { // Loop forever...
    display.clearDisplay(); // Clear the display buffer

    // Draw each snowflake:
    for(f=0; f< NUMFLAKES; f++) {
      display.drawBitmap(icons[f][XPOS], icons[f][YPOS], bitmap, w, h, SSD1306_WHITE);
    }

    display.display(); // Show the display buffer on the screen
    delay(200);        // Pause for 1/10 second

    // Then update coordinates of each flake...
    for(f=0; f< NUMFLAKES; f++) {
      icons[f][YPOS] += icons[f][DELTAY];
      // If snowflake is off the bottom of the screen...
      if (icons[f][YPOS] >= display.height()) {
        // Reinitialize to a random position, just off the top
        icons[f][XPOS]   = random(1 - LOGO_WIDTH, display.width());
        icons[f][YPOS]   = -LOGO_HEIGHT;
        icons[f][DELTAY] = random(1, 6);
      }
    }
  }
}

void displayDemo() {
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

  // Show initial display buffer contents on the screen --
  // the library initializes this with an Adafruit splash screen.
  display.display();
  delay(2000); // Pause for 2 seconds

  // Clear the buffer
  display.clearDisplay();

  // Draw a single pixel in white
  display.drawPixel(10, 10, SSD1306_WHITE);

  // Show the display buffer on the screen. You MUST call display() after
  // drawing commands to make them visible on screen!
  display.display();
  delay(2000);
  // display.display() is NOT necessary after every single drawing command,
  // unless that's what you want...rather, you can batch up a bunch of
  // drawing operations and then update the screen all at once by calling
  // display.display(). These examples demonstrate both approaches...

  testdrawline();      // Draw many lines

  testdrawrect();      // Draw rectangles (outlines)

  testfillrect();      // Draw rectangles (filled)

  testdrawcircle();    // Draw circles (outlines)

  testfillcircle();    // Draw circles (filled)

  testdrawroundrect(); // Draw rounded rectangles (outlines)

  testfillroundrect(); // Draw rounded rectangles (filled)

  testdrawtriangle();  // Draw triangles (outlines)

  testfilltriangle();  // Draw triangles (filled)

  testdrawchar();      // Draw characters of the default font

  testdrawstyles();    // Draw 'stylized' characters

  testscrolltext();    // Draw scrolling text

  testdrawbitmap();    // Draw a small bitmap image

  // Invert and restore display, pausing in-between
  display.invertDisplay(true);
  delay(1000);
  display.invertDisplay(false);
  delay(1000);

  testanimate(logo_bmp, LOGO_WIDTH, LOGO_HEIGHT); // Animate bitmaps
}


Effect *effect;

void setup() {
    FastLED.addLeds<NEOPIXEL, DATA_PIN>(_leds, NUM_LEDS);  
    effect = new PolarFireFly();
    effect->setup();

    displayDemo();
}

void clear()
{
  memset(leds, 0, sizeof(leds));
}

void loop() {
  delay(10);
  if (shouldClear)
    clear();
  effect->draw();
  remap();
  FastLED.show();
  //delay(50);
  //FastLED.clear();
  //FastLED.show();
  //delay(50);
}