bool mgos_event_add_handler(int ev, mgos_event_handler_t cb, void *userdata);

// Event handler signature
typedef void (*mgos_event_handler_t)(int ev, void *ev_data, void *userdata);

// Subscription callback
void subscription_callback(void *ev_data, void *userdata) {
  // Subscribing for command "/start"
  mgos_telegram_subscribe("/start", app_telegram_updates_handler, NULL);
}

// Adding handler for TGB_EV_CONNECTED event
mgos_event_add_handler(TGB_EV_CONNECTED, subscription_callback, NULL);

void mgos_telegram_subscribe(const char *data, mgos_telegram_cb_t callback, void *userdata);

// Telegram handler signature
typedef void (*mgos_telegram_cb_t)(void *ev_data MG_UD_ARG(void *userdata));

// Subscribing for all received commands at one subscription
mgos_telegram_subscribe("*", app_telegram_updates_handler, NULL);

// Subscribing for command "/start"
mgos_telegram_subscribe("/start", app_telegram_updates_handler, NULL);

void mgos_telegram_send_message(int32_t chat_id, const char *text);
void mgos_telegram_send_message_with_callback(int32_t chat_id, const char *text, mgos_telegram_cb_t callback, void *userdata);
void mgos_telegram_send_message_json(const char *json);
void mgos_telegram_send_message_json_with_callback(const char *json, mgos_telegram_cb_t callback, void *userdata);

// Callback example
void callback(void *ev_data, void *userdata) {
    // With ev_data param it will be the response from telegram API for sendMessage method
    struct mgos_telegram_response *response = (struct mgos_telegram_response *) ev_data;
    // With userdata param it will be userdata passed earlier to the send message function
    (void) userdata;
}

// Sending simple text messages to the chat/group
mgos_telegram_send_message(111222333, "Hello from Mongoose OS");
// The same with callback
mgos_telegram_send_message_with_callback(111222333, "Hello from Mongoose OS", callback, NULL);

// Build json string according to the native API (here we using frozen parser/emitter lib https://github.com/cesanta/frozen)
char *json = json_asprintf("{chat_id: %d, text: %Q}", 111222333, "Hello from Mongoose OS");
// Sending messages to the chat/group according to the native API
mgos_telegram_send_message_json(json);
// The same with callback
mgos_telegram_send_message_json_with_callback(json, callback, NULL)
free(json);

void mgos_telegram_edit_message_text(int32_t chat_id, int32_t message_id, const char *text);
void mgos_telegram_edit_message_text_json(const char *json);

// Update as simple text message
mgos_telegram_edit_message_text(111222333, 1237, "Updated message from Mongoose OS");

// Build json string according to the native API (here we using frozen parser/emitter lib https://github.com/cesanta/frozen)
char *json = json_asprintf("{chat_id: %d, message_id: %d, text: %Q}", 111222333, 1237, "Updated message from Mongoose OS");
// Update message according to the native API
mgos_telegram_edit_message_text_json(json);

void mgos_telegram_answer_callback_query(const char *id, const char *text, bool alert);
void mgos_telegram_answer_callback_query_json(const char *json);

// Send simple answer
mgos_telegram_answer_callback_query("933786469216003032", "⚠ Command received", false);

// Build json string according to the native API (here we using frozen parser/emitter lib https://github.com/cesanta/frozen)
char *json = json_asprintf("{callback_query_id: %s, text: %s, show_alert: %B}", "933786469216003032", "⚠ Command received", false);
// Send answer according to the native API
mgos_telegram_answer_callback_query_json(json);
free(json);

void mgos_telegram_execute_custom_method(const char *method, const char *json);
void mgos_telegram_execute_custom_method_with_callback(const char *method, const char *json, mgos_telegram_cb_t callback, void *userdata);

// Callback example
void callback(void *ev_data, void *userdata) {
    // With ev_data param it will be the response from telegram API for sendMessage method
    struct mgos_telegram_response *response = (struct mgos_telegram_response *) ev_data;
    // With userdata param it will be userdata passed earlier to the send message function
    (void) userdata;
}

// Build json string according to the native Telegram Bot API (here we using frozen parser/emitter lib https://github.com/cesanta/frozen)
char *json = json_asprintf("{chat_id: %d, text: %Q}", 111222333, "Hello from telegram bot lib");

