#include "PttController.h"
#include <QQuickWindow>
#include <QApplication>
#include "../overlaycontroller.h"

// application namespace
namespace advsettings {

  bool PttController::pttEnabled() const {
    return m_pttEnabled;
  }


  bool PttController::pttActive() const {
    return m_pttActive;
  }


  bool PttController::pttShowNotification() const {
    return m_pttShowNotification;
  }


  bool PttController::pttLeftControllerEnabled() const {
    return m_pttLeftControllerEnabled;
  }


  bool PttController::pttRightControllerEnabled() const {
    return m_pttRightControllerEnabled;
  }

  void PttController::setPttControllerConfig(unsigned controller, QVariantList buttons, unsigned triggerMode, unsigned padMode, unsigned padAreas) {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    if (controller < 2) {
      uint64_t buttonMask = 0;
      for (auto b : buttons) {
        buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
      }
      m_pttControllerConfigs[controller].digitalButtons = buttons;
      m_pttControllerConfigs[controller].digitalButtonMask = buttonMask;
      m_pttControllerConfigs[controller].triggerMode = triggerMode;
      m_pttControllerConfigs[controller].touchpadMode = padMode;
      m_pttControllerConfigs[controller].touchpadAreas = padAreas;
      savePttConfig();
    }
  }

  void PttController::reloadPttProfiles() {
    pttProfiles.clear();
    auto settings = OverlayController::appSettings();
    settings->beginGroup(getSettingsName());
    auto profileCount = settings->beginReadArray("pttProfiles");
    for (int i = 0; i < profileCount; i++) {
      settings->setArrayIndex(i);
      pttProfiles.emplace_back();
      auto& entry = pttProfiles[i];
      entry.profileName = settings->value("profileName").toString().toStdString();
      entry.showNotification = settings->value("showNotification", true).toBool();
      entry.leftControllerEnabled = settings->value("leftControllerEnabled", false).toBool();
      entry.rightControllerEnabled = settings->value("rightControllerEnabled", false).toBool();
      entry.controllerConfigs[0].digitalButtons = settings->value("digitalButtons_0").toList();
      uint64_t buttonMask = 0;
      for (auto b : entry.controllerConfigs[0].digitalButtons) {
        buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
      }
      entry.controllerConfigs[0].digitalButtonMask = buttonMask;
      entry.controllerConfigs[0].triggerMode = settings->value("triggerMode_0", 0).toUInt();
      entry.controllerConfigs[0].touchpadMode = settings->value("touchpadMode_0", 0).toUInt();
      entry.controllerConfigs[0].touchpadAreas = settings->value("touchPadAreas_0", 0).toUInt();
      entry.controllerConfigs[1].digitalButtons = settings->value("digitalButtons_1").toList();
      buttonMask = 0;
      for (auto b : entry.controllerConfigs[1].digitalButtons) {
        buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
      }
      entry.controllerConfigs[1].digitalButtonMask = buttonMask;
      entry.controllerConfigs[1].triggerMode = settings->value("triggerMode_1", 0).toUInt();
      entry.controllerConfigs[1].touchpadMode = settings->value("touchpadMode_1", 0).toUInt();
      entry.controllerConfigs[1].touchpadAreas = settings->value("touchPadAreas_1", 0).toUInt();
    }
    settings->endArray();
    settings->endGroup();
  }

  void PttController::savePttProfiles() {
    auto settings = OverlayController::appSettings();
    settings->beginGroup(getSettingsName());
    settings->beginWriteArray("pttProfiles");
    unsigned i = 0;
    for (auto& p : pttProfiles) {
      settings->setArrayIndex(i);
      settings->setValue("profileName", QString::fromStdString(p.profileName));
      settings->setValue("showNotification", p.showNotification);
      settings->setValue("leftControllerEnabled", p.leftControllerEnabled);
      settings->setValue("rightControllerEnabled", p.rightControllerEnabled);
      settings->setValue("digitalButtons_0", p.controllerConfigs[0].digitalButtons);
      settings->setValue("triggerMode_0", p.controllerConfigs[0].triggerMode);
      settings->setValue("touchpadMode_0", p.controllerConfigs[0].touchpadMode);
      settings->setValue("touchPadAreas_0", p.controllerConfigs[0].touchpadAreas);
      settings->setValue("digitalButtons_1", p.controllerConfigs[1].digitalButtons);
      settings->setValue("triggerMode_1", p.controllerConfigs[1].triggerMode);
      settings->setValue("touchpadMode_1", p.controllerConfigs[1].touchpadMode);
      settings->setValue("touchPadAreas_1", p.controllerConfigs[1].touchpadAreas);
      i++;
    }
    settings->endArray();
    settings->endGroup();
  }


