// sketch_main.ino

#include "mascat.h"
#include <math.h>




// Redefine PI locally
void decimalToTime(float decimalTime, int& hours, int& minutes) {
  hours = int(decimalTime);
  float fractionalPart = decimalTime - hours;
  minutes = int(fractionalPart * 60);
  //seconds = int((fractionalPart * 3600) - (minutes * 60));
}


void printTime(float decimalTime, int hours, int minutes) {

  Serial.print(hours);
  Serial.print(":");
  if (minutes < 10) {
    Serial.print("0");  // Add leading zero for minutes less than 10
  }
  Serial.print(minutes);
  Serial.print(" ");
}





// Function to convert datetime to Julian Day
double calculateJD(int year, int month, int day, int hour, int minute) {
  double Y = year;
  double M = month;
  double D = day;
  double H = hour;
  double m = minute;
  double z = 7;
  // Adjust for January and February
  if (M <= 2) {
    M = M + 12;
    Y = Y - 1;
  }

  // Prepare special constant B for Gregorian calendar
  double B = 0;
  if ((year > 1582) || ((year == 1582) && ((month > 10) || ((month == 10) && (day >= 15))))) {
    int A = Y / 100;
    B = 2 + (A / 4) - A;
  }

  // Calculate Julian Day
  double JD = 1720994.5 + int(365.25 * Y) + int(30.6001 * (M + 1)) + B + D + ((H * 3600 + m * 60 ) / 86400) - z * 0.04166;
  return JD;
}
void correction_time();
void setup() {

  Serial.begin(115200);
  //   Serial.println(adjust_2_fajr[5]);
  // Define variables for datetime
  int corection_FAJR, corection_ZUHR, corection_ASR, corection_MAGHRIB, corection_ISHA;
  int hour = 12;
  int minute = 0;
  int second = 0;
  int SF = 1;
  int Hu = 12;
  // Call function to calculate Julian Day
  // Define the months and days
  int Next_Year[] = { 2024, 2025, 2026, 2027 };
  int months[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
  String days[] = { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
  double OMAN_TOWNS_COORDS[11][2] = {
    { 58.35, 23.36 },   // Muscat
    { 54.08, 17.019 },  // Salalah
    { 56.50, 23.23 },   // Ibri
    { 57.53, 22.93 },   // Nizwa
    { 56.25, 26.18 },   // Khasab
    { 55.79, 24.25 },   // Al Buraimi
    { 56.73, 24.34 },   // Sohar
    { 57.42, 23.39 },   // Rustaq
    { 59.52, 22.56 },   // Sur
    { 58.52, 22.71 },   // Ibri
    { 56.27, 19.95 }    // Haima
  };
  //for (int c = 0; c < 11; c++) {
  double LAT = OMAN_TOWNS_COORDS[0][1];
  double LONG = OMAN_TOWNS_COORDS[0][0];

  // Print city name and coordinates
  /*switch (c) {
    case 0: Serial.print("Muscat: "); break;
    case 1: Serial.print("Salalah: "); break;
    case 2: Serial.print("Ibri: "); break;
    case 3: Serial.print("Nizwa: "); break;
    case 4: Serial.print("Khasab: "); break;
    case 5: Serial.print("Al Buraimi: "); break;
    case 6: Serial.print("Sohar: "); break;
    case 7: Serial.print("Rustaq: "); break;
    case 8: Serial.print("Sur: "); break;
    case 9: Serial.print("Ibri: "); break;
    case 10: Serial.print("Haima: "); break;}*/



  // Counter for the day of the year
  for (int y = 0; y < 4; y++) {
    int dayOfYear = 1;

    int year = Next_Year[y];


    // Loop through each month
    for (int i = 0; i < 12; i++) {

      //Serial.println("Month: " + months[i]);
      int month = months[i];
      int maxDay;
      if (month == 2) {
        // February: check if it's a leap year
        if (year == 2024 || year == 2028) {
          maxDay = 29;
        } else {
          maxDay = 28;
        }
      } else if (month == 4 || month == 6 || month == 9 || month == 11) {
        // April, June, September, November: 30 days
        maxDay = 30;
      } else {
        // All other months have 31 days
        maxDay = 31;
      }

      // Loop through each day in the month (31 days)
      for (int j = 1; j <= maxDay; j++) {
        if (year != 2024) {
          if (dayOfYear > 365) {
            break;
          }
        } else {
          if (dayOfYear > 366) {
            break;
          }
        }
        int day = j;


        Serial.println(" ");
        //Serial.print(dayOfYear);
        Serial.print(year);
        Serial.print("/");
        Serial.print(months[i]);
        Serial.print("/");
        Serial.print(j);
        Serial.print(", ");
        int m ;
        int dayYear = dayOfYear;
        for ( m = 0; m < dayYear; m++) {
          if (dayYear == correction_3_fajr[y][m]) {
            corection_FAJR = 3;
            /*Serial.print(">>");
            Serial.print(correction_3_fajr[y][m]);*/

          } else if (dayYear == correction_2_fajr[y][m]) {
            corection_FAJR = 2;
           /* Serial.print(">>");
            Serial.print(correction_2_fajr[y][m] );*/

          } else if (dayYear == correction_4_fajr[y][m]) {
            corection_FAJR = 4;
           /* Serial.print(">>");
            Serial.print(correction_4_fajr[y][m]);*/
          }

          if (dayYear == correction_1_zuhr[y][m]) {
            /*  Serial.print("i:");
              Serial.print(i);
              Serial.print(" j:");
              Serial.print(j);
              Serial.print("zu_1_hr>");

              Serial.print(correction_1_zuhr[0][i]);
              Serial.println(" ");*/

            corection_ZUHR = 1;
          } else if (dayYear == correction_2_zuhr[y][m]) {
            /*Serial.print("i:");
              Serial.print(i);
              Serial.print(" j:");
              Serial.print(j);
              Serial.print(" zu_2_hr>");

              Serial.print(correction_2_zuhr[0][i]);
              Serial.println(" ");*/
            corection_ZUHR = 2;
          }

          if (dayYear == correction_5_asr[y][m]) {
            corection_ASR = 5;
          } else if (dayYear == correction_6_asr[y][m]) {
            corection_ASR = 6;
          } else if (dayYear == correction_7_asr[y][m]) {
            corection_ASR = 7;
          }


          if (dayYear == correction_4_maghreb[y][m]) {
            corection_MAGHRIB = 4;

          } else if (dayYear == correction_5_maghreb[y][m]) {
            corection_MAGHRIB = 5;

          } else if (dayYear == correction_6_maghreb[y][m]) {
            corection_MAGHRIB = 6;

          }
        }
        /*Serial.print(" >");

        Serial.print(dayYear);
        Serial.print(">");

        Serial.print(m);*/
        Serial.print(" ");

        Serial.print(corection_FAJR);
        Serial.print(" ");

        Serial.print(corection_ZUHR);
        Serial.print(" ");

        Serial.print(corection_ASR);
        Serial.print(" ");

        Serial.print(corection_MAGHRIB);
        Serial.print(" ");




        //Serial.println(j);}}

        /*for (int i = 0; i < 283 ; i++) {
          if (j ==  adjust_2_fajr[i]) {
            Serial.println("case 2 ");
            break;
          } else if (j == adjust_3_fajr[i]) {
            Serial.println("case 3 ");
            break;
          } else if (j == adjust_4_fajr[i]) {
            Serial.println("case 4 ");
            break;
          }
          }*/




        float JD = calculateJD(year, month, day, hour, minute);


        // Constants for calculations
        const double MY_PI = 3.14159;  // Redefine PI locally
        const double Z = 4;            // Local time zone offset
        // const double LAT = 23;         // Latitude in radians
        //const double LONG = 58;
        // Constants for prayer times angles
        const double FAJR_ANGLE = 18.5;  // Angle for Fajr
        const double ISHA_ANGLE = 90;    // Angle for Isha

        // Calculate T
        double T = 2 * MY_PI * (JD - 2451545) / 365.25;
        //Serial.println("T ");
        //Serial.print(T, 4);

        // Calculate DELTA
        double DELTA = 0.37877 + 23.264 * sin(MY_PI / 180.0 * (57.297 * T - 79.547)) + 0.3812 * sin(MY_PI / 180.0 * (2 * 57.297 * T - 82.682)) + 0.17132 * sin(MY_PI / 180.0 * (3 * 57.297 * T - 59.722));
        //Serial.println("DELTA ");
        //Serial.print(DELTA, 4);

        // Calculate ET and ET1000
        double U = (JD - 2451545) / 36525;
        double L0 = 280.46607 + 36000.7698 * U;
        float sin_L0 = sin(L0 * MY_PI / 180);
        float cos_L0 = cos(L0 * MY_PI / 180);

        float ET1000 = -(1789 + 237 * U) * sin_L0 - (7146 - 62 * U) * cos_L0 + (9934 - 14 * U) * sin(2 * L0 * MY_PI / 180) - (29 + 5 * U) * cos(2 * L0 * MY_PI / 180) + (74 + 10 * U) * sin(3 * L0 * MY_PI / 180) + (320 - 4 * U) * cos(3 * L0 * MY_PI / 180) - 212 * sin(4 * L0 * MY_PI / 180);
        float ET = ET1000 / 1000;
        /* Serial.println("U ");
          Serial.print(U, 4);

          Serial.println("L0 ");
          Serial.print(L0, 4);
          Serial.println("ET1000 ");
          Serial.print(ET1000, 4);
          Serial.println("ET ");
          Serial.print(ET, 4);*/

        // Calculate TT
        double TT = 12 + Z - (LONG / 15) - (ET / 60);  // Assuming Z and LONG are 0 for simplicity
        //Serial.println("TT ");
        //Serial.println(TT, 4);

        // Convert degrees to radians
        float delta_rad = DELTA * M_PI / 180.0;
        float lat_rad = LAT * M_PI / 180.0;

        // Given constants and variables
        double SA_FAJR = -(FAJR_ANGLE);
        double SA_SUNRISE, SA_MAGHRIB;
        //////////////ASR///////////
        double TA_SA_ASR = SF + tan(fabs(delta_rad - lat_rad));
        double AT_SA_ASR = atan(1.0 / TA_SA_ASR);
        double SA_ASR = AT_SA_ASR * 180.0 / M_PI;


        double SA_ISHA = -(ISHA_ANGLE);

        // Given constants and variables
        SA_SUNRISE = -0.8333 - (0.0347 * sqrt(Hu));
        /* Serial.println("SA_ASR ");
          Serial.println(SA_ASR, 4);
          Serial.println("SA_SUNRISE ");
          Serial.println(SA_SUNRISE, 4);*/
        // Declare variables
        double cos_HA_FAJR, cos_HA_MAGHRIB, cos_HA_SUNRISE;
        double cos_HA_ASR, cos_HA_ISHA;

        // Calculate values
        cos_HA_FAJR = (sin(SA_FAJR * MY_PI / 180) - sin(LAT * MY_PI / 180) * sin(DELTA * MY_PI / 180)) / (cos(LAT * MY_PI / 180) * cos(DELTA * MY_PI / 180));
        cos_HA_MAGHRIB = (sin(SA_SUNRISE * MY_PI / 180) - sin(LAT * MY_PI / 180) * sin(DELTA * MY_PI / 180)) / (cos(LAT * MY_PI / 180) * cos(DELTA * MY_PI / 180));
        cos_HA_SUNRISE = (sin(SA_SUNRISE * MY_PI / 180) - sin(LAT * MY_PI / 180) * sin(DELTA * MY_PI / 180)) / (cos(LAT * MY_PI / 180) * cos(DELTA * MY_PI / 180));
        cos_HA_ASR = (sin(SA_ASR * MY_PI / 180) - sin(LAT * MY_PI / 180) * sin(DELTA * MY_PI / 180)) / (cos(LAT * MY_PI / 180) * cos(DELTA * MY_PI / 180));
        cos_HA_ISHA = (sin(SA_ISHA * MY_PI / 180) - sin(LAT * MY_PI / 180) * sin(DELTA * MY_PI / 180)) / (cos(LAT * MY_PI / 180) * cos(DELTA * MY_PI / 180));

        /*Serial.println("cos_HA_FAJR ");
          Serial.println(cos_HA_FAJR, 4);

          Serial.println("cos_HA_MAGHRIB ");
          Serial.println(cos_HA_MAGHRIB, 4);

          Serial.println("cos_HA_ASR ");
          Serial.println(cos_HA_ASR, 4);

          Serial.println("cos_HA_ISHA ");
          Serial.println(cos_HA_ISHA, 4);*/
        // Calculate hour angles
        double HA_FAJR = acos(cos_HA_FAJR) * 180 / MY_PI;
        double HA_SUNRISE, HA_MAGHRIB;
        HA_MAGHRIB = acos(cos_HA_MAGHRIB) * 180 / MY_PI;
        double HA_ASR = acos(cos_HA_ASR) * 180 / MY_PI;
        double HA_ISHA = acos(cos_HA_ISHA) * 180 / MY_PI;
        /*Serial.println("HA_FAJR ");
          Serial.println(HA_FAJR, 4);

          Serial.println("HA_MAGHRIB ");
          Serial.println(HA_MAGHRIB, 4);

          Serial.println("HA_ASR ");
          Serial.println(HA_ASR, 4);

          Serial.println("HA_ISHA ");
          Serial.println(HA_ISHA, 4);*/

        // Calculate other prayer times
        double FAJR = (TT - HA_FAJR / 15) + 0 * 0.0166;
        double SUNRISE = (TT - HA_MAGHRIB / 15) + 0 * 0.0166;
        double ZUHR = TT + (4 + 0) * 0.0166;

        double ASR = (TT + HA_ASR / 15) + 0 * 0.0166;
        double MAGHRIB = (TT + HA_MAGHRIB / 15) + 0 * 0.0166;
        //double ISHA = (TT + HA_ISHA / 15) + corection_ISHA * 0.0166;

        double NEXT_SUNRISE = 24 + SUNRISE;
        double NIGHT_DURATION = NEXT_SUNRISE - MAGHRIB;
        /*double ISHA = MAGHRIB + (NIGHT_DURATION / 2) + FAJR;
          double FAJR1 = SUNRISE - (NIGHT_DURATION / 2);*/

        /*double FAJR1 = SUNRISE - (NIGHT_DURATION * FAJR_ANGLE / 60);
          double ISHA = MAGHRIB + (NIGHT_DURATION * ISHA_ANGLE / 60);*/
        //double FAJR1 = SUNRISE - (NIGHT_DURATION / 7);
        double ISHA = MAGHRIB + (NIGHT_DURATION / 7) + 0 * 0.0166;


        /*  Serial.println("NIGHT_DURATION");
          Serial.println(NIGHT_DURATION);

          Serial.println("FAJR1");
          Serial.println(FAJR1);

          Serial.println("ISHA");
          Serial.println(ISHA);*/


        double prayerTimes[] = { FAJR, ZUHR, ASR, MAGHRIB, ISHA };

        int numPrayerTimes = sizeof(prayerTimes) / sizeof(prayerTimes[0]);  // Calculate the number of elements in the array
        for (int i = 0; i < numPrayerTimes; i++) {

          int hours, minutes;

          decimalToTime(prayerTimes[i], hours, minutes);
          printTime(prayerTimes[i], hours, minutes);
        }
        dayOfYear++;
      }
    }
  }
}


void loop() {
  // put your main code here, to run repeatedly:
}