/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2015-2016 Apple Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#if ENABLE_BLE_TRIGGERED_BONJOUR

#include "mDNSEmbeddedAPI.h"
#include "DNSCommon.h"

#import <Foundation/Foundation.h>
#import <CoreBluetooth/CoreBluetooth.h>
#import <CoreBluetooth/CoreBluetooth_Private.h>
#import "mDNSMacOSX.h"
#import "BLE.h"
#import "coreBLE.h"

static coreBLE * coreBLEptr;

// Call Bluetooth subsystem to start/stop the the Bonjour BLE beacon and
// beacon scanning based on the current Bloom filter.
void updateBLEBeacon(serviceHash_t bloomFilter)
{
    if (coreBLEptr == 0)
        coreBLEptr = [[coreBLE alloc] init];

    LogInfo("updateBLEBeacon: bloomFilter = 0x%lx", bloomFilter);

    [coreBLEptr updateBeacon:bloomFilter];
}

// Stop the current BLE beacon.
void stopBLEBeacon(void)
{
    if (coreBLEptr == 0)
        coreBLEptr = [[coreBLE alloc] init];

    [coreBLEptr stopBeacon];
}

bool currentlyBeaconing(void)
{
    if (coreBLEptr == 0)
        coreBLEptr = [[coreBLE alloc] init];

    return [coreBLEptr isBeaconing];
}

// Start the scan.
void startBLEScan(void)
{
    if (coreBLEptr == 0)
        coreBLEptr = [[coreBLE alloc] init];
    [coreBLEptr startScan];
}

// Stop the scan.
void stopBLEScan(void)
{
    if (coreBLEptr == 0)
        coreBLEptr = [[coreBLE alloc] init];

    [coreBLEptr stopScan];
}

@implementation coreBLE
{
    CBCentralManager     *_centralManager;
    CBPeripheralManager  *_peripheralManager;

    NSData               *_currentlyAdvertisedData;

    // [_centralManager isScanning] is only available on iOS and not OSX,
    // so track scanning state locally.
    BOOL                 _isScanning;
    BOOL                 _centralManagerIsOn;
    BOOL                 _peripheralManagerIsOn;
}

- (id)init
{
    self = [super init];

    if (self)
    {
        _centralManager     = [[CBCentralManager alloc] initWithDelegate:self queue:dispatch_get_main_queue()];
        _peripheralManager  = [[CBPeripheralManager alloc] initWithDelegate:self queue:dispatch_get_main_queue()];
        _currentlyAdvertisedData = nil;
        _isScanning = NO;
        _centralManagerIsOn = NO;
        _peripheralManagerIsOn = NO;

        if (_centralManager == nil || _peripheralManager == nil )
        {
            LogMsg("coreBLE initialization failed!");
        } 
        else
        {
            LogInfo("coreBLE initialized");
        }
    }

    return self;
}

#define ADVERTISEMENTDATALENGTH 28 // 31 - 3 (3 bytes for flags)

// TODO: 
// Define DBDeviceTypeBonjour for prototyping until we move to the TDS beacon format.
// The Bluetooth team recommended using a value < 32 for prototyping, since 32 is the number of
// beacon types they can track in their duplicate beacon filtering logic.
#define DBDeviceTypeBonjour     26

// Beacon flags and version byte
#define BonjourBLEVersion     1

extern mDNS mDNSStorage;
extern mDNSInterfaceID AWDLInterfaceID;

// Transmit the last beacon indicating we are no longer advertising or browsing any services for two seconds.
#define LastBeaconTime 2

