#include <stdio.h>
#include "lwip/err.h"
#include "lwip/apps/sntp.h"
#include "driver/gpio.h"
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "mqtt_client.h"
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <esp_sntp.h>

#define TIMEZONE_OFFSET_S 18000
#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_PASS ""
#define led GPIO_NUM_13
#define max_val 1000

char str1[max_val];
char strftime_buf[64];
bool on= false;
int st_h=0,st_m=0,et_h=0,et_m=0,day=0,status=0; // 
int iteration=0,len;
static EventGroupHandle_t wifi_event_group;
const int WIFI_CONNECTED_BIT = BIT0;
static const char *TOPIC = "srkv99/feeds/story";
static const char *TOPIC2 = "srkv99/feeds/out";
bool message = true;
bool sch_ok=false;
char *str;
int num;
int my_itr=0;
esp_mqtt_client_handle_t client;
///////////////////////////////functions///////////////
void get_char(char *cha);
void show_data();
void check_schedule();
void main_management(const char *recieve_data);



typedef struct{
    int start_hour;
    int start_minute;
    int end_hour;
    int end_minute;
    int day_of_week;
    bool turn_on;
}schedule_t;
int schedules;
schedule_t s;

struct tm timeinfo;
static void my_mqtt_data_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
 const char sch_pub[40];
 esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
 client = event->client;
if(message)
{  
  ets_printf("Please Select Schedules Number 1-5 first, after selection press * on pad");
  message=false;
}
if (strncmp(event->data, "*", 1) == 0) {
                esp_mqtt_client_subscribe(event->client, TOPIC2,0);
                schedules=schedules*10+(str1[0]-'0');
                
                ets_printf("Schedules %d",schedules);
                sprintf(sch_pub,"Number of schedule selected is %d", schedules);
                esp_mqtt_client_publish(event->client,TOPIC2,sch_pub,strlen(sch_pub),0,0);
                iteration=0;   
                ets_printf("BIG ITERATION %d\n",iteration);
                sch_ok=true;
                }

 get_data(event->data);

 if (strncmp(event->data, "#", 1) == 0) {
                printf("Stop receiving data\n");
                esp_mqtt_client_unsubscribe(client, TOPIC);
                iteration=0;
                show_data();
                assign_data();
                //check_schedule();

 }
 
}
void get_data(char *cha)
{
  
  str1[iteration]=*cha;
  ets_printf("SAVING data %c\t",str1[iteration]);
  iteration++;
  ets_printf("ITERATION in GETDATA%d\n",iteration);
  
}
void show_data()
{
  ets_printf("Showing DATA\n");
  int int_num=0;
  for(int j=0;j<24;j++)
  {
    ets_printf("%c\t",str1[j]);
  }
}

/////////////////////////////////////////////
/*void check_schedule()
{
  //int i;
  ets_printf("Checking Schedule....\n");
  //ets_printf("start minute %d\n",s1.start_minute);
  bool start_time=true;
  bool end_time=true;
  const char *data="SRK HERE";
  //bool once=true;
  while(1){
        if(start_time){
            get_current_time();
          vTaskDelay(10000 / portTICK_PERIOD_MS); // wait for 1 second
          }

  if(s[0].start_hour==timeinfo.tm_hour)//&& timeinfo.tm_min==s1.start_minute)
  {
    //while(once)
    {
      ets_printf("Start Hour Works\n");
      start_time=false;
      break;
      
      //once=false;
    }
  
  }
  if(timeinfo.tm_hour==s1.end_hour&& timeinfo.tm_min==s1.end_minute)
  {
    ets_printf("End Hour Works\n");
    end_time=false;
    break;
  }
  
  }
}*/
  /////////////////////////////////////////


