/*H*******************************************************
 MerrittSoft
 Internet Clock with Daylight Savings
 30/01/2020
 Language: C++/Arduino
 Thank you to those people that made the Libarays in this project posable.
********************************************************/
#include <TM1637Display.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h> // here I have used the WiFiManager Library to connect to the wifi,
 //I have found that it dosen't always connect after power on, thats why i add a restet button
#include <DNSServer.h>
#include <TimeLib.h> //For more information in the TimeLib Library, Please read PaulStoffregen library Arduino Time.
#include <Timezone.h> // To understand how to setup the timezones and daylight saving times,
 //please read Jack Christensen Library Arduino Timezone.

//************************* DEFINES ************************************
#define  BAUD  9600
#define DIO D5           // Display pins on Arduino
#define CLK D6
// part of fixed wifi ssid and password
//const char ssid[] = "SSID"; // your network SSID (name)
//const char pass[] = "PASSWORD"; // your network password

//************************* PROTOTYPES ************************************
time_t getNtpTime();
void digitalClockDisplay();
void printDigits( int digits );
void sendNTPpacket( IPAddress &address );

//************************* VARIABLES ************************************
TimeChangeRule aEDT = {"AEDT", First, Sun, Oct, 2, 660}; // UTC + 11 hours For Sydney Australia, fron Timezone library
TimeChangeRule aEST = {"AEST", First, Sun, Apr, 3, 600}; // UTC + 10 hours For Sydney Australia fron Timezone library
Timezone ausET( aEDT, aEST);
int sensorPin = A0;
int formattedTimemin = 0;
int formattedTimehour = 0;
int sensorValue = 0;
TM1637Display display( CLK, DIO);
// NTP Servers:
static const char ntpServerName[] = "3.oceania.pool.ntp.org"; // replace this NTP Server with one that is closer to your location
//static const char ntpServerName[] = "time.nist.gov";
//static const char ntpServerName[] = "time-a.timefreq.bldrdoc.gov";
//static const char ntpServerName[] = "time-b.timefreq.bldrdoc.gov";
//static const char ntpServerName[] = "time-c.timefreq.bldrdoc.gov";
int timeZone = 0; // GMT Timezone handled from Timezone library, ajust above
WiFiUDP   Udp;
unsigned int localPort = 8888; // local port to listen for UDP packets
TimeChangeRule *tcr;
const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
time_t prevDisplay = 0; // when the digital clock was displayed