- (void) updateBeacon:(serviceHash_t) bloomFilter
{
    uint8_t advertisingData[ADVERTISEMENTDATALENGTH] = {0, 0xff, 0x4c, 0x00 };
    uint8_t advertisingLength = 4;

    // If no longer browsing or advertising, beacon this state for 'LastBeaconTime' seconds
    // so that peers have a chance to notice the state change.
    if (bloomFilter == 0)
    {
        LogInfo("updateBeacon: Stopping beacon in %d seconds", LastBeaconTime);

        if (mDNSStorage.timenow == 0)
        {
            // This should never happen since all calling code paths should have called mDNS_Lock(), which
            // initializes the mDNSStorage.timenow value.
            LogMsg("updateBeacon: NOTE, timenow == 0 ??");
        }

        mDNSStorage.NextBLEServiceTime = NonZeroTime(mDNSStorage.timenow + (LastBeaconTime * mDNSPlatformOneSecond));
        finalBeacon = true;
    }
    else
    {
        // Cancel any pending final beacon processing.
        finalBeacon = false;
    }

    // The beacon type.
    advertisingData[advertisingLength++] = DBDeviceTypeBonjour;

    // Flags and Version field
    advertisingData[advertisingLength++] = BonjourBLEVersion;

    memcpy(& advertisingData[advertisingLength], & bloomFilter, sizeof(serviceHash_t));
    advertisingLength += sizeof(serviceHash_t);

    // Add the MAC address of the awdl0 interface.  Don't cache it since
    // it can get updated periodically.
    if (AWDLInterfaceID)
    {
        NetworkInterfaceInfoOSX *intf = IfindexToInterfaceInfoOSX(AWDLInterfaceID);
        if (intf)
            memcpy(& advertisingData[advertisingLength], & intf->ifinfo.MAC, sizeof(mDNSEthAddr));
        else 
            memset( & advertisingData[advertisingLength], 0, sizeof(mDNSEthAddr));
    }
    else
    {
        // Just use zero if not avaiblable.
       memset( & advertisingData[advertisingLength], 0, sizeof(mDNSEthAddr));
    }
    advertisingLength += sizeof(mDNSEthAddr);

    // Total length of data advertised, minus this length byte.
    advertisingData[0] = (advertisingLength - 1);

    LogInfo("updateBeacon: advertisingLength = %d", advertisingLength);

    if (_currentlyAdvertisedData)
        [_currentlyAdvertisedData release];
    _currentlyAdvertisedData = [[NSData alloc] initWithBytes:advertisingData length:advertisingLength];
    [self startBeacon];
}

- (void) startBeacon
{
    if (!_peripheralManagerIsOn)
    {
        LogInfo("startBeacon: Not starting beacon, CBPeripheralManager not powered on");
        return;
    }

    if (_currentlyAdvertisedData == nil)
    {
        LogInfo("startBeacon: Not starting beacon, no data to advertise");
        return;
    }

    if ([_peripheralManager isAdvertising])
    {
        LogInfo("startBeacon: Stop current beacon transmission before restarting");
        [_peripheralManager stopAdvertising];
    }
    LogInfo("startBeacon: Starting beacon");

#if 0   // Move to this code during Fall 2018 develelopment if still using these APIs.
    [_peripheralManager startAdvertising:@{ CBAdvertisementDataAppleMfgData : _currentlyAdvertisedData, CBManagerIsPrivilegedDaemonKey : @YES, @"kCBAdvOptionUseFGInterval" : @YES }];
#else
    // While CBCentralManagerScanOptionIsPrivilegedDaemonKey is deprecated in current MobileBluetooth project, it's still defined in the current and
    // previous train SDKs.  Suppress deprecated warning for now since we intend to move to a different Bluetooth API to manage the BLE Triggered Bonjour 
    // beacons when this code is enabled by default.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    [_peripheralManager startAdvertising:@{ CBAdvertisementDataAppleMfgData : _currentlyAdvertisedData, CBCentralManagerScanOptionIsPrivilegedDaemonKey : @YES, @"kCBAdvOptionUseFGInterval" : @YES }];
#pragma GCC diagnostic pop
#endif
}

- (bool) isBeaconing
{
    return (_currentlyAdvertisedData != nil);
}

- (void) stopBeacon
{
    if (!_peripheralManagerIsOn)
    {
        LogInfo("stopBeacon: CBPeripheralManager is not powered on");
        return;
    }

    // Only beaconing if we have advertised data to send.
    if (_currentlyAdvertisedData)
    {
        LogInfo("stoptBeacon: Stopping beacon");
        [_peripheralManager stopAdvertising];
        [_currentlyAdvertisedData release];
        _currentlyAdvertisedData = nil;
    }
    else
        LogInfo("stoptBeacon: Note currently beaconing");
}

