#ifndef BLUETOOTH_H
#define BLUETOOTH_H

#include <string>
#include <stdexcept>

// For now
#include <boost/log/core.hpp>
#include <boost/log/trivial.hpp>
#include "ByteBuffer.h"

#define D BOOST_LOG_TRIVIAL(debug)
#define I BOOST_LOG_TRIVIAL(info)
#define W BOOST_LOG_TRIVIAL(warning)

#define DF BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": "
#define IF BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": "
#define WF BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": "

#define UUID_PRIMARY_SERVICE 0x2800
#define UUID_SECONDARY_SERVICE 0x2801

namespace trygvis {
    using namespace std;

    class BluetoothAdapter;

    class BluetoothDevice;

    class BluetoothException : public runtime_error {
    public:
        BluetoothException(const BluetoothAdapter *adapter, string const &what) :
                runtime_error(what), adapter(adapter), device(nullptr) {
        }

        BluetoothException(const BluetoothDevice *device, string const &what) :
                runtime_error(what), adapter(nullptr), device(device) {
        }

        BluetoothException(string const &what) :
                runtime_error(what), adapter(nullptr), device(nullptr) {
        }

        const BluetoothAdapter *adapter;
        const BluetoothDevice *device;
    };

    class Mac {
    public:
        Mac(uint8_t _0, uint8_t _1, uint8_t _2, uint8_t _3, uint8_t _4, uint8_t _5) {
            bytes[0] = _0;
            bytes[1] = _1;
            bytes[2] = _2;
            bytes[3] = _3;
            bytes[4] = _4;
            bytes[5] = _5;
        };

        string str() const;

        bool operator==(Mac &other) const;

        bool operator!=(Mac &other) const;

        void copy(uint8_t &_0, uint8_t &_1, uint8_t &_2, uint8_t &_3, uint8_t &_4, uint8_t &_5) const;

        static Mac *parseMac(string s) throw(BluetoothException);

        friend bool operator<(const Mac &a, const Mac &b);
    private:
        uint8_t bytes[6];
    };

    class BluetoothDevice {
    public:
        virtual Mac const &mac() = 0;

        virtual BluetoothAdapter &adapter() = 0;

        virtual void connect() = 0;

        virtual void disconnect() = 0;

        virtual void discoverServices() = 0;
    };

    class BluetoothAdapter {
    public:
        BluetoothAdapter() {
        };

        virtual ~BluetoothAdapter();

        virtual void stopScan() = 0;

        virtual void runScan(void (callback)(BluetoothDevice &device)) = 0;

        virtual BluetoothDevice &getDevice(Mac& mac) = 0;
    };

    enum AttPduType {
        ERROR = 0x00,
        READ_BY_GROUP_TYPE_REQ = 0x10,
        READ_BY_GROUP_TYPE_RES = 0x11
    };

    class AttributeData;

    class AttPdu {
    public:
        AttPdu(ByteBuffer &bytes);

        AttPdu(ByteBuffer &bytes, AttPduType type);

        AttPduType getType();

        static vector <AttributeData> parseReadByGroupType(ByteBuffer &bytes);

        static void makeReadByGroupType(ByteBuffer &bytes, uint16_t startHandle, uint16_t endHandle, uint16_t uuid);

    private:
        static void checkType(ByteBuffer &bytes, AttPduType type);

        ByteBuffer &bytes;
    };

    class AttributeData {
    public:
        ~AttributeData();

        static AttributeData fromByteBuffer(ByteBuffer &value, uint8_t length);

        const uint16_t handle;
        const uint16_t groupEndHandle;
        const ByteBuffer value;

    private:
        AttributeData(uint16_t handle, uint16_t groupEndHandle, ByteBuffer value);
    };

//    BluetoothAdapter &getAdapter(int hciDevice);
    BluetoothAdapter *getAdapter(int hciDevice);
}

#endif