  void PttController::reloadPttConfig() {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    auto settings = OverlayController::appSettings();
    settings->beginGroup(getSettingsName());
    setPttEnabled(settings->value("pttEnabled", false).toBool(), true, false);
    setPttLeftControllerEnabled(settings->value("pttLeftControllerEnabled", false).toBool(), true, false);
    setPttRightControllerEnabled(settings->value("pttRightControllerEnabled", false).toBool(), true, false);
    setPttShowNotification(settings->value("pttShowNotification", true).toBool(), true, false);
    m_pttControllerConfigs[0].digitalButtons = settings->value("pttDigitalButtons_0").toList();
    uint64_t buttonMask = 0;
    for (auto b : m_pttControllerConfigs[0].digitalButtons) {
      buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
    }
    m_pttControllerConfigs[0].digitalButtonMask = buttonMask;
    m_pttControllerConfigs[0].triggerMode = settings->value("pttTriggerMode_0", 0).toUInt();
    m_pttControllerConfigs[0].touchpadMode = settings->value("pttTouchpadMode_0", 0).toUInt();
    m_pttControllerConfigs[0].touchpadAreas = settings->value("pttTouchPadAreas_0", 0).toUInt();
    m_pttControllerConfigs[1].digitalButtons = settings->value("pttDigitalButtons_1").toList();
    buttonMask = 0;
    for (auto b : m_pttControllerConfigs[0].digitalButtons) {
      buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
    }
    m_pttControllerConfigs[1].digitalButtonMask = buttonMask;
    m_pttControllerConfigs[1].triggerMode = settings->value("pttTriggerMode_1", 0).toUInt();
    m_pttControllerConfigs[1].touchpadMode = settings->value("pttTouchpadMode_1", 0).toUInt();
    m_pttControllerConfigs[1].touchpadAreas = settings->value("pttTouchPadAreas_1", 0).toUInt();
    settings->endGroup();
  }

  void PttController::savePttConfig() {
    auto settings = OverlayController::appSettings();
    settings->beginGroup(getSettingsName());
    settings->setValue("pttEnabled", pttEnabled());
    settings->setValue("pttLeftControllerEnabled", pttLeftControllerEnabled());
    settings->setValue("pttRightControllerEnabled", pttRightControllerEnabled());
    settings->setValue("pttShowNotification", pttShowNotification());
    settings->setValue("pttDigitalButtons_0", m_pttControllerConfigs[0].digitalButtons);
    settings->setValue("pttTriggerMode_0", m_pttControllerConfigs[0].triggerMode);
    settings->setValue("pttTouchpadMode_0", m_pttControllerConfigs[0].touchpadMode);
    settings->setValue("pttTouchPadAreas_0", m_pttControllerConfigs[0].touchpadAreas);
    settings->setValue("pttDigitalButtons_1", m_pttControllerConfigs[1].digitalButtons);
    settings->setValue("pttTriggerMode_1", m_pttControllerConfigs[1].triggerMode);
    settings->setValue("pttTouchpadMode_1", m_pttControllerConfigs[1].touchpadMode);
    settings->setValue("pttTouchPadAreas_1", m_pttControllerConfigs[1].touchpadAreas);
    settings->endGroup();
  }