void assign_data()
{ 
  int val;
  schedule_t s[schedules];
  ets_printf("schedules %d\n",schedules);
  for(int sch=0;sch<schedules;sch++)
  {
    val=sch*10;

    st_h=0,st_m=0,et_h=0,et_m=0,day=0,status=0;
   for (int i = 2+val; i<4+val; i++) {
       //s[sch].start_hour =  s[sch].start_hour * 10 + (str1[i] - '0'); //start_time_hr
       st_h=st_h*10+(str1[i]-'0');
      // ets_printf("ST_h%d\n",st_h);
    }
    s[sch].start_hour=st_h;
    ets_printf("Start STRUCT hr for %d is %d\n",sch,s[sch].start_hour);
    
    //ets_printf("Start hr %d\n",s[sch].start_hour);
    for (int i = 4+val; i<6+val; i++) {
      //s[sch].start_minute = s[sch].start_minute * 10 + (str1[i] - '0'); //start_time_min
       //ets_printf("SM%c\n",str1[i]);
       st_m=st_m*10+(str1[i]-'0');
    }
    s[sch].start_minute=st_m;
    ets_printf("Start STRUCT MIN for %d is %d\n",sch,s[sch].start_minute);
    //ets_printf("Start min %d\n",s[sch].start_minute);
    for (int i = 6+val; i<8+val; i++) {
     // s[sch].end_hour =  s[sch].end_hour * 10 + (str1[i] - '0'); //end_time_hr
      //ets_printf("EH%c\n",str1[i]);
      et_h=et_h*10+(str1[i]-'0');
    }  
    s[sch].end_hour=et_h;
    ets_printf("END STRUCT hr for %d is %d\n",sch,s[sch].end_hour);
    //ets_printf("end hr %d\n",s[sch].end_hour);
    for (int i = 8+val; i<10+val; i++) {
      //s[sch].end_minute = s[sch].end_minute * 10 + (str1[i] - '0'); //end_time_min
      //ets_printf("EM%c\n",str1[i]);
      et_m=et_m*10+(str1[i]-'0');
    } 
    s[sch].end_minute=et_m;
    ets_printf("END STRUCT min  for %d is %d\n",sch,s[sch].end_minute);
    //ets_printf("end min %d\n",s[sch].end_minute);

    for (int i = 10+val; i<11+val; i++) {
      //s[sch].day_of_week = s[sch].day_of_week* 10 + (str1[i] - '0'); //start_time
      //ets_printf("W%c\n",str1[i]);
      day=day*10+(str1[i]-'0');
    } 
    s[sch].day_of_week=day;
    ets_printf("Week day hr for %d is %d\n",sch,s[sch].day_of_week);
   //ets_printf("day %d",s[sch].day_of_week);

    for (int i = 11+val; i<12+val ; i++) {
     // s[sch].turn_on = s[sch].turn_on * 10 + (str1[i] - '0');
     //ets_printf("TO%c\n",str1[i]);
     status=status*10+(str1[i]-'0');
    }
    s[sch].turn_on=status;
    ets_printf("Status hr  for %d is %d\n",sch,s[sch].turn_on);
   // ets_printf("status %d\n",s[sch].turn_on);

  }
  //check_schedule();
  ets_printf("Checking Schedule....\n");
  //ets_printf("start minute %d\n",s1.start_minute);
  bool start_time=true;
  bool end_time=true;
  const char *data="SRK HERE";
  char message[40];
  int sch_no;
  for(int z=0;z<schedules;z++)
  {
  //bool once=true;
  
  while(1){
        //if(start_time)
        {
            get_current_time();
          vTaskDelay(10000 / portTICK_PERIOD_MS); // wait for 1 second
          }
    
  if(s[z].start_hour==timeinfo.tm_hour&& timeinfo.tm_min==s[z].start_minute)
  {
    //while(once)
    {
      sch_no=z+1;
      ets_printf("Start Hour Works\n");
      ets_printf("ZTERATION%d\n",z);
      sprintf(message, "Schedule number %d is running ",sch_no);
      esp_mqtt_client_publish(client, TOPIC2, message, strlen(message), 1, 0);
      //start_time=false;
      break;
      
      //once=false;
    }
  
  }
  /*if(timeinfo.tm_hour==s1.end_hour&& timeinfo.tm_min==s1.end_minute)
  {
    ets_printf("End Hour Works\n");
    end_time=false;
    break;
  }*/
  
    }
  }

 
}


