cmake_minimum_required(VERSION 3.13)

# initialize the SDK based on PICO_SDK_PATH
# note: this must happen before project()
include(pico_sdk_import.cmake)

project(pico_W_BLE C CXX ASM) # sets ${CMAKE_PROJECT_NAME}
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

set(PICO_BOARD pico_w)  # needed for Pico-W, otherwise #include "pico/cyw43_arch.h" won't be found

# [Platfrom specific command] Initialize the Raspberry Pi Pico SDK
pico_sdk_init()

set(PROJECT_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
add_compile_options(-include "${PROJECT_ROOT_DIR}/src/IncludeMcuLibConfig.h")

add_executable(${CMAKE_PROJECT_NAME})

# enable USB CDC and disable UART:
pico_enable_stdio_usb(${CMAKE_PROJECT_NAME} 1)
pico_enable_stdio_uart(${CMAKE_PROJECT_NAME} 0)

# add component directories to the list
add_subdirectory(./McuLib)
add_subdirectory(./src)

# generate extra files (map/bin/hex/uf2)
pico_add_extra_outputs(${CMAKE_PROJECT_NAME})

target_link_libraries(
  ${CMAKE_PROJECT_NAME}
  # might have circular library dependencies, see https://stackoverflow.com/questions/45135/why-does-the-order-in-which-libraries-are-linked-sometimes-cause-errors-in-gcc
  SrcLib
  McuLib
  SrcLib  # again because of FreeRTOShooks.c
  pico_stdlib
)

# file: Collect all files that need to be compiled. 
file(GLOB FILES
  main.c
  app_platform.c
  application.c
  Shell.c
  FreeRTOShooks.c
  ble_client.c
  ble_server.c
  PicoWiFi.c
  ntp_client.c
  dns_resolver.c
)

# add_library: With this declaration, you express the intent to build a library. 
# The first argument is the name of the library, 
# the second argument are the files that will be compiled to create your library.
add_library(SrcLib ${FILES})

# need to add custom compile flags
target_compile_definitions(SrcLib PRIVATE
  CYW43_ENABLE_BLUETOOTH=1  # otherwise cyw43_arch_init() will not initialize BLE
)

# target_link_libraries: If you link with other libraries, list them here
target_link_libraries(
  SrcLib                # this library
  McuLib                # we need the McuLib
  pico_stdlib           # pico standard library
  hardware_adc          # internal temperature and ADC
  pico_btstack_ble      # BLE stack
  pico_btstack_cyw43    # BLE stack with CYW43
  pico_cyw43_arch_lwip_sys_freertos  # full lwIP stack including blocking sockets, with NO_SYS=0
)

# target_include_directories: Libraries need to publish their header files 
# so that you can import them in source code. This statement expresses where to find the files 
# - typically in an include directory of your projects.
target_include_directories(SrcLib PUBLIC .)

pico_btstack_make_gatt_header(SrcLib PRIVATE "${CMAKE_CURRENT_LIST_DIR}/temp_sensor.gatt")

pico_btstack_make_gatt_header(SrcLib PRIVATE "${CMAKE_CURRENT_LIST_DIR}/temp_sensor.gatt")

#if !PL_CONFIG_USE_WIFI
static void clientTask(void *pv) {
  /* initialize CYW43 driver architecture (will enable BT if/because CYW43_ENABLE_BLUETOOTH == 1) */
  if (cyw43_arch_init()) {
    McuLog_fatal("failed to initialize cyw43_arch");
    for(;;){}
  }
  BleClient_SetupBLE();
  for(;;) {
    btstack_run_loop_execute(); /* does not return */
  }
}
#endif

void BleClient_Init(void) {
#if !PL_CONFIG_USE_WIFI /* if using WiFi, will do the BLE stuff from the WiFi task */
  if (xTaskCreate(
      clientTask,  /* pointer to the task */
      "BLEclient", /* task name for kernel awareness debugging */
      1200/sizeof(StackType_t), /* task stack size */
      (void*)NULL, /* optional task startup argument */
      tskIDLE_PRIORITY+2,  /* initial priority */
      (TaskHandle_t*)NULL /* optional task handle to create */
    ) != pdPASS)
  {
    McuLog_fatal("failed creating task");
    for(;;){} /* error! probably out of memory */
  }
#endif
}

void BleClient_SetupBLE(void) {
  l2cap_init(); /* Set up L2CAP and register L2CAP with HCI layer */
  sm_init(); /* setup security manager */
  sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT); /* set security manager that we want to connect automatically */
  gatt_client_init(); /* initialize client */

  hci_event_callback_registration.callback = &hci_event_handler; /* configure callback structure */
  hci_add_event_handler(&hci_event_callback_registration); /* register callback */

  /* setup timer */
#if PL_CONFIG_USE_WIFI /* use cyw43/lwip timer */
  async_context_add_at_time_worker_in_ms(cyw43_arch_async_context(), &heartbeat_worker, LED_SLOW_FLASH_DELAY_MS);
#else /* use BTStack timer */
  heartbeat.process = &heartbeat_handler;
  btstack_run_loop_set_timer(&heartbeat, LED_SLOW_FLASH_DELAY_MS);
  btstack_run_loop_add_timer(&heartbeat);
#endif
  hci_power_control(HCI_POWER_ON); /* turn it on */
}

