#include "LedControl.h"
LedControl lc=LedControl(14,12,13,4);
/* card LOLIN(WEMOS) D1 R2 & MINI
 * Create a new controller 
 * Params :
 * int dataPin    The pin on the Arduino where data gets shifted out
 * int clockPin   The pin for the clock
 * int csPin      The pin for selecting the device when data is to be sent
 * int numDevices The maximum number of devices that can be controlled
*/
//LedControl(int dataPin, int clkPin, int csPin, int numDevices);

#include <ESP_WiFiManager.h> 
#include <time.h>

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

#define OLED_RESET LED_BUILTIN  //4
Adafruit_SSD1306 display(OLED_RESET);

const char* ssid     = "";
const char* password = "";

int ledPin = 13;

int timezone = 1 * 3600;
int dst = 0;
/* we always wait a bit between updates of the display */
unsigned long delaytime=100;

#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

void setup() {

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

  // Clear the buffer.
  display.clearDisplay();
  display.display();
  
  pinMode(ledPin,OUTPUT);
  digitalWrite(ledPin,LOW);

  Serial.begin(115200);

  display.setTextSize(1);
  display.setTextColor(WHITE);
  
  display.setCursor(0,0);
  Serial.println("Wifi connecting to ");
  Serial.println( ssid );

  WiFi.begin(ssid,password);
 
  Serial.println("\nConnecting");

  display.display();

  while( WiFi.status() != WL_CONNECTED ){
      delay(500);
      Serial.print("."); 
      display.display();       
  }

  // Clear the buffer.
  display.clearDisplay();
  display.display();
  display.setCursor(0,0);
  
  display.println("Wifi Connected!");
  display.print("IP:");
  display.println(WiFi.localIP() );

  display.display();

  configTime(timezone, dst, "pool.ntp.org","time.nist.gov");
  display.println("\nWaiting for NTP...");

  while(!time(nullptr)){
     Serial.print("*");
     
     delay(1000);
  }
  display.println("\nTime response....OK"); 
  display.display();  
  delay(1000);

  display.clearDisplay();
  display.display();

  /*
   The MAX72XX is in power-saving mode on startup,
   we have to do a wakeup call
   */
  lc.shutdown(0,false);
  lc.shutdown(1,false);
  lc.shutdown(2,false);
  lc.shutdown(3,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,0);
  lc.setIntensity(1,0);
  lc.setIntensity(2,0);
  lc.setIntensity(3,0);
  /* and clear the display */
  lc.clearDisplay(0);
  lc.clearDisplay(1);
  lc.clearDisplay(2);
  lc.clearDisplay(3);

}