//For example execute sendMessage method 
mgos_telegram_execute_custom_method("sendMessage", json);

//The same with callback
mgos_telegram_execute_custom_method_with_callback("sendMessage", json, callback, NULL);

#include "mgos.h"
#include "mgos_telegram.h"

void app_start_handler(int ev, void *ev_data, void *userdata);
void app_telegram_updates_handler(void *ev_data, void *userdata);

// Application start handler
void app_start_handler(int ev, void *ev_data, void *userdata) {
  (void) ev;
  (void) ev_data;
  (void) userdata;
  // Subscribe to all received commands at one subscription "*"
  mgos_telegram_subscribe("*", app_telegram_updates_handler, NULL);
  // Or subscribe to certain commands
  // mgos_telegram_subscribe("/start", app_telegram_updates_handler, NULL);
  // mgos_telegram_subscribe("/status", app_telegram_updates_handler, NULL);
}

// Telegram updates handler
void app_telegram_updates_handler(void *ev_data, void *userdata) {
    (void) userdata;
    // The message data will be passed with ev_data param
    // We have to explain what kind of data it is (it will be type of struct mgos_telegram_response)
    struct mgos_telegram_update *update = (struct mgos_telegram_update *) ev_data;
	// Print to the terminal update details 
    LOG(LL_INFO, ("APP ->> chat: %li, data: %s", (long)update->chat_id, update->data));
    // Handle the "/start" command
    if ( strcmp(update->data, "/start") == 0 ) {
        // Send message to the chat
        mgos_telegram_send_message(update->chat_id, "Hello from Mongoose OS");
    }
    // Handle all another commands
    else {
        // Send message back with received text
        mgos_telegram_send_message(update->chat_id, update->data);
    }
    return;
}

// APP INIT FN
enum mgos_app_init_result mgos_app_init(void) {
    // Adding the handler for TGB_EV_CONNECTED event
    mgos_event_add_handler(TGB_EV_CONNECTED, app_start_handler, NULL);
    return MGOS_APP_INIT_SUCCESS;
};

#include "mgos.h"
#include "mgos_telegram.h"

void app_start_handler(int ev, void *ev_data, void *userdata);
char* get_panel_state();
char* get_panel_keyboard();
void update_all_panels();
void app_telegram_updates_handler(void *ev_data, void *userdata);
void app_telegram_response_handler(void *ev_data, void *userdata);

// Control panel element prototype
struct panel_el {
  uint32_t chat_id;
  uint32_t message_id;
  SLIST_ENTRY(panel_el) next;
};

// State struct prototype
struct app_state {
  // Fake relays
  bool alarm;
  bool light;
  // List for storing all panels in all chat
  SLIST_HEAD(panels, panel_el) panels;
};

// Variable for storing the state
struct app_state *state = NULL;

