//for Advertising it is important to have the variable in the global scope
uint8_t         manufactData[10] = {0x01,0x02,0x03,0x04,  0x03,0x07,0x07,0x08,  0x09,0x0A};
uint8_t         serviceData[16]  = {0x01,0x02,0x03,0x04,  0x05,0x06,0x07,0x08,  0x09,0x0A,0x01,0x02,  0x09,0x0A,0x01,0x02};
uint8_t         sensoreData[17]  = {0x01,0x00,0x02,0x04,  0x09,0x08,0x07,0x06,  0x09,0x0A,0x01,0x02,  0x09,0x0A,0x01,0x02, 0x01};

void setup() {

		/*
		...  I hide  other statement for clarification
		*/

    // Advertising service data
    BLEAdvertisingData scanData;
    scanData.setLocalName("TIS.001");
    //scanData.setFlags(BLEFlagsGeneralDiscoverable);  
    scanData.setAdvertisedServiceData(0x183B,sensoreData,sizeof(sensoreData));
    BLE.setScanResponseData(scanData);

    // Advertising manufacturer data
    BLEAdvertisingData advData;
    advData.setLocalName("TIS.001");
    setManufacturerData("WIMO000001"); // is the first wimo modul of TIS-module => first window in the house
    advData.setManufacturerData(0xFFFF, manufactData, sizeof(manufactData));
    BLE.setAdvertisingData(advData);
    BLE.setAdvertisedService(binarySensorService);  

    BLE.advertise();  
		/*
		...  I hide  other statement for clarification
		*/
}

// This are the BLE Peripheral Information
#define    SYSID  "TIS.001.XIAO-NRF52840"
#define    MODEL  "TIS.HOBRO.WINDOW"
#define    SERIE  "001.001.240525"
#define    FWREV  "ArduinoBLE V 1.3.6"
#define    HWREV  "X 1.0-0"
#define    SWREV  "X 0.0-4"
#define    FIRMA  "TIS-Switzerland"
// Appearance of BLE
#define WINDOW_APPEARANCE   0X0706 // Catecory => Access Control, dh. = zugang zum objekt
// BLE Services
#define DEVICEINFOSERVICEVALUE          "180A"
#define BATTERYSERVICEVALUE             "180F"
#define BINARYSENSORSERVICEVALUE        "183B"
#define AUTOMATIONIOSERVICEVALUE        "1815"
// BLE Characteristics
#define SYSIDCHARACTERVALUE             "2A23"
#define MODELCHARACTERVALUE             "2A24"
#define SERIECHARACTERVALUE             "2A25"
#define FWREVCHARACTERVALUE             "2A26"
#define HWREVCHARACTERVALUE             "2A27"
#define SWREVCHARACTERVALUE             "2A28"
#define FIRMACHARACTERVALUE             "2A29"
// BLE Descriptor type
#define USERDESCRIPTION                 "2901"
#define PRESENTATIONFORMAT              "2904"
#define BATTERYLEVELCHARAKTERVALUE      "2A19"
#define BSSCONTROLPOINTCHARACTERVALUE   "2B2B"
#define BSSRESPONSECHARACTERVALUE       "2B2C"
// Common globals
#define CRITICALBATTERYLEVEL                 0 // adjust level if battery is connected
#define MINPIEZOLEVEL                      150 // the level must have to add to the serie of values
#define MINPIEZODELTA                       25 // the value differs from brevious to store;
#define BLEADR001               51156894393645  // first XIAO for not forget

// Bluetooth® Services
BLEService                      deviceInfoService(   DEVICEINFOSERVICEVALUE   );
BLEService                      batteryService(      BATTERYSERVICEVALUE      );
BLEService                      binarySensorService( BINARYSENSORSERVICEVALUE ); 

