#ifdef CONFIG_BOOTLOADER_MCUBOOT
#include "os_mgmt/os_mgmt.h"
#include "img_mgmt/img_mgmt.h"
#endif
/*****************************************************************************
* Section: Included Files
*****************************************************************************/
#define QLENGTH  120
#define MAXDATAFRMSIZE 45

K_TIMER_DEFINE(msec_timer,msectimerCB,NULL);
K_TIMER_DEFINE(onesec,onesecCB,NULL);

tm_u8_t debugstr[DEBUGSTRLEN];
tm_u8_t sver[8] = "1.12";
rx_mcu_buff tm_rx_buff;

bt_addr_le_t mac_address[1];
tm_u8_t macadd[50];
size_t MACcount = 1;
tm_u8_t macid[18];
tm_u8_t rxbuf[2000];
uint8_t mac_id[26] = {0};
uint8_t time_cnt=0;
uint16_t rxbuflen;
char send_data[10] = {"{SHOW IMEI}"};
char rx_Buff_len[10]={"BUFF_LEN: "};
const struct device *uartDev;
struct bt_conn *conn;
static struct bt_conn *default_conn;
tm_instance_t AppInstance;

//struct uart_data uartData;
/* extern Variables */
extern tm_btctrl_t *pBtCtrl;
extern volatile int tm_flag;

extern volatile int FOTA_Flag;

struct sensor_data_type_t
{
  uint8_t frame_data[45];
  uint8_t frame_len;
};

static tm_u16_t g_queue_rx, g_queue_tx,RxDatandex,g_time_out;
struct sensor_data_type_t    g_sensor_data[QLENGTH]; 

enum tm_datarxstate
{
  LOOKFOR_BEGIN=0
  ,GET_DATA 
  ,LOOKFOR_VEHICALID  
};
typedef enum tm_datarxstate tm_datarxstate_t;
tm_datarxstate_t RxDataState;


/*******************************************************************************************************
Function:

    void main(void)

  Summary:
    calling all the events.
  Description:
    This function initilize all the peripirals and ble advertise the ble device.
*********************************************************************************************************/
static void connected(struct bt_conn *conn, uint8_t err)
{
	char addr[BT_ADDR_LE_STR_LEN];
  int secure_level=0;
  int secure_status=0;
	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	if (err) {
		printk("Failed to connect to %s (%u)\n\r", addr, err);
    //DPRINTF(debugstr);
		return;
	}
  else
  {
    printk("{Connected: %s}\n\r", addr);
    //DPRINTF(debugstr);
    default_conn = bt_conn_ref(conn);
    secure_status=bt_conn_set_security(conn, BT_SECURITY_L2);
   if(secure_status)
    {
      printk("Failed to set security\n\r");
    }
    else
    {
       printk("Security Enabled\n\r");
    }
    secure_level=bt_conn_get_security(conn);
    if(secure_level != 0)
    {
      printk("security_level:%d\n\r",secure_level);
      //DPRINTF(debugstr);
    }                                                   //bharath
    else
    {
     printk("security :ZERO(0)\n\r");
    }
   request_conn_param_update(conn);
  } 
}

static void disconnected(struct bt_conn *conn, uint8_t reason)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

  printk("{Disconnected: %s}\n\r", addr);
  //DPRINTF(debugstr);
  if (default_conn) {
        bt_conn_unref(default_conn);
        default_conn = NULL;}
}

BT_CONN_CB_DEFINE(conn_callbacks) = {
	.connected = connected,
	.disconnected = disconnected,

};
#endif

static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	printk("Passkey for %s: %06u\n\r", addr, passkey);
  //DPRINTF(debugstr);
}

static void auth_cancel(struct bt_conn *conn)
{
	char addr[BT_ADDR_LE_STR_LEN];

	bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

	printk("Pairing cancelled: %s\n\r", addr);
  //DPRINTF(debugstr);
}

static void passkey_cb(struct bt_conn *conn, unsigned int num)
{
    printk("Passkey callback: %u\n\r", num);
    //DPRINTF(debugstr);
    if (num == 0) {
        bt_conn_auth_passkey_entry(conn, FIXED_PASSKEY);  // Enter the fixed passkey
    }
}

static void pairing_complete(struct bt_conn *conn, bool bonded)
{
  int err;
	printk("Pairing Complete\n\r");
  err=settings_save();
  if(err)
  {
    printk("failed to save settings\n\r");
  }
  else
  {
    printk("settings saved\n\r");
  }
}

static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
{
	printk("Pairing Failed (%d). Disconnecting.\n\r", reason);
  //DPRINTF(debugstr);
	bt_conn_disconnect(conn, BT_HCI_ERR_AUTH_FAIL);
}

static void pairing_confirm(struct bt_conn *conn)
{
  bt_conn_auth_pairing_confirm(conn);
	printk("Pairing Confirm\n\r");
}