/*F********************************************************************
*
**********************************************************************/
void 
setup()
{
    WiFiManager wifiManager;     // part of wifimanager Library
    Serial.begin( BAUD );
     while( !Serial); // Needed for Leonardo only
         delay( 250 );
    Serial.println( "TimeNTP Example");
     // part of the wifimanager Library
     wifiManager.autoConnect( "Internet-Clock");
     // part of the fixed wifi ssid and password
     // Serial.print("Connecting to ");
     //Serial.println(ssid);
     // WiFi.begin(ssid, pass);
     //while (WiFi.status() != WL_CONNECTED) 
        //{
     // delay(500);
     // Serial.print(".");
     // }
    Serial.print("IP number assigned by DHCP is ");
    Serial.println( WiFi.localIP());
    Serial.println("Starting UDP");
     Udp.begin( localPort );
    Serial.print( "Local port: ");
    Serial.println( Udp.localPort());
    Serial.println("waiting for sync");
     setSyncProvider(getNtpTime);
     setSyncInterval(300);
}
/*F********************************************************************
*
**********************************************************************/
void 
loop()
{
    delay(10000); // time update every 10 seconds
    time_t utc = now();
    time_t local = ausET.toLocal(utc, &tcr);
    Serial.println();
    printDateTime(local, tcr -> abbrev);
    sensorValue = analogRead(sensorPin);
    if( sensorValue < 15) 
        display.setBrightness( 0x01 );
    else if( sensorValue < 50 ) 
        display.setBrightness( 0x03 );
    else 
        display.setBrightness( 0x07 );
    if( timeStatus() != timeNotSet) 
    {
        if( now() != prevDisplay) //update the display only if time has changed
            prevDisplay = now();
    }
    // change 24hr to 12hr
    if( formattedTimehour > 12 ) 
        morethen12();
    if( formattedTimehour < 1 ) 
        lessthenone();
    digitalClockDisplay();
}
/*F********************************************************************
*
**********************************************************************/
void 
digitalClockDisplay()
{
    // digital clock display of the time
    Serial.println() ;
    Serial.print( hour() ) ;
    printDigits( minute() ) ;
    printDigits( second() ) ;
    Serial.print( " ") ;
    Serial.print( day() ) ;
    Serial.print( ".") ;
    Serial.print( month() ) ;
    Serial.print( ".") ;
    Serial.print( year() ) ;
    Serial.println() ;
    Serial.print( sensorValue) ;  
    Serial.print( "sensorValue ") ;  
    Serial.print( sensorValue) ;
    // send to display
    display.showNumberDecEx( formattedTimehour * 100 + formattedTimemin
        , 0b01000000 , false, 4, 0) ;
}
/*F********************************************************************
*
**********************************************************************/
void 
printDigits( int digits )
{
    // utility for digital clock display: prints preceding colon and leading 0
    Serial.print(":");
    if( digits < 10 )
        Serial.print('0');
    Serial.print( digits );
}
/*F********************************************************************
* Function to return the compile date and time as a time_t value
**********************************************************************/
time_t 
compileTime()
{
    const time_t FUDGE(10); // ADJ to allow for compile time (sec, YMMV)
    const char *compDate = __DATE__, *compTime = __TIME__
        , *months = "JanFebMarAprMayJunJulAugSepOctNovDec";
    char chMon[4], *m;
    tmElements_t tm;
    strncpy( chMon, compDate, 3);
    chMon[3] = '\0';
    m = strstr( months, chMon);
    tm.Month = ( (m - months) / 3 + 1);
    tm.Day = atoi( compDate + 4);
    tm.Year = atoi( compDate + 7) - 1970;
    tm.Hour = atoi( compTime);
    tm.Minute = atoi( compTime + 3);
    tm.Second = atoi( compTime + 6);
    time_t t = makeTime( tm );
    return t + FUDGE; // add fudge factor to allow for compile time
}
/*F********************************************************************
* format and print a time_t value, with a time zone appended.
**********************************************************************/
void 
printDateTime( time_t t, const char *tz)
{
    char buf[32];
    char m[4]; // temp stg for month string (DateStrings.cpp uses shared buffer)
    strcpy( m, monthShortStr( month( t )));
    sprintf( buf, "%.2d:%.2d:%.2d %s %.2d %s %d %s",
        hour(t), minute(t), second(t), dayShortStr(weekday(t)), day(t)
        , m, year(t), tz);
    // put hours and minutes into formattedTimehour and formattedTimemin for sending to display after its converted to 12hr time
    formattedTimemin = minute(t);
    formattedTimehour = hour(t);
    Serial.println( buf );
}
/*F********************************************************************
*
**********************************************************************/
time_t 
getNtpTime()
{
    IPAddress ntpServerIP; // NTP server's ip address
    while( Udp.parsePacket() > 0) ; // discard previously rcve pkts
    Serial.println("Transmit NTP Request");
    // get a random server from the pool
    WiFi.hostByName(ntpServerName, ntpServerIP);
    Serial.print(ntpServerName);
    Serial.print(": ");
    Serial.println(ntpServerIP);
    sendNTPpacket(ntpServerIP);
    uint32_t beginWait = millis();
    while (millis() - beginWait < 1500) {
    int size = Udp.parsePacket();
    if( size >= NTP_PACKET_SIZE) {
    Serial.println("Receive NTP Response");
    Udp.read(packetBuffer, NTP_PACKET_SIZE); // read packet into the buffer
    unsigned long secsSince1900;
    // convert four bytes starting at location 40 to a long integer
    secsSince1900 = (unsigned long)packetBuffer[40] << 24;
    secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
    secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
    secsSince1900 |= (unsigned long)packetBuffer[43];
    return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
    }
    }
    Serial.println("No NTP Response :-(");
    return 0; // return 0 if unable to get the time
}
/*F********************************************************************
* send an NTP request to the time server at the given address
**********************************************************************/
void 
sendNTPpacket( IPAddress &address)
{
    // set all bytes in the buffer to 0
    memset(packetBuffer, 0, NTP_PACKET_SIZE);
    // Initialize values needed to form NTP request
    // (see URL above for details on the packets)
    packetBuffer[0] = 0b11100011; // LI, Version, Mode
    packetBuffer[1] = 0; // Stratum, or type of clock
    packetBuffer[2] = 6; // Polling Interval
    packetBuffer[3] = 0xEC; // Peer Clock Precision
    // 8 bytes of zero for Root Delay & Root Dispersion
    packetBuffer[12] = 49;
    packetBuffer[13] = 0x4E;
    packetBuffer[14] = 49;
    packetBuffer[15] = 52;
    // all NTP fields have been given values, now
    // you can send a packet requesting a timestamp:
    Udp.beginPacket(address, 123); //NTP requests are to port 123
    Udp.write(packetBuffer, NTP_PACKET_SIZE);
    Udp.endPacket();
}
/*F********************************************************************
*
**********************************************************************/
void 
morethen12() 
{
    formattedTimehour = formattedTimehour - 12;
}
/*F********************************************************************
*
**********************************************************************/
void 
lessthenone() 
{
    formattedTimehour = formattedTimehour + 12;
}