static esp_err_t mqtt_event_handler_cb(esp_mqtt_event_handle_t event)
{
  esp_mqtt_client_handle_t client;
  client = event->client;
  int msg_id;
  switch(event->event_id){
    case MQTT_EVENT_CONNECTED:
      ets_printf("MQTT_EVENT_CONNECTED");
      msg_id = esp_mqtt_client_subscribe(client,TOPIC,0);
      
    break;
    case MQTT_EVENT_DISCONNECTED:
      ets_printf("MQTT EVENT DISCONNECTED");
    break;
    case MQTT_EVENT_SUBSCRIBED:
      ets_printf("MQTT EVENT SUBSCRIBED msg_id= %d",event->msg_id);  
      
    break;
    case MQTT_EVENT_UNSUBSCRIBED:
      ets_printf("MQTT EVENT UNSUBSCRIBED msg_id = %d",event->msg_id);
      //show_data();
     // check_schedule();
      

    break;  
    case MQTT_EVENT_DATA:
      ets_printf("MQTT_EVENT_DATA");
      my_mqtt_data_handler(NULL, NULL, 0, event);
      /*main_management(event->data);
      if (strncmp(event->data, "#", 1) == 0) {
                printf("Stop receiving data\n");
                esp_mqtt_client_unsubscribe(client, TOPIC);
                iteration=0;
                break; 
          }*/
        break; 
      //ets_printf("Topic: %d %s\n", event->topic_len, event->topic);
      //ets_printf("Data: %d %s\n", event->data_len, event->data);
      //ets_printf("DATA\t %s",event->data);
      //get_data(event->data);
      /*if (strncmp(event->data, "#", 1) == 0) {
                printf("Stop receiving data\n");
                esp_mqtt_client_unsubscribe(client, TOPIC);
                iteration=0;
                break;
          }
        break;
      //str=event->data;
     /* if(*str=='1' || *str=='0')
      {
       
        if(*str=='1')
        {
          on=true;
          led_on_off(on);
        }
        else{
          on=false;
          
          led_on_off(on);
        }
      }*/
    
    case MQTT_EVENT_ERROR:
      ets_printf("MQTT_EVENT_ERROR");
    break;
    default:
            ets_printf("Other event id:%d", event->event_id);
    break;
  }
  return ESP_OK;
}

void main_management(const char *recieve_data)
{

 // esp_mqtt_client_handle_t local_client = client;
  ets_printf("Main management\n");
  //esp_mqtt_client_subscribe(client,TOPIC,0);
  get_data(recieve_data);
  //show_data();
  // void mqtt_sub_and_get_data_unsub(esp_mqtt_client_handle_t client);
  //id decided i=5 cin =id;
  //s1[i].start_hour....s1[i].turn_on
  //s[1],s[2],s[3]....fill in struct array 
  //unsubscribe
    //void mqtt_unsub_and_send_data(){
      //subscribe->new feed
      //esp_mqtt_client-pusblish_data
   // }

  //esp_mqtt_client_handle_t local_client = event->client;
  //esp_mqtt_client_subscribe(client,TOPIC,0);
  //get_data recieveing conditions unsub}
  
}






/*void show_data()
{
  int int_num=0;
  for(int j=0;str1[j]!='#';j++)
  {
    ets_printf("%c\t",str1[j]);
  }
   for (int i = 0; i<2; i++) {
       s1.start_hour =  s1.start_hour * 10 + (str1[i] - '0'); //start_time_hr
    }
    ets_printf("Start hr %d\n",s1.start_hour);
    for (int i = 2; i<4; i++) {
      s1.start_minute = s1.start_minute * 10 + (str1[i] - '0'); //start_time_min
       
    }
    ets_printf("Start min %d\n",s1.start_minute);
    for (int i = 4; i<6; i++) {
      s1.end_hour =  s1.end_hour * 10 + (str1[i] - '0'); //end_time_hr
      
    }  
    ets_printf("end hr %d\n",s1.end_hour);
    for (int i = 6; i<8; i++) {
      s1.end_minute = s1.end_minute * 10 + (str1[i] - '0'); //end_time_min
      
    } 
    ets_printf("end min %d\n",s1.end_minute);
    for (int i = 8; i<9; i++) {
      s1.day_of_week = s1.day_of_week* 10 + (str1[i] - '0'); //start_time
      
    } 
   ets_printf("day %d",s1.day_of_week);
      for (int i = 9; str1[i] != '#'; i++) {
      s1.turn_on = s1.turn_on * 10 + (str1[i] - '0');
    
}
 ets_printf("status %d\n",s1.turn_on);

ets_printf("The integer value is: %d\n", int_num);
  
}*/
void led_on_off(bool b1)
{
  ets_printf("inside led\n");
  
  if(b1==true)
  {
    on=1;
    gpio_set_level(led,1);
    ets_printf("inside led ON \n");
    
  }
  else if(b1==false){
    on=0;
    gpio_set_level(led,0);
     ets_printf("inside led OFF \n");   
  }
}