  void PttController::checkPttStatus() {
    static auto handleControllerState = [](const vr::VRControllerState_t& state, PttControllerConfig* config) -> bool {
      if (state.ulButtonPressed & config->digitalButtonMask) {
        return true;
      }
      if (config->triggerMode) {
        if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Trigger)
            || state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Trigger)) {
          return true;
        }
      }
      if (config->touchpadMode) {
        if (((config->touchpadMode & 1) && (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Touchpad)))
            || ((config->touchpadMode & 2) && (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Touchpad)))) {
          if (config->touchpadAreas == (PAD_AREA_LEFT + PAD_AREA_TOP + PAD_AREA_RIGHT + PAD_AREA_BOTTOM)) {
            return true;
          } else {
            float x = state.rAxis[0].x;
            float y = state.rAxis[0].y;
            if (std::abs(x) >= 0.2 || std::abs(y) >= 0.2) { // deadzone in the middle
              if (x < 0 && std::abs(y) < -x && (config->touchpadAreas & PAD_AREA_LEFT)) {
                return true;
              } else if (y > 0 && std::abs(x) < y && (config->touchpadAreas & PAD_AREA_TOP)) {
                return true;
              } else if (x > 0 && std::abs(y) < x && (config->touchpadAreas & PAD_AREA_RIGHT)) {
                return true;
              } else if (y < 0 && std::abs(x) < -y && (config->touchpadAreas & PAD_AREA_BOTTOM)) {
                return true;
              }
            }
          }
        }
      }
      return false;
    };
    if (m_pttEnabled) {
      bool newState = false;
      if (m_pttLeftControllerEnabled) {
        auto leftId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand);
        if (leftId != vr::k_unTrackedDeviceIndexInvalid) {
          vr::VRControllerState_t state;
          if (vr::VRSystem()->GetControllerState(leftId, &state, sizeof(vr::VRControllerState_t))) {
            //logControllerState(state, "Left ");
            newState |= handleControllerState(state, m_pttControllerConfigs);
          }
        }
      }
      if (m_pttRightControllerEnabled) {
        auto rightId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand);
        if (rightId != vr::k_unTrackedDeviceIndexInvalid) {
          vr::VRControllerState_t state;
          if (vr::VRSystem()->GetControllerState(rightId, &state, sizeof(vr::VRControllerState_t))) {
            //logControllerState(state, "Right ");
            newState |= handleControllerState(state, m_pttControllerConfigs + 1);
          }
        }
      }
      if (newState && !m_pttActive && pttChangeValid()) {
        startPtt();
      } else if (!newState && m_pttActive && pttChangeValid()) {
        stopPtt();
      }
    }
  }

  void PttController::startPtt() {
    m_pttActive = true;
    onPttStart();
    if (m_pttShowNotification && getNotificationOverlayHandle() != vr::k_ulOverlayHandleInvalid) {
      vr::VROverlay()->ShowOverlay(getNotificationOverlayHandle());
    }
    emit pttActiveChanged(m_pttActive);
  }

  void PttController::stopPtt() {
    m_pttActive = false;
    onPttStop();
    if (m_pttShowNotification && getNotificationOverlayHandle() != vr::k_ulOverlayHandleInvalid) {
      vr::VROverlay()->HideOverlay(getNotificationOverlayHandle());
    }
    emit pttActiveChanged(m_pttActive);
  }

  void PttController::addPttProfile(QString name) {
    PttProfile* profile = nullptr;
    for (auto& p : pttProfiles) {
      if (p.profileName.compare(name.toStdString()) == 0) {
        profile = &p;
        break;
      }
    }
    if (!profile) {
      auto i = pttProfiles.size();
      pttProfiles.emplace_back();
      profile = &pttProfiles[i];
    }
    profile->profileName = name.toStdString();
    profile->showNotification = m_pttShowNotification;
    profile->leftControllerEnabled = m_pttLeftControllerEnabled;
    profile->rightControllerEnabled = m_pttRightControllerEnabled;
    profile->controllerConfigs[0].digitalButtons = m_pttControllerConfigs[0].digitalButtons;
    profile->controllerConfigs[0].digitalButtonMask = m_pttControllerConfigs[0].digitalButtonMask;
    profile->controllerConfigs[0].triggerMode = m_pttControllerConfigs[0].triggerMode;
    profile->controllerConfigs[0].touchpadMode = m_pttControllerConfigs[0].touchpadMode;
    profile->controllerConfigs[0].touchpadAreas = m_pttControllerConfigs[0].touchpadAreas;
    profile->controllerConfigs[1].digitalButtons = m_pttControllerConfigs[1].digitalButtons;
    profile->controllerConfigs[1].digitalButtonMask = m_pttControllerConfigs[1].digitalButtonMask;
    profile->controllerConfigs[1].triggerMode = m_pttControllerConfigs[1].triggerMode;
    profile->controllerConfigs[1].touchpadMode = m_pttControllerConfigs[1].touchpadMode;
    profile->controllerConfigs[1].touchpadAreas = m_pttControllerConfigs[1].touchpadAreas;
    savePttProfiles();
    OverlayController::appSettings()->sync();
    emit pttProfilesUpdated();
  }

  void PttController::applyPttProfile(unsigned index) {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    if (index < pttProfiles.size()) {
      auto& profile = pttProfiles[index];
      setPttShowNotification(profile.showNotification);
      setPttLeftControllerEnabled(profile.leftControllerEnabled);
      setPttRightControllerEnabled(profile.rightControllerEnabled);
      m_pttControllerConfigs[0].digitalButtons = profile.controllerConfigs[0].digitalButtons;
      m_pttControllerConfigs[0].digitalButtonMask = profile.controllerConfigs[0].digitalButtonMask;
      m_pttControllerConfigs[0].triggerMode = profile.controllerConfigs[0].triggerMode;
      m_pttControllerConfigs[0].touchpadMode = profile.controllerConfigs[0].touchpadMode;
      m_pttControllerConfigs[0].touchpadAreas = profile.controllerConfigs[0].touchpadAreas;
      m_pttControllerConfigs[1].digitalButtons = profile.controllerConfigs[1].digitalButtons;
      m_pttControllerConfigs[1].digitalButtonMask = profile.controllerConfigs[1].digitalButtonMask;
      m_pttControllerConfigs[1].triggerMode = profile.controllerConfigs[1].triggerMode;
      m_pttControllerConfigs[1].touchpadMode = profile.controllerConfigs[1].touchpadMode;
      m_pttControllerConfigs[1].touchpadAreas = profile.controllerConfigs[1].touchpadAreas;
    }
  }

  void PttController::deletePttProfile(unsigned index) {
    if (index < pttProfiles.size()) {
      auto pos = pttProfiles.begin() + index;
      pttProfiles.erase(pos);
      savePttProfiles();
      OverlayController::appSettings()->sync();
      emit pttProfilesUpdated();
    }
  }

  QVariantList PttController::pttDigitalButtons(unsigned controller) {
    if (controller < 2) {
      return m_pttControllerConfigs[controller].digitalButtons;
    }
    return QVariantList();
  }

  unsigned long PttController::pttDigitalButtonMask(unsigned controller) {
    if (controller < 2) {
      return m_pttControllerConfigs[controller].digitalButtonMask;
    }
    return 0;
  }

  unsigned PttController::pttTouchpadMode(unsigned controller) {
    if (controller < 2) {
      return m_pttControllerConfigs[controller].touchpadMode;
    }
    return 0;
  }

  unsigned PttController::pttTriggerMode(unsigned controller) {
    if (controller < 2) {
      return m_pttControllerConfigs[controller].triggerMode;
    }
    return 0;
  }

  unsigned PttController::pttTouchpadArea(unsigned controller) {
    if (controller < 2) {
      return m_pttControllerConfigs[controller].touchpadAreas;
    }
    return 0;
  }

  unsigned PttController::getPttProfileCount() {
    return (unsigned)pttProfiles.size();
  }

  QString PttController::getPttProfileName(unsigned index) {
    if (index < pttProfiles.size()) {
      return QString::fromStdString(pttProfiles[index].profileName);
    }
    return "";
  }

  void PttController::setPttEnabled(bool value, bool notify, bool save) {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    if (value != m_pttEnabled) {
      m_pttEnabled = value;
      if (value) {
        onPttEnabled();
      } else {
        onPttDisabled();
      }
      if (notify) {
        emit pttEnabledChanged(value);
      }
      if (save) {
        savePttConfig();
      }
    }
  }

  void PttController::setPttShowNotification(bool value, bool notify, bool save) {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    if (value != m_pttShowNotification) {
      m_pttShowNotification = value;
      if (notify) {
        emit pttShowNotificationChanged(value);
      }
      if (save) {
        savePttConfig();
      }
    }
  }

  void PttController::setPttLeftControllerEnabled(bool value, bool notify, bool save) {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    if (value != m_pttLeftControllerEnabled) {
      m_pttLeftControllerEnabled = value;
      if (notify) {
        emit pttLeftControllerEnabledChanged(value);
      }
      if (save) {
        savePttConfig();
      }
    }
  }

  void PttController::setPttRightControllerEnabled(bool value, bool notify, bool save) {
    std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
    if (value != m_pttRightControllerEnabled) {
      m_pttRightControllerEnabled = value;
      if (notify) {
        emit pttRightControllerEnabledChanged(value);
      }
      if (save) {
        savePttConfig();
      }
    }
  }

  void logControllerState(const vr::VRControllerState_t& state, const std::string& prefix) {
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ApplicationMenu)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_ApplicationMenu) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_ApplicationMenu)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_ApplicationMenu) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Grip)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Grip) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_Grip)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Grip) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_DPad_Left)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Left) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_DPad_Left)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Left) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_DPad_Up)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Up) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_DPad_Up)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Up) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_DPad_Right)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Right) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_DPad_Right)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Right) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_DPad_Down)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Down) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_DPad_Down)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_DPad_Down) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_A)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_A) << " pressed";
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_A)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_A) << " touched";
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Axis0)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis0) << " pressed";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis0) << " x: " << state.rAxis[0].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_Axis0)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis0) << " touched";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis0) << " x: " << state.rAxis[0].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Axis1)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis1) << " pressed";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis1) << " x: " << state.rAxis[1].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_Axis1)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis1) << " touched";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis1) << " x: " << state.rAxis[1].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Axis2)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis2) << " pressed";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis2) << " x: " << state.rAxis[2].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_Axis2)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis2) << " touched";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis2) << " x: " << state.rAxis[2].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Axis3)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis3) << " pressed";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis3) << " x: " << state.rAxis[3].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_Axis3)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis3) << " touched";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis3) << " x: " << state.rAxis[3].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_Axis4)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis4) << " pressed";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis4) << " x: " << state.rAxis[4].x << "  y: " << state.rAxis[0].y;
    }
    if (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_Axis4)) {
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis4) << " touched";
      LOG(INFO) << prefix << vr::VRSystem()->GetButtonIdNameFromEnum(vr::k_EButton_Axis4) << " x: " << state.rAxis[4].x << "  y: " << state.rAxis[0].y;
    }
  }

} // namespace advconfig