#include "mbed.h"
#include "platform/mbed_thread.h"

// define the Serial object
Serial pc(USBTX, USBRX);

// Blinking rate in milliseconds
#define BLINKING_RATE_MS 2000

// Serial baud rate
#define PC_SERIAL_BAUD 115200

int main()
{
    // Initialise the digital pin LED1 as an output
    DigitalOut led(LED1);

    // setup serial connection
    pc.baud(PC_SERIAL_BAUD);

    // Print something over the serial connection
    pc.printf("Running main loop.\r\n");

    while (true) {
        led = !led;
        thread_sleep_for(BLINKING_RATE_MS);
        pc.printf("Blink! LED is now %d\r\n", led.read());
    }
}

// Platform Libs
#include <events/mbed_events.h>
#include <mbed.h>
#include "ble/BLE.h"

// Constants
#define BLINKING_RATE_MS 500               // Blinking rate in milliseconds
#define PC_SERIAL_BAUD 115200               // Serial baud rate
static const int URI_MAX_LENGTH = 18;       // Maximum size of service data in ADV packets

// Global Objects
Serial _pc_serial(USBTX, USBRX);            // define the Serial object
DigitalOut _led1(LED1);              // Initialise the digital pin LED1 as an output
static EventQueue _eventQueue(/* event count */ 16 * EVENTS_EVENT_SIZE);

/* Do blinky on LED1 while we're waiting for BLE events. Called every BLINKING_RATE_MS */
void periodicCallback(void)
{
    _led1 = !_led1;
}

/*
 * This function is called every time we receive an advertisement.
 */
void advertisementCallback(const Gap::AdvertisementCallbackParams_t *params)
{
    _pc_serial.printf("Address: %02x:%02x:%02x:%02x:%02x:%02x, RSSI: %ddBm\t\r\n", params->peerAddr[5], params->peerAddr[4], params->peerAddr[3], params->peerAddr[2], params->peerAddr[1], params->peerAddr[0], params->rssi);
}

/*
 *   Called if there's an error initialising the BLE instance
 */
void onBleInitError(BLE& ble, ble_error_t error)
{
   _pc_serial.printf("Error intitialising BLE object:\r\n%u\r\n", error);
}

/*
 *   Called when the BLE instance is intialiased
 */ 
void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
{
    BLE&        ble   = params->ble;
    ble_error_t error = params->error;

    if (error != BLE_ERROR_NONE) {
        onBleInitError(ble, error);
        return;
    }

    if (ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
        return;
    }
  
    /*
        DEPRECATED BUT EASY WAY OF STARTING A SCAN
     */
    ble.gap().setScanParams(1800 /* scan interval */, 1500 /* scan window */, true /* active scanning */);
    ble.gap().startScan(advertisementCallback);
}

 /*
    Setup the callback method on the event queue
  */
void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) {
    //BLE &ble = BLE::Instance();
    _eventQueue.call(Callback<void()>(&context->ble, &BLE::processEvents));
}

// Main method sets up peripherals, runs infinite loop
int main()
{   
    // setup serial connection
    _pc_serial.baud(PC_SERIAL_BAUD);

    // Print something over the serial connection
    _pc_serial.printf("Serial link setup.\r\n");

    // setup BLE object
    // add LED blinking to the events queue
    _eventQueue.call_every(BLINKING_RATE_MS, periodicCallback);

    // instantiate the BLE object
    BLE &ble = BLE::Instance();
    ble.onEventsToProcess(scheduleBleEventsProcessing);
    ble.init(bleInitComplete);

    // Run
    _pc_serial.printf("Setup done. Running.\r\n");
    _eventQueue.dispatch_forever();

    return 0;
}

/*
    Example BLE scanning application
 */
// Platform Libs
#include <events/mbed_events.h>
#include <mbed.h>
#include "ble/BLE.h"

// Constants
#define BLINKING_RATE_MS        500               // LED blinking rate in milliseconds
#define PC_SERIAL_BAUD          115200            // Serial baud rate