static void mqtt_app_start(void)
{
  const esp_mqtt_client_config_t mqtt_cfg={
    .uri="mqtt://io.adafruit.com",
    .event_handle=mqtt_event_handler_cb,
    .username="srkv99",
    .password="aio_PgaK15CdWbOGNbg5URFSuJgwtpkz",
  };
  esp_mqtt_client_handle_t client=esp_mqtt_client_init(&mqtt_cfg);
  esp_mqtt_client_start(client);
  //main_management(client);
  
}

static void wifi_event_handler(void* arg, esp_event_base_t event_base,
int32_t event_id, void* event_data)
{
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        esp_wifi_connect();
        xEventGroupClearBits(wifi_event_group, WIFI_CONNECTED_BIT);
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        xEventGroupSetBits(wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void wifi_init_sta(void)
{
    wifi_event_group = xEventGroupCreate();

    tcpip_adapter_init();

    esp_event_loop_create_default();
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);

    esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,
     &wifi_event_handler, NULL);
    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP,
     &wifi_event_handler, NULL);

    wifi_config_t wifi_config = {
        .sta = {
            .ssid = WIFI_SSID,
            .password = WIFI_PASS,
        },
    };
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
    esp_wifi_start();

    ets_printf( "wifi_init_sta finished.\n");
    wifi_config_t current_config;

    EventBits_t bits = xEventGroupWaitBits(wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
    if (bits & WIFI_CONNECTED_BIT) {
       
        esp_wifi_get_config(ESP_IF_WIFI_STA, &current_config);
         ets_printf( "Wi-Fi connected\n");
        ets_printf("Connected to SSID: %s, Password: %s", current_config.sta.ssid, current_config.sta.password);
    } else {
        ets_printf("Failed to connect to Wi-Fi");
    }
}

////////////////////////////////////////////////////////////////////////////////////////////
void initialize_sntp(void)
{
    sntp_setoperatingmode(SNTP_OPMODE_POLL);
    sntp_setservername(0, "pool.ntp.org");
    sntp_init();
    ets_printf("IN initialize\n");
    while (sntp_get_sync_status() == SNTP_SYNC_STATUS_RESET) {
        vTaskDelay(100 / 
        portTICK_PERIOD_MS);
    }
}

void get_current_time(void)
{
    time_t now;
    time(&now);
    localtime_r(&now, &timeinfo);
    //ets_printf("Current time: %02d:%02d:%02d\n", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec);
    timeinfo.tm_sec +=TIMEZONE_OFFSET_S;
    mktime(&timeinfo);
    strftime(strftime_buf, sizeof(strftime_buf), "%c", &timeinfo);
    printf("Current time in Pakistan: %s\n", strftime_buf);
    //ets_printf("Current min in Pakistan: %d\n",timeinfo.tm_min);
}
/////////////////////////////////////////////////////////////////////////////////////
/*void check_schedule()
{
  ets_printf("Checking Schedule....\n");
  ets_printf("start minute %d\n",s1.start_minute);
  bool start_time=true;
  bool end_time=true;
  const char *data="SRK HERE";
  //bool once=true;
  while(1){
        if(start_time){
            get_current_time();
          vTaskDelay(10000 / portTICK_PERIOD_MS); // wait for 1 second
          }

  if(s1.start_hour==timeinfo.tm_hour)//&& timeinfo.tm_min==s1.start_minute)
  {
    //while(once)
    {
      ets_printf("Start Hour Works\n");
      start_time=false;
      break;
      //once=false;
    }
  
  }
  /*if(timeinfo.tm_hour==s1.end_hour&& timeinfo.tm_min==s1.end_minute)
  {
    ets_printf("End Hour Works\n");
    end_time=false;
    break;
  }
  
  }
  ets_printf("AGAIN....Subscribed\n");
  //esp_mqtt_client_subscribe(client, TOPIC2, 0);
  esp_err_t err = esp_mqtt_client_subscribe(client, TOPIC2, 0);
if (err != ESP_OK) {
    ets_printf("Error subscribing to topic\n");
} else {
    ets_printf("Subscribed to topic %s successfully\n");
}
esp_mqtt_client_publish(client, TOPIC2, data, strlen(data), 1, 0);
}*/
//////////////////////////////////////////////////////
void app_main()
{
   gpio_pad_select_gpio(led);
   gpio_set_direction(led, GPIO_MODE_OUTPUT);
   int on=0;
    // Initialize NVS.
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ret;

    ets_printf("ESP_WIFI_MODE_STA\n");

    wifi_init_sta();
    initialize_sntp();
    get_current_time();
    esp_event_loop_create_default();
    mqtt_app_start();   
    
}