BLECharacteristic               bssControlPointChar( BSSCONTROLPOINTCHARACTERVALUE,  BLEWrite | BLENotify,256, *buffer);
BLECharacteristic               bssResponseChar(     BSSRESPONSECHARACTERVALUE,      BLERead  | BLENotify,256, *buffer);
BLEUnsignedCharCharacteristic   batteryLevelChar(    BATTERYLEVELCHARAKTERVALUE,     BLERead  | BLENotify); 

   if (!BLE.begin()) {
        StateManager.SetState(error);
        while (1);
   }
    binarySensor.InitNrOfSensors(8,0,4); // 4 ocl-shas, 4 ocl-glasbr. 0 human and 4 vibration
    BLE.setLocalName( "TIS-WindowMonitor");
    BLE.setDeviceName("TIS-WindowMonitor");
    // Battery Service
    batteryService.addCharacteristic(batteryLevelChar); 
    BLE.addService(batteryService);                     
    batteryLevelChar.writeValue(oldBatteryLevel);       // set initial value for this characteristic
    // Sensor Service
    binarySensorService.addCharacteristic(bssControlPointChar);
    binarySensorService.addCharacteristic(bssResponseChar);
    BLE.addService(binarySensorService);
    // Device Info Service
    BLECharacteristic  sysIdCharacter = BLECharacteristic(SYSIDCHARACTERVALUE, BLERead, SYSID);
    BLECharacteristic  modelCharacter = BLECharacteristic(MODELCHARACTERVALUE, BLERead, MODEL);
    BLECharacteristic  serieCharacter = BLECharacteristic(SERIECHARACTERVALUE, BLERead, SERIE);
    BLECharacteristic  fwRevCharacter = BLECharacteristic(FWREVCHARACTERVALUE, BLERead, FWREV);
    BLECharacteristic  hwRevCharacter = BLECharacteristic(HWREVCHARACTERVALUE, BLERead, HWREV);
    BLECharacteristic  swRevCharacter = BLECharacteristic(SWREVCHARACTERVALUE, BLERead, SWREV);
    BLECharacteristic  firmaCharacter = BLECharacteristic(FIRMACHARACTERVALUE, BLERead, FIRMA);
    deviceInfoService.addCharacteristic(sysIdCharacter);
    deviceInfoService.addCharacteristic(modelCharacter);
    deviceInfoService.addCharacteristic(serieCharacter);
    deviceInfoService.addCharacteristic(fwRevCharacter);
    deviceInfoService.addCharacteristic(hwRevCharacter);
    deviceInfoService.addCharacteristic(swRevCharacter);
    deviceInfoService.addCharacteristic(firmaCharacter);
    BLE.addService(deviceInfoService);

    BLE.setAppearance(WINDOW_APPEARANCE);
    BLE.setEventHandler(BLEConnected, blePeripheralConnectHandler);
    BLE.setEventHandler(BLEDisconnected, blePeripheralDisconnectHandler);
    bssControlPointChar.setEventHandler(BLEWritten,bssControllPointWritten);
    BLE.advertise();  // shout out I am here

/// @brief                  This callback is excecuted whenever the character is written by the peripheral.
///                         It does disassembling the datastream, build the coresponding response  and semd
///                         it to the charcateristic in fragments if needed.
/// @param central          is the central that the characteristc belongs.
/// @param characteristic   is the character of hte central that has been written 
void bssControllPointWritten(BLEDevice central, BLECharacteristic characteristic) {


    int sTyp[]      = {PARVALTYPSOCL,PARVALTYPSHDE,PARVALTYPSVIP,PARVALTYPMOCL,PARVALTYPMHDE,PARVALTYPMVIP,240};
    byte b[256]     = {0};
    byte *ptBuffer  = &b[0]; 
    int len         = 0;
    int cmd;
    int idx ;

    if (characteristic.valueLength() > 0) {
        len = characteristic.readValue(ptBuffer, 256);
        JoinFragment.Add(ptBuffer, len);
    } else {
        // Serial.println("Callback can't read");
        return ;
    }
   
    int datalength = JoinFragment.GetLength();
    if (JoinFragment.IsLast() && datalength > 0){
        int result = binarySensor.DisasemblingControlCommand(0, JoinFragment.Data, datalength);
        if (result > 0) {
           cmd  = result /10;
           idx  = result %10;
           if (cmd == 1) binarySensor.CreateGetSensorStatusResponse(sTyp[idx], bssResponseChar);
           else 
           if (cmd == 2) binarySensor.CreateSettingSensorResponse(  sTyp[idx], bssResponseChar);
        }
    }
}

/// @brief                  If the central is connected then we set the state and then 
///                         we must start again the advertisment if we want to
///                         broadcast our sensors by advertise data.
/// @param central          The central that is connected.
void blePeripheralConnectHandler(BLEDevice central) {

    StateManager.SetState(connected);
    BLE.advertise();  
}

void blePeripheralDisconnectHandler(BLEDevice central) {

   // BLE.advertise(); 
    StateManager.SetState(disconnected);
}

    /// @brief          Sets the private property of different state and then depending of the property 
    ///                 the state of the applicateion is evaluatet.  The code is based on a true tabelle
    ///                 which says when should the buildin led have what color. the color shows you the current state of
    ///                 the device.
    /// @param state    the property you want set.
    /// @return         not used yet.
    int StatusOfWindow::SetState(windowState state){

        ledColor color;
        switch(state) {
            case disconnected: isConnected  = false; break;
            case connected:    isConnected  = true;  break;
            case vibrationOff:  _vibration  = false; break; 
            case vibrationOn:   _vibration  = true;  break; 
            case glassOk:     _glassbroken  = false; break; 
            case glassBreak:  _glassbroken  = true;  break; 
            case batLow:       _batteryLow  = true;  break; 
            case batOk:        _batteryLow  = false; break; 
            case closeLe:        _OpenLeft  = false; break; 
            case openLe:         _OpenLeft  = true;  break; 
            case closeMi:      _openMiddle  = false; break; 
            case openMi:       _openMiddle  = true;  break;
            case closeRi:       _openRight  = false; break;
            case openRi:        _openRight  = true;  break;
            case error:             _error  = true;  break;  
            case errorOff:          _error  = false; break;
            default:    break;
        }
        if (_batteryLow || _error) color = red; 
            else if (_glassbroken) color = magenta;
                else if ( _OpenLeft || _openMiddle || _openRight) color = green;
                    else if (_vibration) color = yellow;
                        else if (!isConnected) color = blue;
                            else color = none;
        SetBoardLed(color);
        return 0;
    }