byte Seconds;
byte SecondsOnes;
byte SecondsTens;
byte Minutes;
byte MinutesOnes;
byte MinutesTens;
bool ToggleDotsFlag;
void loop() {
time_t now = time(nullptr);
struct tm* p_tm = localtime(&now);
  
  
  Serial.print(p_tm->tm_mday);
  Serial.print("/");
  Serial.print(p_tm->tm_mon + 1);
  Serial.print("/");
  Serial.print(p_tm->tm_year + 1900);
  
  Serial.print(" ");
  
  Serial.print(p_tm->tm_hour);
  Serial.print(":");
  Serial.print(p_tm->tm_min);
  Serial.print(":");
  Serial.println(p_tm->tm_sec);
  
  // Clear the buffer.
  display.clearDisplay();
 
  display.setTextSize(3);
  display.setTextColor(WHITE);
  
  display.setCursor(0,0);
  display.print(p_tm->tm_hour);
  display.print(":");
  if( p_tm->tm_min <10)
    display.print("0"); 
  display.print(p_tm->tm_min);
  
  display.setTextSize(2);
  display.setCursor(90,5);
  display.print(".");
  if( p_tm->tm_sec <10)
    display.print("0"); 
  display.print(p_tm->tm_sec);

  display.setTextSize(1);
  display.setCursor(0,40);
  display.print(p_tm->tm_mday);
  display.print("/");
  display.print(p_tm->tm_mon + 1);
  display.print("/");
  display.print(p_tm->tm_year + 1900);

  display.display();

  delay(500); // update every 1 sec

byte Digit[10][8]=  { 
{
  B00111000,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B01000100,
  B00111000
},{
  B00010000,
  B00110000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00010000,
  B00111000
},{
  B00111000,
  B01000100,
  B00000100,
  B00000100,
  B00001000,
  B00010000,
  B00100000,
  B01111100
},{
  B00111000,
  B01000100,
  B00000100,
  B00011000,
  B00000100,
  B00000100,
  B01000100,
  B00111000
},{
  B00000100,
  B00001100,
  B00010100,
  B00100100,
  B01000100,
  B01111100,
  B00000100,
  B00000100
},{
  B01111100,
  B01000000,
  B01000000,
  B01111000,
  B00000100,
  B00000100,
  B01000100,
  B00111000
},{
  B00111000,
  B01000100,
  B01000000,
  B01111000,
  B01000100,
  B01000100,
  B01000100,
  B00111000
},{
  B01111100,
  B00000100,
  B00000100,
  B00001000,
  B00010000,
  B00100000,
  B00100000,
  B00100000
},{
  B00111000,
  B01000100,
  B01000100,
  B00111000,
  B01000100,
  B01000100,
  B01000100,
  B00111000
},{
  B00111000,
  B01000100,
  B01000100,
  B01000100,
  B00111100,
  B00000100,
  B01000100,
  B00111000
}};

  byte DigitRight[10][8]=  { 
{
  B00011100,
  B00100010,
  B00100010,
  B00100010,
  B00100010,
  B00100010,
  B00100010,
  B00011100
},{  
  B00001000,
  B00011000,
  B00001000,
  B00001000,
  B00001000,
  B00001000,
  B00001000,
  B00011100
},{
  B00011100,
  B00100010,
  B00000010,
  B00000010,
  B00000100,
  B00001000,
  B00010000,
  B00111110
},{
  B00011100,
  B00100010,
  B00000010,
  B00001100,
  B00000010,
  B00000010,
  B00100010,
  B00011100
},{
  B00000010,
  B00000110,
  B00001010,
  B00010010,
  B00100010,
  B00111110,
  B00000010,
  B00000010
},{
  B00111110,
  B00100000,
  B00100000,
  B00111100,
  B00000010,
  B00000010,
  B00100010,
  B00011100
},{
  B00011100,
  B00100010,
  B00100000,
  B00111100,
  B00100010,
  B00100010,
  B00100010,
  B00011100
},{
  B00111110,
  B00000010,
  B00000010,
  B00000100,
  B00001000,
  B00010000,
  B00010000,
  B00010000
},{
  B00011100,
  B00100010,
  B00100010,
  B00011100,
  B00100010,
  B00100010,
  B00100010,
  B00011100
},{
  B00011100,
  B00100010,
  B00100010,
  B00100010,
  B00011110,
  B00000010,
  B00100010,
  B00011100
}};
Seconds=p_tm->tm_min;
Minutes=p_tm->tm_hour;
SecondsTens=Seconds/10;
SecondsOnes=Seconds-SecondsTens*10;
MinutesTens=Minutes/10;
MinutesOnes=Minutes-MinutesTens*10;

/* now display them one by one with a small delay */
lc.setRow(0,0,Digit[SecondsOnes][0]);
lc.setRow(0,1,Digit[SecondsOnes][1]);
lc.setRow(0,2,Digit[SecondsOnes][2]);
lc.setRow(0,3,Digit[SecondsOnes][3]);
lc.setRow(0,4,Digit[SecondsOnes][4]);
lc.setRow(0,5,Digit[SecondsOnes][5]);
lc.setRow(0,6,Digit[SecondsOnes][6]);
lc.setRow(0,7,Digit[SecondsOnes][7]);

lc.setRow(1,0,DigitRight[SecondsTens][0]);
lc.setRow(1,1,DigitRight[SecondsTens][1]);
lc.setRow(1,2,DigitRight[SecondsTens][2]);
lc.setRow(1,3,DigitRight[SecondsTens][3]);
lc.setRow(1,4,DigitRight[SecondsTens][4]);
lc.setRow(1,5,DigitRight[SecondsTens][5]);
lc.setRow(1,6,DigitRight[SecondsTens][6]);
lc.setRow(1,7,DigitRight[SecondsTens][7]);

lc.setRow(2,0,Digit[MinutesOnes][0]);
lc.setRow(2,1,Digit[MinutesOnes][1]);
lc.setRow(2,2,Digit[MinutesOnes][2]);
lc.setRow(2,3,Digit[MinutesOnes][3]);
lc.setRow(2,4,Digit[MinutesOnes][4]);
lc.setRow(2,5,Digit[MinutesOnes][5]);
lc.setRow(2,6,Digit[MinutesOnes][6]);
lc.setRow(2,7,Digit[MinutesOnes][7]);

lc.setRow(3,0,DigitRight[MinutesTens][0]);
lc.setRow(3,1,DigitRight[MinutesTens][1]);
lc.setRow(3,2,DigitRight[MinutesTens][2]);
lc.setRow(3,3,DigitRight[MinutesTens][3]);
lc.setRow(3,4,DigitRight[MinutesTens][4]);
lc.setRow(3,5,DigitRight[MinutesTens][5]);
lc.setRow(3,6,DigitRight[MinutesTens][6]);
lc.setRow(3,7,DigitRight[MinutesTens][7]);
      
if (ToggleDotsFlag==true){
  ToggleDotsFlag=false;
}
else {
  ToggleDotsFlag=true;
}
lc.setLed(1,1,0,ToggleDotsFlag); 
lc.setLed(1,2,0,ToggleDotsFlag); 
lc.setLed(1,5,0,ToggleDotsFlag); 
lc.setLed(1,6,0,ToggleDotsFlag); 

lc.setLed(2,1,7,ToggleDotsFlag); 
lc.setLed(2,2,7,ToggleDotsFlag); 
lc.setLed(2,5,7,ToggleDotsFlag); 
lc.setLed(2,6,7,ToggleDotsFlag); 
}


void WriteTimeOnMatrix() {

}