//
//  SixenseManager.h
//  input-plugins/src/input-plugins
//
//  Created by Andrzej Kapolka on 11/15/13.
//  Copyright 2013 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//

#ifndef hifi_SixenseManager_h
#define hifi_SixenseManager_h

#include <SimpleMovingAverage.h>

#include <controllers/InputDevice.h>
#include <controllers/StandardControls.h>

#include <plugins/InputPlugin.h>

struct _sixenseControllerData;
using SixenseControllerData = _sixenseControllerData;

// Handles interaction with the Sixense SDK (e.g., Razer Hydra).
class SixenseManager : public InputPlugin {
    Q_OBJECT
public:
    // Plugin functions
    virtual bool isSupported() const override;
    virtual const QString getName() const override { return NAME; }
    virtual const QString getID() const override { return SIXENSE_ID_STRING; }

    // Sixense always seems to initialize even if the hydras are not present. Is there
    // a way we can properly detect whether the hydras are present?
    // bool isHandController() const override { return true; }

    virtual void init() override;

    virtual bool activate() override;
    virtual void deactivate() override;

    virtual void pluginFocusOutEvent() override { _inputDevice->focusOutEvent(); }
    virtual void pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override;

    virtual void saveSettings() const override;
    virtual void loadSettings() override;

public slots:
    void setSixenseFilter(bool filter);

private:
    static const int MAX_NUM_AVERAGING_SAMPLES = 50; // At ~100 updates per seconds this means averaging over ~.5s
    static const int CALIBRATION_STATE_IDLE = 0;
    static const int CALIBRATION_STATE_IN_PROGRESS = 1;
    static const int CALIBRATION_STATE_COMPLETE = 2;
    static const glm::vec3 DEFAULT_AVATAR_POSITION;
    static const float CONTROLLER_THRESHOLD;

    class InputDevice : public controller::InputDevice {
    public:
        InputDevice() : controller::InputDevice("Hydra") {}
        void setDebugDrawRaw(bool flag);
        void setDebugDrawCalibrated(bool flag);
    private:
        // Device functions
        virtual controller::Input::NamedVector getAvailableInputs() const override;
        virtual QString getDefaultMappingConfig() const override;
        virtual void update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override;
        virtual void focusOutEvent() override;

        void handleButtonEvent(unsigned int buttons, bool left);
        void handlePoseEvent(float deltaTime, const controller::InputCalibrationData& inputCalibrationData, const glm::vec3& position, const glm::quat& rotation, bool left);
        void updateCalibration(SixenseControllerData* controllers);

        friend class SixenseManager;

        int _calibrationState { CALIBRATION_STATE_IDLE };
        // these are calibration results
        glm::vec3 _avatarPosition { DEFAULT_AVATAR_POSITION }; // in hydra-frame
        glm::quat _avatarRotation; // in hydra-frame

        float _lastDistance;
        bool _requestReset { false };
        bool _debugDrawRaw { false };
        bool _debugDrawCalibrated { false };
        // these are measured values used to compute the calibration results
        quint64 _lockExpiry;
        glm::vec3 _averageLeft;
        glm::vec3 _averageRight;
        glm::vec3 _reachLeft;
        glm::vec3 _reachRight;
    };

    std::shared_ptr<InputDevice> _inputDevice { std::make_shared<InputDevice>() };

    static const char* NAME;
    static const char* SIXENSE_ID_STRING;

    static bool _isEnabled;
    static bool _sixenseLoaded;
};

#endif // hifi_SixenseManager_h