/*
    Active scanning sends scan requests to elicit scan responses
 */
#define ACTIVE_SCANNING         true              

/*
    Scan interval is the time it waits on a single advertising channel
 */
#define SCAN_INTERVAL           1000              

/*
    From the API documentation:
    The scanning window divided by the interval determines the duty cycle for scanning. For example, if the interval is 100ms and the window is 10ms, then the controller will scan for 10 percent of the time. It is possible to have the interval and window set to the same value. In this case, scanning is continuous, with a change of scanning frequency once every interval.
 */
#define SCAN_WINDOW             1000

// Global Objects
static EventQueue event_queue(/* event count */ 16 * EVENTS_EVENT_SIZE);
Serial _pc_serial(USBTX, USBRX);            // define the Serial object

/*
    Inner scanner class
 */
class BLEScanner : ble::Gap::EventHandler {

public:
    // constructor
    BLEScanner(BLE &ble, events::EventQueue &event_queue) :
        _ble(ble),
        _event_queue(event_queue),
        _alive_led(LED1, 1) { }

    // destructor
    ~BLEScanner() { }

    // scan method 
    void scan() {
        // sets the instance of the scanner class as the event handler
        _ble.gap().setEventHandler(this);

        // Initialise the BLE stack, start scanning if successful
        _ble.init(this, &BLEScanner::on_init_complete);

        // add the LED blinker as a recurring event on the event queue
        _event_queue.call_every(BLINKING_RATE_MS, this, &BLEScanner::blink);

        // run infinitely
        _event_queue.dispatch_forever();
    }

// Private scanner class variables and methods
private:
    // private global scanner variables
    BLE &_ble;
    events::EventQueue &_event_queue;
    DigitalOut _alive_led;

    /** Callback triggered when the ble initialization process has finished */
    void on_init_complete(BLE::InitializationCompleteCallbackContext *params) {

        // report error or success
        if (params->error != BLE_ERROR_NONE) {
            _pc_serial.printf("Ble initialisation failed.");
            return;
        }

        _pc_serial.printf("Ble initialisation complete.");

        // setup scan with custom parameters
        ble::ScanParameters scan_params;
        scan_params.set1mPhyConfiguration(ble::scan_interval_t(SCAN_INTERVAL), ble::scan_window_t(SCAN_WINDOW), ACTIVE_SCANNING);
        _ble.gap().setScanParameters(scan_params);

        // start scanning
        _ble.gap().startScan();
    }

    // Blink the alive LED
    void blink() {
        _alive_led = !_alive_led;
    }

    // Called on receipt of an advertising report
    void onAdvertisingReport(const ble::AdvertisingReportEvent &event) {

        // get the address and RSSI from the event
        ble::address_t address = event.getPeerAddress();
        ble::rssi_t rssi = event.getRssi();
   
        // print it out
        _pc_serial.printf("Received advertising data from address %02x:%02x:%02x:%02x:%02x:%02x, RSSI: %ddBm\r\n", address[5], address[4], address[3], address[2], address[1], address[0], rssi);
                  
                  // Use the below to get to the actual advertising data
                  //ble::AdvertisingDataParser adv_data(event.getPayload());
   }    
}; /*  /Inner scanner class */

/** Schedule processing of events from the BLE middleware in the event queue. */
void schedule_ble_events(BLE::OnEventsToProcessCallbackContext *context) {
    event_queue.call(Callback<void()>(&context->ble, &BLE::processEvents));
}

// Main method sets up peripherals, runs infinite loop
int main()
{   
    // setup serial connection
    _pc_serial.baud(PC_SERIAL_BAUD);

    // create BLE instance
    BLE &ble = BLE::Instance();

    // attach the callback to the event queue
    ble.onEventsToProcess(schedule_ble_events);

    // Setup scanner instance
    BLEScanner scanner(ble, event_queue);

    // Run the scanner
    _pc_serial.printf("Setup done. Running.\r\n");
    scanner.scan();
    return 0;
}