static void passkey_confirm (struct bt_conn *conn, unsigned int passkey)
{
  bt_conn_auth_passkey_confirm(conn);
}

static void pair_delete(uint8_t id, const bt_addr_le_t *peer)
{
  clear_bonds();
}

static struct bt_conn_auth_cb auth_cb_display = {
	.passkey_display = auth_passkey_display,
	//.passkey_entry = passkey_cb,
  .passkey_confirm = passkey_confirm,
  .pairing_confirm=pairing_confirm,
	.cancel = auth_cancel,
	.pairing_complete = pairing_complete,
	.pairing_failed = pairing_failed,
  .bond_deleted = pair_delete,
};
void main(void)
{
  bool adv_status;
  bool boot_status;
  int index=0;
  int err;
  int settig_init_err;
  int setting_load_err;
  int settings_saved;
  int bood_image_conform;
  pBtCtrl = &AppInstance.BtCtrl;
  memset(&AppInstance, 0, sizeof(AppInstance));
  AppInstance.BtCtrl.bConfigUpdate = false;
  /* upgrade FOTA */
  #ifdef CONFIG_BOOTLOADER_MCUBOOT
  os_mgmt_register_group();
  img_mgmt_register_group(); 
  #endif
  #ifdef CONFIG_MCUMGR_SMP_BT
  smp_bt_register();
  #endif
  bood_image_conform=boot_write_img_confirmed();
  if(bood_image_conform)
  {
    printk("new image failed to boot error%d\n\r",bood_image_conform);
  }
  else
  {
    printk("-----new image confirm------\n\r");
  }
  boot_status=boot_is_img_confirmed();
  if(!boot_status)
  {
    printk("boot image failed\n\r");
  }
  /*else
  (
    printk("boot image confirm\n\r");
  )*/
  k_timer_start(&onesec,K_SECONDS(1),K_SECONDS(1));
  k_timer_start(&msec_timer,K_MSEC(20),K_MSEC(20));
  uartDev = device_get_binding("UART_0");  /* uart changed to 1 to test bootloader sequence */
  AppInstance.UartQTx.pUartData = &AppInstance.UartData;
  InitUart(&AppInstance.UartQTx,uartDev,uart_cb);
  //clear_bonds();
 settig_init_err = settings_subsys_init();
 if (settig_init_err)
  {
      printk("Failed to initialize settings subsystem (err %d)\n", settig_init_err);
  }
  RxDataState=LOOKFOR_BEGIN;
  err=bt_enable(NULL);
  if(err)
  {
    printk("{Bluetooth init failed (err %d)}\n\r", err);
    //DPRINTF(debugstr);
    return;
  }
  else
  {
    printk("{Bluetooth initialized}\n\r");
    //DPRINTF(debugstr);
  }
  setting_load_err=settings_load();
  if(setting_load_err)
  {
    printk("settinges loded failed:%d\n\r",setting_load_err);
  }
  else
  {                                                            //bharath
    printk("settinges loded\n\r");
  }
  bt_set_bondable(true);
  bt_conn_auth_cb_register(&auth_cb_display);
  settings_saved=settings_save();
  if(settings_saved)
  {
    printk("failed to save settings(error%d)\n\r",settings_saved);
  }
  else
  {
    printk("settings saved\n\r");   //bharath
  }
  bt_id_get(&mac_address,&MACcount);
  if(MACcount>0)
   {
    bt_addr_le_to_str(mac_address, macid, sizeof(macid)); 
    for (int i = 3; i >= 0; i--)
     {
        index += sprintf(&mac_id[index],"%02x", mac_address[0].a.val[i]);
     }
     strcat(macadd,"{MAC:");
     strcat(macadd,macid);
     strcat(macadd,"}");
     printk(macadd);
   }
  strcpy(AppInstance.BtCtrl.btName, "TM_");
  strcat(AppInstance.BtCtrl.btName,mac_id);
  strcat(AppInstance.BtCtrl.btName,"_v");
  strcat(AppInstance.BtCtrl.btName,sver);
  AppInstance.BtCtrl.btNameLen = strlen(AppInstance.BtCtrl.btName);
  adv_status = bt_start_adv(&AppInstance.BtCtrl);
  if (adv_status)
  {
     printk("BLE STARTED ADVERTISING\n\r");
  }
  else
  {
     printk("BLE STOPPED ADVERTISING\n\r");
  }
  printk("NAME:%s",AppInstance.BtCtrl.btName);
   while (1)
    {
     for(uint8_t i =NUMBEROFEVENTS-1; i>=0; i--)
     {
      if(AppInstance.Events[i]==TM_TRUE)
      { 
        HandleEvents(i);
        AppInstance.Events[i] = TM_FALSE;
        k_sleep(K_MSEC(100)); 
      }
     } 
    }
}