#ifndef BLESCANNER_H
#define BLESCANNER_H

// Qt
#include <QObject>
#include <QBluetoothDeviceDiscoveryAgent>
#include <QBluetoothDeviceInfo>
#include <QLowEnergyController>
#include <QLowEnergyService>
#include <QTimer>
#include <QByteArray>

// Project
#include "main.h"
#include "VBluetoothDeviceInfo.h"

// define
#define _BLEScanner BLEScanner::I()

using namespace View;

class BLEScanner : public QObject
{
    Q_OBJECT

    QThread *_thread = nullptr;
    bool     _init   = false;

// Singleton
SINGLETON(BLEScanner)

public:

    // 19 total bytes
    struct bp_measurement {
        uint8_t flags;                                      // 1 byte
        uint16_t systolic;                                  // 2 bytes
        uint16_t diastolic;                                 // 2 bytes
        uint16_t mean_arterial_pressure_value;              // 2 bytes
        uint16_t year;                                      // 2 bytes
        uint8_t month;                                      // 1 byte
        uint8_t day;                                        // 1 byte
        uint8_t hour;                                       // 1 byte
        uint8_t minute;                                     // 1 byte
        uint8_t second;                                     // 1 byte
        uint16_t pulse_rate;                                // 2 bytes
        uint8_t user_id;                                    // 1 byte
        uint16_t measurement_status;                        // 2 bytes

    };
    typedef bp_measurement bp_measurement_t;

    void scanForDevices();
    void parseMeasurement(const QByteArray &byteArray);
    void requestBPMeasurement();

private:

    QList<QBluetoothDeviceInfo> devices;
    QString macAddress = "";
    QBluetoothDeviceDiscoveryAgent *discoveryAgent;
    QLowEnergyController *lowEnergyController;

    QList<QLowEnergyService*> services;
    QLowEnergyService* omronUnknownService       = nullptr;
    QLowEnergyService* omronCurrentTimeService   = nullptr;
    QLowEnergyService* omronBatteryLevelService  = nullptr;
    QLowEnergyService* omronBloodPressureService = nullptr;
    QLowEnergyDescriptor notificationDesc;
    QLowEnergyDescriptor readDesc;

    const QString omronCurrentTimeServiceName    = QString("{00002a2b-0000-1000-8000-00805f9b34fb}");
    const QString omronBatteryLevelServiceName   = QString("{0000180f-0000-1000-8000-00805f9b34fb}");
    const QString omronUnknownServiceName        = QString("{ecbe3980-c9a2-11e1-b1bd-0002a5d5c51b}");
    const QString omronBloodPressureServiceName  = QString("{00001810-0000-1000-8000-00805f9b34fb}");

    QStringList characteristicsToAcquireNotify;

    void initConnections();
    void quitThread();
    void connectToDevice(const QBluetoothDeviceInfo& deviceInfo);
    void setMacAddress(const QString &mac);

signals:
    void receivedBPMeasurement(bp_measurement_t);
    void connectedToBloodPressureService();
    void scanForDevicesError(QBluetoothDeviceDiscoveryAgent::Error error);
    void scanFinished();
    void deviceDiscovered(const QBluetoothDeviceInfo &device);

public slots:
    bool init();

private slots:

    // discovery agent
    void onDeviceDiscovered(const QBluetoothDeviceInfo& deviceInfo);
    void onDiscoveryAgentError(QBluetoothDeviceDiscoveryAgent::Error error);
    void onScanFinished();

    // low energy controller
    void onServiceDiscovered(const QBluetoothUuid &uuid);
    void onServiceScanDone();
    void onControllerError(const QLowEnergyController::Error &error);
    void onDeviceConnected();
    void onDeviceDisconnected();

    // service slots
    void serviceStateChanged(const QLowEnergyService::ServiceState &serviceState);
    void onCharacteristicChanged(const QLowEnergyCharacteristic &c, const QByteArray &byteArray);
    void confirmedDescriptorWrite(const QLowEnergyDescriptor &desc, const QByteArray &byteArray);
    void serviceCharacteristicsRead(const QLowEnergyCharacteristic &c,const QByteArray &byteArray);

    void quit();
    void onSelectedDevice(const QString &addr);
};

#endif // BLESCANNER_H