#if PL_CONFIG_USE_WIFI
  static void heartbeat_handler(async_context_t *context, async_at_time_worker_t *worker);
  static async_at_time_worker_t heartbeat_worker = { .do_work = heartbeat_handler };

  static void heartbeat_handler(async_context_t *context, async_at_time_worker_t *worker) {
    bool useShortDelay;

    useShortDelay = callbackToggleLED();
    /* restart timer */
    async_context_add_at_time_worker_in_ms(context, &heartbeat_worker, useShortDelay?LED_QUICK_FLASH_DELAY_MS:LED_SLOW_FLASH_DELAY_MS);
  }
#else
  static btstack_timer_source_t heartbeat;

  static void heartbeat_handler(struct btstack_timer_source *ts) {
    bool useShortDelay;

    useShortDelay = callbackToggleLED();
    /* restart timer */
    btstack_run_loop_set_timer(ts, useShortDelay?LED_QUICK_FLASH_DELAY_MS:LED_SLOW_FLASH_DELAY_MS);
    btstack_run_loop_add_timer(ts);
  }
#endif

#define HEARTBEAT_PERIOD_MS 1000

static btstack_packet_callback_registration_t hci_event_callback_registration;

static void callbackSendData(void) { /* callback is called every second */
  static uint32_t counter = 0;
  counter++;
  if ((counter%10) == 0) { /* Update the temperature every 10s */
    poll_temperature();
    if (le_notification_enabled) {
      att_server_request_can_send_now_event(con_handle);
    }
  }
}

static void callbackToggleLED(void) { /* called every second */
  /* Invert the led */
  static int led_on = true;
  led_on = !led_on;
  cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, led_on);
}

#if PL_CONFIG_USE_WIFI
  static void heartbeat_handler(async_context_t *context, async_at_time_worker_t *worker);
  static async_at_time_worker_t heartbeat_worker = { .do_work = heartbeat_handler };

  static void heartbeat_handler(async_context_t *context, async_at_time_worker_t *worker) {
    callbackSendData();
    callbackToggleLED();
    /* restart timer */
    async_context_add_at_time_worker_in_ms(context, &heartbeat_worker, HEARTBEAT_PERIOD_MS);
  }
#else
  static btstack_timer_source_t heartbeat;

  static void heartbeat_handler(struct btstack_timer_source *ts) {
    callbackSendData();
    callbackToggleLED();
    /* restart timer */
    btstack_run_loop_set_timer(ts, HEARTBEAT_PERIOD_MS);
    btstack_run_loop_add_timer(ts);
  }
#endif

void BleServer_SetupBLE(void) {
  l2cap_init(); /* Set up L2CAP and register L2CAP with HCI layer */
  sm_init(); /* setup security manager */
  att_server_init(profile_data, att_read_callback, att_write_callback); /* setup attribute callbacks */

  /* inform about BTstack state */
  hci_event_callback_registration.callback = &packet_handler; /* setup callback for events */
  hci_add_event_handler(&hci_event_callback_registration); /* register callback handler */

  /* register for ATT event */
  att_server_register_packet_handler(packet_handler); /* register packet handler */

  /* setup timer */
#if PL_CONFIG_USE_WIFI /* use cyw43 timer */
  async_context_add_at_time_worker_in_ms(cyw43_arch_async_context(), &heartbeat_worker, HEARTBEAT_PERIOD_MS);
#else /* use BTStack timer */
  heartbeat.process = &heartbeat_handler;
  btstack_run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
  btstack_run_loop_add_timer(&heartbeat);
#endif
  hci_power_control(HCI_POWER_ON); /* turn BLE on */
}

static void SetupTemperatureSensor(void) {
  /* Initialize adc for the temperature sensor */
  adc_init();
  adc_select_input(ADC_CHANNEL_TEMPSENSOR);
  adc_set_temp_sensor_enabled(true);
}

#if !PL_CONFIG_USE_WIFI /* if using WiFi, will do the BLE stuff from the WiFi task */
static void serverTask(void *pv) {
  /* initialize CYW43 driver architecture (will enable BT if/because CYW43_ENABLE_BLUETOOTH == 1) */
  if (cyw43_arch_init()) {
    McuLog_fatal("failed to initialize cyw43_arch");
    for(;;) {}
  }
  BleServer_SetupBLE();
  for(;;) {
    btstack_run_loop_execute(); /* does not return */
  }
}
#endif /* !PL_CONFIG_USE_WIFI */