- (void) startScan
{
    if (!_centralManagerIsOn)
    {
        LogInfo("startScan: Not starting scan, CBCentralManager is not powered on");
        return;
    }

    if (_isScanning)
    {
        LogInfo("startScan: already scanning, stopping scan before restarting");
        [_centralManager stopScan];
    }

    LogInfo("startScan: Starting scan");

    _isScanning = YES;

#if 0   // Move to this code during Fall 2018 develelopment if still using these APIs.
    [_centralManager scanForPeripheralsWithServices:nil options:@{ CBCentralManagerScanOptionAllowDuplicatesKey : @YES , CBManagerIsPrivilegedDaemonKey : @YES}];
#else
    // While CBCentralManagerScanOptionIsPrivilegedDaemonKey is deprecated in current MobileBluetooth project, it's still defined in the current and
    // previous train SDKs.  Suppress deprecated warning for now since we intend to move to a different Bluetooth API to manage the BLE Triggered Bonjour 
    // beacons when this code is enabled by default.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    [_centralManager scanForPeripheralsWithServices:nil options:@{ CBCentralManagerScanOptionAllowDuplicatesKey : @YES , CBCentralManagerScanOptionIsPrivilegedDaemonKey : @YES}];
#pragma GCC diagnostic pop
#endif
}

- (void) stopScan
{
    if (!_centralManagerIsOn)
    {
        LogInfo("stopScan: Not stopping scan, CBCentralManager is not powered on");
        return;
    }

    if (_isScanning)
    {
        LogInfo("stopScan: Stopping scan");
        [_centralManager stopScan];
        _isScanning = NO;
    }
    else
    {
        LogInfo("stopScan: Not currently scanning");
    }
}

#pragma mark - CBCentralManagerDelegate protocol

- (void)centralManagerDidUpdateState:(CBCentralManager *)central
{
    switch (central.state) {
        case CBManagerStateUnknown:
            LogInfo("centralManagerDidUpdateState: CBManagerStateUnknown");
            break;

        case CBManagerStateResetting:
            LogInfo("centralManagerDidUpdateState: CBManagerStateResetting");
            break;

        case CBManagerStateUnsupported:
            LogInfo("centralManagerDidUpdateState: CBManagerStateUnsupported");
            break;

        case CBManagerStateUnauthorized:
            LogInfo("centralManagerDidUpdateState: CBManagerStateUnauthorized");
            break;

        case CBManagerStatePoweredOff:
            LogInfo("centralManagerDidUpdateState: CBManagerStatePoweredOff");
            break;

        case CBManagerStatePoweredOn:
            // Hold lock to synchronize with main thread from this callback thread.
            KQueueLock();

            LogInfo("centralManagerDidUpdateState: CBManagerStatePoweredOn");
            _centralManagerIsOn = YES;
            // Only start scan if we have data we will be transmitting or if "suppressBeacons"
            // is set, indicating we should be scanning, but not beaconing.
            if (_currentlyAdvertisedData || suppressBeacons)
                [self startScan];
            else
                LogInfo("centralManagerDidUpdateState:: Not starting scan");

            KQueueUnlock("CBManagerStatePoweredOn");
            break;

        default:
            LogInfo("centralManagerDidUpdateState: Unknown state ??");
            break;
    }
}

#define beaconTypeByteIndex  2   // Offset of beacon type in received CBAdvertisementDataManufacturerDataKey byte array.
#define beaconDataLength    18  // Total number of bytes in the CBAdvertisementDataManufacturerDataKey.

- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary<NSString *, id> *)advertisementData RSSI:(NSNumber *)RSSI
{
    (void) central;
    (void) peripheral;
    (void) RSSI;

    NSData *data = [advertisementData objectForKey:CBAdvertisementDataManufacturerDataKey];
   
    // Just return if the beacon data does not match what we are looking for.
    if (!data || ([data length] != beaconDataLength))
    {
        return;
    }

    unsigned char *bytes = (unsigned char *)data.bytes;
    
    // Just parse the DBDeviceTypeBonjour beacons.
    if (bytes[beaconTypeByteIndex] == DBDeviceTypeBonjour)
    {
        serviceHash_t peerBloomFilter;
        mDNSEthAddr   peerMAC;
        unsigned char flagsAndVersion;
        unsigned char *ptr;

#if VERBOSE_BLE_DEBUG
        LogInfo("didDiscoverPeripheral: received DBDeviceTypeBonjour beacon, length = %d", [data length]);
        LogInfo("didDiscoverPeripheral: central = 0x%x, peripheral = 0x%x", central, peripheral);
#endif // VERBOSE_BLE_DEBUG

        // The DBDeviceTypeBonjour beacon bytes will be:
        // 0x4C (1 byte), 0x0 (1 byte), DBDeviceTypeBonjour byte, flags and version byte, 8 byte Bloom filter,
        // 6 byte sender AWDL MAC address

        ptr = & bytes[beaconTypeByteIndex + 1];
        flagsAndVersion = *ptr++;
        memcpy(& peerBloomFilter, ptr, sizeof(serviceHash_t));
        ptr += sizeof(serviceHash_t);
        memcpy(& peerMAC, ptr, sizeof(peerMAC));

#if VERBOSE_BLE_DEBUG
        LogInfo("didDiscoverPeripheral: version = 0x%x, peerBloomFilter = 0x%x",
                flagsAndVersion, peerBloomFilter);
        LogInfo("didDiscoverPeripheral: sender MAC = 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
            peerMAC.b[0], peerMAC.b[1], peerMAC.b[2], peerMAC.b[3], peerMAC.b[4], peerMAC.b[5]);
#else
        (void)flagsAndVersion; // Unused
#endif  // VERBOSE_BLE_DEBUG

        responseReceived(peerBloomFilter, & peerMAC);
    }
}

#pragma mark - CBPeripheralManagerDelegate protocol

- (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)peripheral
{

    switch (peripheral.state) {
        case CBManagerStateUnknown:
            LogInfo("peripheralManagerDidUpdateState: CBManagerStateUnknown");
            break;

        case CBManagerStateResetting:
            LogInfo("peripheralManagerDidUpdateState: CBManagerStateResetting");
            break;

        case CBManagerStateUnsupported:
            LogInfo("peripheralManagerDidUpdateState: CBManagerStateUnsupported");
            break;

        case CBManagerStateUnauthorized:
            LogInfo("peripheralManagerDidUpdateState: CBManagerStateUnauthorized");
            break;

        case CBManagerStatePoweredOff:
            LogInfo("peripheralManagerDidUpdateState: CBManagerStatePoweredOff");
            break;

        case CBManagerStatePoweredOn:
            // Hold lock to synchronize with main thread from this callback thread.
            KQueueLock();

            LogInfo("peripheralManagerDidUpdateState: CBManagerStatePoweredOn");
            _peripheralManagerIsOn = YES;

            // Start beaconing if we have initialized beacon data to send.
            if (_currentlyAdvertisedData)
                [self startBeacon];

            KQueueUnlock("CBManagerStatePoweredOn");
            break;

        default:
            LogInfo("peripheralManagerDidUpdateState: Unknown state ??");
            break;
    }
}

- (void)peripheralManagerDidStartAdvertising:(CBPeripheralManager *)peripheral error:(nullable NSError *)error
{
    (void) peripheral;

    if (error)
    {
        const char * errorString = [[error localizedDescription] cStringUsingEncoding:NSASCIIStringEncoding];
        LogInfo("peripheralManagerDidStartAdvertising: error = %s", errorString ? errorString: "unknown");
    }
    else
    {
        LogInfo("peripheralManagerDidStartAdvertising:");
    }
}

@end
#endif  // ENABLE_BLE_TRIGGERED_BONJOUR