// Function returning current state 
char* get_panel_state() {
  char *res = NULL;
  mg_asprintf(&res, 0, "%s%u\r\n%s%f\r\n%s%s\r\n%s%s",
              "FREE MEM: ", mgos_get_heap_size(),
              "UPTIME: ", mgos_uptime(),              
              "ALARM: ", state->alarm ? "✅ ON" : "❌ OFF",
              "LIGHT: ", state->light ? "✅ ON" : "❌ OFF"
              );
  return res;
}
// Function returning current button state 
char* get_panel_keyboard() {
  char *res = json_asprintf("{inline_keyboard: [[{text: %Q, callback_data: %Q}],[{text: %Q, callback_data: %Q}]]}", 
                state->alarm ? "SWITCH OFF ALARM" : "SWITCH ON ALARM", "/alarm_toggle",
                state->light ? "SWITCH OFF LIGHT" : "SWITCH ON LIGHT", "/light_toggle"
                );
  return res;
}
// Function for update all control panels in all chat
void update_all_panels() {
  // If panels list is empty return
  if (SLIST_EMPTY(&state->panels)) return;
  // Getting current state
  char *text = get_panel_state();
  // Getting current button state 
  char *keyboard = get_panel_keyboard();
  char *json = NULL;
  struct panel_el *panel;
  // Iterate panels list and update each panel
  SLIST_FOREACH(panel, &state->panels, next) {
    json = json_asprintf("{chat_id: %d, message_id: %d, text: %Q, reply_markup: %s}", 
      panel->chat_id, panel->message_id, text, keyboard);
    mgos_telegram_edit_message_text_json(json);
  }
  // Do not forget to free allocated memory
  free(json);
  free(text);
  free(keyboard);
}
// Telegram subscribing handler
void app_start_handler(int ev, void *ev_data, void *userdata) {
  (void) ev;
  (void) ev_data;
  (void) userdata;
  // Subscribe to all received commands at one subscription
  mgos_telegram_subscribe("*", app_telegram_updates_handler, NULL);
  // Or subscribe to certain commands
  // mgos_telegram_subscribe("/menu", app_telegram_updates_handler, NULL);
  // mgos_telegram_subscribe("/alarm_toggle", app_telegram_updates_handler, NULL);
  // mgos_telegram_subscribe("/light_toggle", app_telegram_updates_handler, NULL);
}
// Telegram response handler
void app_telegram_response_handler(void *ev_data, void *userdata) {
  // The message data will be passed with ev_data param
  // We have to explain what kind of data it is (it will be struct mgos_telegram_response)
  struct mgos_telegram_response *response = (struct mgos_telegram_response *) ev_data;
  struct panel_el *new_panel = (struct panel_el *) userdata;
  // Adding message_id to new panel
  new_panel->message_id = response->message_id;
  // Adding new panel to panels list for future updating
  SLIST_INSERT_HEAD(&state->panels, new_panel, next);
}
// Telegram updates handler
void app_telegram_updates_handler(void *ev_data, void *userdata) {
    (void) userdata;
    // The message data will be passed with ev_data param
    // We have to explain what kind of data it is (it will be struct mgos_telegram_update)
    struct mgos_telegram_update *update = (struct mgos_telegram_update *) ev_data;
	// Print to terminal data
    LOG(LL_INFO, ("APP ->> chat: %li, data: %s", (long)update->chat_id, update->data));
    // Handle the "/menu" command
    if ( strcmp(update->data, "/menu") == 0 ) {
	  // Check for existence of the control panel in this chat
      if (!SLIST_EMPTY(&state->panels)) {
        struct panel_el *panel;
        SLIST_FOREACH(panel, &state->panels, next) {
		  // If panel is already exist in this chat - return from function
          if (panel->chat_id == update->chat_id) return;
        };        
      }
      // Else make new panel
      struct panel_el *new_panel = (struct panel_el *) calloc(1, sizeof(*new_panel));
      new_panel->chat_id = update->chat_id;
	  // Getting current state
      char *text = get_panel_state();
	  // Getting current button state
      char *keyboard = get_panel_keyboard();
	  // Generating the message with actual control panel      
      char *json = json_asprintf("{chat_id: %d, text: %Q, reply_markup: %s}", update->chat_id, text, keyboard);
	  // Send message with control panel to the chat
	  // Here we have to handle the response for getting meaasage id for future updating
	  // Also push the new_panel pointer for response handler as userdata
      mgos_telegram_send_message_json_with_callback(json, app_telegram_response_handler, new_panel);
	  // Do not forget to free dynamically allocated memory
      free(text);
      free(keyboard);
      free(json);
      return;
    }
	// Handle the "/alarm_toggle" command
    if ( strcmp(update->data, "/alarm_toggle") == 0 ) {
      state->alarm = !state->alarm;
	  // Send acknowledgment for pushing the inline keyboard button
      mgos_telegram_answer_callback_query(update->query_id, "⚠ Command received", false);
	  // Relay state was changed, call update all panels function
      update_all_panels();
    }
	// Handle the "/light_toggle" command
    if ( strcmp(update->data, "/light_toggle") == 0 ) {
	  // Invert light relay state
      state->light = !state->light;
	  // Send acknowledgment for pushing the inline keyboard button
      mgos_telegram_answer_callback_query(update->query_id, "⚠ Command received", false);
	  // Relay state was changed, call update all panels function
      update_all_panels();
    }
}

// APP INIT FN
enum mgos_app_init_result mgos_app_init(void) {
  // Allocate memory for the state variable	
  state = (struct app_state *) calloc(1, sizeof(*state));
  // Add initial state for the fake relays
  state->alarm = false;
  state->light = false;
  // Add handler for TGB_EV_CONNECTED event
  mgos_event_add_handler(TGB_EV_CONNECTED, app_start_handler, NULL);
  return MGOS_APP_INIT_SUCCESS;
};