/*
INFORMAZIONI SUI CALCOLI LUNARI
IL MESE LUNARE ED IL MESE SIDEREO
La Luna ha il tempo di rotazione e quello di rivoluzione coincidenti,
è il motivo per cui mostra alla Terra sempre la stessa "faccia".
Il tempo impiegato dalla Luna per riallinearsi nel cielo con una stella precisa
è detto Mese Sidereo (o Rivoluzione Siderea) e dura poco più di 27 giorni.
Il tempo impiegato dalla Luna per riallinearsi con la Terra è invece
detto Mese Lunare (anche Lunazione oppure Rivoluzione Sinodica)
e dura poco più di 29 giorni. Vi è per questo motivo uno scarto di circa 2
giorni fra i due tipi di allineamento.

NUMERO AUREO E ANNO LUNARE
Fu scoperto da Metone nel V sec. a.c. che il ciclo di rivoluzioni e rotazioni
lunari torna nella medesima posizione siderea circa ogni 19 anni, 
ricominciando il ciclo nelle medesime posizioni del ciclo precedente.
E' la conseguenza di quello scarto di circa 2 giorni tra Mese Lunare e Sidereo. 
Il Ciclo Metoniano viene così determinato matematicamente grazie
al cosiddetto Numero d'Oro (o Aureo), un numero assegnato ad ogni singolo anno
che va da 1 a 19 ed è calcolabile, è dunque il numero dell'Anno Lunare in corso.

EPATTA ANNUALE
"Patta", termine volgare da "Epatta", derivante dal latino "Epacta" 
a sua volta derivante dal greco "Epaktos", "aggiunto".
E' un metodo per calcolare i cicli lunari correggendo i dati solari,
possiamo infatti considerarla un fattore di correzione.
L'Epatta è L'età della Luna al 31/12 dell'anno precedente e vale come
Epatta dell'intero anno nuovo, per essere calcolata viene spesso 
desunta utilizzando il Numero Aureo dell'anno in corso.
Gli anni bisestili non sono influenti e vengono ignorati in quanto non
influenzano il calcolo dell'Epatta.

UN PO' DI STORIA
L'Epatta era utilizzata fin dall'Epoca Classica, dopo Metone fu Dionigi
il Piccolo a ricalcolare l'Anno Lunare e l'Epatta.
L'Epatta fu utilizzata prima con il Calendario Giuliano e poi fu 
corretta nuovamente nel 325 d.c. durante il Concilio di Nicea, 
dunque nel 1582 con l'attuazione del Calendario Gregoriano ancora in
uso oggi, Papa Gregorio XIII apportò ulteriori correzioni al
calcolo dell'Anno Lunare oltre a quello dell'Anno Solare.
L'Anno Lunare, l'Epatta ed il Numero Aureo sono stati rivisti più
volte dal Medioevo in poi soprattuto dal Clero, in quanto il
ciclo lunare è fondamentale per il calcolo della Pasqua e di altre
ricorrenze religiose. 
Possiamo dire che alle origini l'Epatta Annuale corrispondesse 
al numero di giorni da aggiungere all'Anno Lunare per parificarsi 
a quello Solare, ma in epoca Gregoriana lo studioso Luigi Lilio la 
modificò rendendola il fattore matematico correttivo che oggi vediamo,
ad essere precisi quindi il calcolo è ormai basato sull'Epatta Liliana.
Dopo l'anno 1000 avvenne il Grande Scisma con la Chiesa Ortodossa, 
quest'ultima continuò ad utilizzare il Calendario Giuliano e dunque
un calcolo dell'Epatta e dei Cicli Lunari basati ancora su di esso,
rifiutando il Calendario Gregoriano.
I calcoli dei Cicli Lunari e delle Fasi sono rimasti in uso anche
tra la gente comune nel corso dei secoli, soprattutto per coloro
che utilizzavano tali cicli per regolare il proprio lavoro, come
ad esempio i contadini, che spesso tramandavano oralmente il modo
di calcolo dell'Epatta e della Fase, ma ha sempre avuto anche un
significato esoterico molto importante per l'astrologia e
l'alchimia, rimanendo perfino nella superstizione popolare attuale,
solo in parte confermata dalla Scienza visto che la Luna 
effettivamente influisce fisicamente con la Terra.

EPATTA MENSILE
Esiste un'Epatta Mensile, calcolata tenendo conto del mese lunare e 
del suo scarto con i mesi solari (gregoriani), così si parte da 0 a 
Gennaio, poi 1 a Febbraio, ma a Marzo il ciclo riprende da 0, poiché
il Primo Marzo si verifica il Capodanno Lunare, e Febbraio che lo 
precede possiede 28-29 giorni soltanto rispetto agli altri mesi, fino a 
Dicembre che a questo punto varrà 10, tra Agosto (5) e Settembre (7)
vi è un balzo di 2 anziché di 1 unità, poiché il nono mese è preceduto 
da  due mesi di 31 giorni. Quindi in questo calcolo dell'Epatta Mensile 
0 e 1 si ripetono due volte ed il numero 6 viene saltato.

L'ETA' LUNARE
l'Età della Luna o Giorno Lunare è il giorno in cui la Luna si trova
all'interno del suo ciclo di 29. In realtà il Mese Lunare è composto
da 30 giorni, dal giorno 0 al giorno 29, nel giorno 0 la Luna rinasce
ed è quindi "Nuova", mentre al giorno 15, a metà del mese, la Luna
sarà completamente visibile e dunque "Piena".

LE FASI LUNARI
Le fasi lunari sono classicamente otto, in ordine: Luna Nuova, Luna
Crescente, Primo Quarto, Luna Gibbosa Crescente, Luna Piena, Luna
Gibbosa Calante, Ultimo Quarto, Luna Calante.
Conoscendo l'Età Lunare è possibile calcolare con facilità le Fasi,
se nel giorno 0 del Mese Lunare la Luna è Nuova (0%), tra l'1 ed 
il 6 la Luna sarà "Crescente", tra il 7 e l'8 sarà ancora Crescente 
ma al suo "Primo Quarto" (50%), tra il 9 ed il 14 sarà sempre
Crescente ma anche "Gibbosa", il giorno 15 sarà "Luna Piena" (100%),
tra il 16 ed il 21 sarà "Calante", tra il 22 ed il 23 sarà ancora
Calante ma nel suo "Ultimo Quarto" (50%), tra il 24 ed il 29, quindi
al finire del Mese Lunare, la Luna sarà ancora Calante ma anche 
"Gibbosa". Il ciclo dunque riprenderà con un nuovo giorno 0 e con una
Luna Nuova.


FONTI:
http://utenti.quipo.it/base5/scienze/etaluna.htm
http://calendario.eugeniosongia.com/epatta.htm
http://calendario.eugeniosongia.com/numerodoro.htm
http://www.marcopersichetti.it/joomla/index.php/calcolo-delle-fasi-lunari
https://it.wikipedia.org/wiki/Fasi_lunari
https://www.studiamo.it/pages/curiosita-e-tempo-libero-fasi-lunari-e-patta/
https://it.wikipedia.org/wiki/Epatta
https://books.google.it/books?id=hsU8wQCNH3UC&printsec=frontcover&hl=it&source=gbs_ge_summary_r&cad=0#v=onepage&q&f=false
*/