void BleServer_Init(void) {
  SetupTemperatureSensor();
#if !PL_CONFIG_USE_WIFI /* if using WiFi, will do the BLE stuff from the WiFi task */
  if (xTaskCreate(
      serverTask,  /* pointer to the task */
      "BLEserver", /* task name for kernel awareness debugging */
      1200/sizeof(StackType_t), /* task stack size */
      (void*)NULL, /* optional task startup argument */
      tskIDLE_PRIORITY+2,  /* initial priority */
      (TaskHandle_t*)NULL /* optional task handle to create */
    ) != pdPASS)
  {
    McuLog_fatal("failed creating task");
    for(;;){} /* error! probably out of memory */
  }
#endif
}

static void WiFiTask(void *pv) {
  int res;
  bool ledIsOn = false;

#if CONFIG_USE_EEE
  if (networkMode == WIFI_PASSWORD_METHOD_WPA2) {
    McuLog_info("using WPA2");
  }
#endif

  McuLog_info("started WiFi task");
  /* initialize CYW43 architecture
      - will enable BT if CYW43_ENABLE_BLUETOOTH == 1
      - will enable lwIP if CYW43_LWIP == 1
   */
  if (cyw43_arch_init_with_country(CYW43_COUNTRY_SWITZERLAND)!=0) {
    McuLog_error("failed setting country code");
    for(;;) {}
  }
#if PL_CONFIG_USE_BLE && PL_CONFIG_STANDALONE_BLE_SERVER
  BleServer_SetupBLE();
#elif PL_CONFIG_USE_BLE && PL_CONFIG_STANDALONE_BLE_CLIENT
  BleClient_SetupBLE();
#endif
  wifi.isInitialized = true;
#if PL_CONFIG_USE_WIFI
  McuLog_info("enabling STA mode");
  cyw43_arch_enable_sta_mode();
#if PL_CONFIG_USE_MINI
  McuMinINI_ini_gets(NVMC_MININI_SECTION_WIFI, NVMC_MININI_KEY_WIFI_HOSTNAME, WIFI_DEFAULT_HOSTNAME, wifi.hostname, sizeof(wifi.hostname), NVMC_MININI_FILE_NAME);
  McuMinINI_ini_gets(NVMC_MININI_SECTION_WIFI, NVMC_MININI_KEY_WIFI_SSID,     WIFI_DEFAULT_SSID,     wifi.ssid, sizeof(wifi.ssid), NVMC_MININI_FILE_NAME);
  McuMinINI_ini_gets(NVMC_MININI_SECTION_WIFI, NVMC_MININI_KEY_WIFI_PASS,     WIFI_DEFAULT_PASS,     wifi.pass, sizeof(wifi.pass), NVMC_MININI_FILE_NAME);
#else
  McuUtility_strcpy(wifi.hostname, sizeof(wifi.hostname), WIFI_DEFAULT_HOSTNAME);
  McuUtility_strcpy(wifi.ssid, sizeof(wifi.ssid), WIFI_DEFAULT_SSID);
  McuUtility_strcpy(wifi.pass, sizeof(wifi.pass), WIFI_DEFAULT_PASS);
#endif
  McuLog_info("setting hostname: %s", wifi.hostname);
  netif_set_hostname(&cyw43_state.netif[0], wifi.hostname);

  vTaskDelay(pdMS_TO_TICKS(1000)); /* give network tasks time to start up */

  McuLog_info("connecting to SSID '%s'...", wifi.ssid);
  res = cyw43_arch_wifi_connect_timeout_ms(wifi.ssid, wifi.pass, CYW43_AUTH_WPA2_AES_PSK, 20000);
  if (res!=0) {
    for(;;) {
      McuLog_error("connection failed after timeout! code %d", res);
      vTaskDelay(pdMS_TO_TICKS(30000));
    }
  } else {
    McuLog_info("success!");
    wifi.isConnected = true;
  #if PL_CONFIG_USE_NTP_CLIENT
    NtpClient_TaskResume();
  #endif
  #if PL_CONFIG_USE_MQTT_CLIENT
    MqttClient_Connect();
  #endif
  }
  for(;;) {
    cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, ledIsOn);
    ledIsOn = !ledIsOn;
    if (wifi.isConnected) {
      vTaskDelay(pdMS_TO_TICKS(1000));
    } else {
      vTaskDelay(pdMS_TO_TICKS(50));
    }
  }
#endif
}

#if PL_CONFIG_USE_BLE && PL_CONFIG_STANDALONE_BLE_SERVER
  BleServer_SetupBLE();
#elif PL_CONFIG_USE_BLE && PL_CONFIG_STANDALONE_BLE_CLIENT
  BleClient_SetupBLE();
#endif