productUID = "com.blues.bsatrom:wfh_stress_detector"

i2c = board.I2C()

card = notecard.OpenI2C(i2c, 0, 0, debug=True)

bmp280 = adafruit_bmp280.Adafruit_BMP280_I2C(i2c)
sht31d = adafruit_sht31d.SHT31D(i2c)
microphone = audiobusio.PDMIn(
    board.MICROPHONE_CLOCK,
    board.MICROPHONE_DATA,
    sample_rate=16000,
    bit_depth=16
)

bmp280.sea_level_pressure = 1013.25

ble = adafruit_ble.BLERadio()

def get_heart_rate_data(hr_connection, notify_hr):
    heart_rate = {}

    print("Scanning for Heart Rate Service...")
    red_led.value = True
    blue_led.value = False
    time.sleep(1)

    for adv in ble.start_scan(ProvideServicesAdvertisement, timeout=5):
        if HeartRateService in adv.services:
            print("found a HeartRateService advertisement")
            hr_connection = ble.connect(adv)
            time.sleep(2)
            print("Connected to service")
            blue_led.value = True
            red_led.value = False
            break

    # Stop scanning whether or not we are connected.
    ble.stop_scan()
    print("Stopped BLE scan")
    red_led.value = False
    blue_led.value = True

    if hr_connection and hr_connection.connected:
        print("Fetch HR connection")
        if DeviceInfoService in hr_connection:
            dis = hr_connection[DeviceInfoService]
            try:
                manufacturer = dis.manufacturer
            except AttributeError:
                manufacturer = "(Manufacturer Not specified)"
            try:
                model_number = dis.model_number
            except AttributeError:
                model_number = "(Model number not specified)"
            heart_rate["manufacturer"] = manufacturer.replace("\u0000", "")
            heart_rate["model_number"] = model_number
        else:
            print("No device information")

        if BatteryService in hr_connection:
            batt_svc = hr_connection[BatteryService]
            batt = batt_svc.level
            heart_rate["battery_level"] = batt

        hr_service = hr_connection[HeartRateService]

        while hr_connection.connected:
            values = hr_service.measurement_values
            if values:
                bpm = values.heart_rate
                if bpm is not 0:
                    pct_notify = round(100 * (bpm / notify_hr))
                if values.heart_rate is 0:
                    print("Heart Rate not found...")
                    break
                else:
                    heart_rate["bpm"] = bpm
                    heart_rate["pct_notify"] = pct_notify
                    break
    return heart_rate, hr_connection

const encText = msgBody.data;
const encAES = msgBody.key;

const decryptedPayload = await aes_decrypt(encAES, encText);

const crypto = require('crypto');
const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient, CryptographyClient } = require("@azure/keyvault-keys");

const keyVaultName = process.env["KEY_VAULT_NAME"];
const keyName = process.env["KEY_NAME"];

const ENC_ALGORITHM = 'AES-256-CBC';
const IV_LENGTH = 16;

const KVUri = "https://" + keyVaultName + ".vault.azure.net";

const credential = new DefaultAzureCredential();
const client = new KeyClient(KVUri, credential);

const aes_decrypt = async function (encryptedAES, cipherText) {
  const key = await client.getKey(keyName);
  const cryptographyClient = new CryptographyClient(key, credential);

  // decrypt the random aes with RSA private key (RSA)
  const aes = await cryptographyClient.decrypt({
    algorithm: "RSA1_5",
    ciphertext: Buffer.from(encryptedAES, "base64")
  });

  const text = Buffer.from(cipherText, 'base64');
  const iv = Buffer.alloc(IV_LENGTH, 0);

  // Create a decipher object using the decrypted AES key
  var decipher = crypto.createDecipheriv(ENC_ALGORITHM, aes.result, iv);
  decipher.setAutoPadding(false);
  
  // Decrypt the cipher text using the AES key
  let dec = decipher.update(text, 'base64', 'utf-8');
  dec += decipher.final('utf-8');

  return dec.replace(/[\u0000-\u0010+\f]/gu,"");
}

const jsonPayload = JSON.parse(decryptedPayload);
jsonPayload["event_created"] = msgBody.event_created;

context.bindings.healthDataStorage = jsonPayload;

def send_notification(message):
    req = {"req": "note.add"}
    req["file"] = "sensor_alert.qo"
    req["sync"] = True
    req["body"] = {
        "message": message
    }
    card.Transaction(req)

if heart_rate["bpm"] > notify_hr:
  send_notification("Your heart rate is high. Take a few deep breaths, buddy.")

if sound_level > sound_max:
  send_notification("It's pretty loud in there. Maybe stop yelling and you'll feel better.")

notify_hr = int(get_env_var("notify_hr"))
sound_max = int(get_env_var("sound_max"))

def get_env_var(name):
    req = {"req": "env.get"}
    req["name"] = name
    rsp = card.Transaction(req)
    if "text" in rsp:
        return rsp["text"]
    else:
        return 0