#include "Adafruit_SH110X.h"
#include "RTClib.h"

#include "img_fasi.h"

Adafruit_SH1106G display = Adafruit_SH1106G(128, 64, &Wire, -1);

RTC_DS1307 rtc;

char giorno_settimana[7][12] = {"Domenica", "Lunedi'", "Martedi'", "Mercoledi'", "Giovedi'", "Venerdi'", "Sabato"};

signed int anno_corrente;
byte mese_corrente;
byte giorno_solare;
byte epatta_anno;
byte epatta_mese;
byte giorno_lunare;
String fase;

void setup() {
  display.begin(0x3c);
  display.clearDisplay();

  if (! rtc.begin()) {
    Serial.println(F("La batteria dell'orologio è scarica!"));
    Serial.flush();
    abort();
  }
  
  //rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); //NECESSARIO? BOH!

  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  display.setTextSize(1);
  display.setTextColor(SH110X_WHITE);
  display.setCursor(0, 0);

  DateTime now = rtc.now();

  anno_corrente = now.year();
  mese_corrente = now.month();
  giorno_solare = now.day();

  display.fillRect(0, 0, 127, 15, 0); //metodo per refreshare solo una porzione di schermo (ora e data)

  display.print(giorno_settimana[now.dayOfTheWeek()]);
  display.print(F(" "));
  char buff_day[] = "DD/MM/YYYY";
  display.println(now.toString(buff_day));
  display.print(F("ore "));
  char buff_sec[] = "hh:mm:ss";
  display.print(now.toString(buff_sec));

  display.drawLine(0, 17, 127, 17, 1);
  display.setCursor(0, 19);

  calcolo_epatta_annuale();
  display.print(F("Epatta Annuale    "));
  display.println(epatta_anno);
  
  calcolo_epatta_mensile();
  display.print(F("Epatta Mensile    "));
  display.println(epatta_mese);

  calcolo_giorno_lunare();
  display.print(F("Giorno Lunare     "));
  display.println(giorno_lunare);

  display.drawLine(0, 44, 127, 44, 1);
  display.setCursor(0, 51);

  calcolo_fase_lunare();
  display.println(fase);

  display.drawLine(104, 17, 104, 63, 1);
  display.setCursor(0, 46);

  led_fase_lunare();

  //immagine della Fase Lunare
  if (giorno_lunare == 0) display.drawBitmap(108, 48, luna_nuova, 14, 14, 1);
  else if (giorno_lunare >= 1 && giorno_lunare <= 6) display.drawBitmap(108, 48, crescente, 14, 14, 1);
  else if (giorno_lunare >= 7 && giorno_lunare <= 8) display.drawBitmap(108, 48, primo_quarto, 14, 14, 1);
  else if (giorno_lunare >= 9 && giorno_lunare <= 14) display.drawBitmap(108, 48, gibbosa_crescente, 14, 14, 1);
  else if (giorno_lunare == 15) display.drawBitmap(108, 48, luna_piena, 14, 14, 1);
  else if (giorno_lunare >= 16 && giorno_lunare <= 21) display.drawBitmap(108, 48, gibbosa_calante, 14, 14, 1);
  else if (giorno_lunare >= 24 && giorno_lunare <= 29) display.drawBitmap(108, 48, calante, 14, 14, 1);
  else if (giorno_lunare >= 22 && giorno_lunare <= 23) display.drawBitmap(108, 48, ultimo_quarto, 14, 14, 1);

  display.display();

  if (now.hour() == 0 && now.minute() == 0 && now.second() == 0) display.clearDisplay(); //ad un dato orario lo schermo si aggiorna
}

signed int calcolo_epatta_annuale() {
    //CALCOLO DELL'EPATTA ANNUALE COSI' COME VENNE CORRETTA IN EPOCA GREGORIANA
  byte oro = (anno_corrente % 19) + 1; //Anno del Ciclo Metoniano, corrisponde all'Anno Lunare nel suo ciclo di 19 anni
  signed int a = ((oro * 11) - 10) % 30;
  byte secolare = anno_corrente / 100;
  byte b = secolare - 15;
  signed int c = (b - (b / 25)) / 3;
  signed int d = (b * 3) / 4;
  signed int e = (d - c) % 30;
  if ( a >= e) epatta_anno = a - e;
  else if (a < e) epatta_anno = 30 - (e - a);
  return epatta_anno;
}

signed int calcolo_epatta_mensile() {
    //CALCOLO DELL'EPATTA MENSILE
  switch(mese_corrente) {
    case 1: epatta_mese = 0;
    break;
    case 2: epatta_mese = 1;
    break;
    case 3: epatta_mese = 0; //il mese di Marzo ha di nuovo Epatta 0 perché il 1° del mese avviene il Capodanno Lunare e Febbraio che lo precede ha meno giorni degli altri mesi
    break;
    case 4: epatta_mese = 1;
    break;
    case 5: epatta_mese = 2;
    break;
    case 6: epatta_mese = 3;
    break;
    case 7: epatta_mese = 4;
    break;
    case 8: epatta_mese = 5;
    break;
    case 9: epatta_mese = 7; //il mese di Settembre somma due unità invece che una e passa a 7 perché preceduto da due mesi di 31 giorni
    break;
    case 10: epatta_mese = 8;
    break;
    case 11: epatta_mese = 9;
    break;
    case 12: epatta_mese = 10;
    break;
    default: {
      Serial.println(F("I mesi sono solo 12! Hai sbagliato a digitare! L'Epatta Mensile risulterà errata!"));
      Serial.flush();
    }
    break;
  }
}

signed int calcolo_giorno_lunare() {
    //CALCOLO DELL'ETA' DELLA LUNA, GIORNO DEL CICLO LUNARE
  giorno_lunare = (giorno_solare + epatta_mese + epatta_anno) % 30;
  return giorno_lunare;
}

void calcolo_fase_lunare() {
    //CALCOLO DELLA FASE LUNARE IN BASE ALL'ETA' DELLA LUNA
  if (giorno_lunare == 0) fase = F("Luna Nuova");
  else if (giorno_lunare >= 1 && giorno_lunare <= 6) fase = F("Crescente");
  else if (giorno_lunare >= 7 && giorno_lunare <= 8) fase = F("Primo Quarto");
  else if (giorno_lunare >= 9 && giorno_lunare <= 14) fase = F("Gibbosa Crescente");
  else if (giorno_lunare == 15) fase = F("Luna Piena");
  else if (giorno_lunare >= 16 && giorno_lunare <= 21) fase = F("Gibbosa Calante");
  else if (giorno_lunare >= 24 && giorno_lunare <= 29) fase = F("Calante");
  else if (giorno_lunare >= 22 && giorno_lunare <= 23) fase = F("Ultimo Quarto");
}

void led_fase_lunare() {
    //ACCENSIONE LED SECONDO FASE LUNARE
  if (giorno_lunare >= 1 && giorno_lunare <= 6) digitalWrite(6, HIGH);
  else if (giorno_lunare >= 7 && giorno_lunare <= 8) {digitalWrite(6, HIGH); digitalWrite(7, HIGH);}
  else if (giorno_lunare >= 9 && giorno_lunare <= 14) {digitalWrite(6, HIGH); digitalWrite(7, HIGH); digitalWrite(8, HIGH);} 
  else if (giorno_lunare == 15) {digitalWrite(6, HIGH); digitalWrite(7, HIGH); digitalWrite(8, HIGH); digitalWrite(9, HIGH);}
  else if (giorno_lunare >= 16 && giorno_lunare <= 21) {digitalWrite(7, HIGH); digitalWrite(8, HIGH); digitalWrite(9, HIGH);}
  else if (giorno_lunare >= 24 && giorno_lunare <= 29) {digitalWrite(9, HIGH);}
  else if (giorno_lunare >= 22 && giorno_lunare <= 23) {digitalWrite(8, HIGH); digitalWrite(9, HIGH);}
}