//
//  Created by Bradley Austin Davis on 2015/05/26
//  Copyright 2015 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
//
#pragma once

#include <QtCore/QLoggingCategory>

#include <ovr_capi.h>
#include <GLMHelpers.h>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include <controllers/Forward.h>

Q_DECLARE_LOGGING_CATEGORY(displayplugins)
Q_DECLARE_LOGGING_CATEGORY(oculusLog)

namespace hifi { 
    
struct ovr {
    static bool available();
    static ovrSession acquireRenderSession();
    static void releaseRenderSession(ovrSession session);
    static void withSession(const std::function<void(ovrSession)>& f);
    static ovrSessionStatus getStatus();
    static ovrSessionStatus getStatus(ovrResult& result);
    static ovrTrackingState getTrackingState(double absTime = 0.0, ovrBool latencyMarker = ovrFalse);
    static QString getError();

    static inline bool quitRequested() { return quitRequested(getStatus()); }
    static inline bool reorientRequested() { return reorientRequested(getStatus()); }
    static inline bool hmdMounted() { return hmdMounted(getStatus()); }
    static inline bool hasInputFocus() { return hasInputFocus(getStatus()); }

    static inline bool quitRequested(const ovrSessionStatus& status) { return status.ShouldQuit != ovrFalse; }
    static inline bool displayLost(const ovrSessionStatus& status) { return status.DisplayLost != ovrFalse; }
    static inline bool isVisible(const ovrSessionStatus& status) { return status.IsVisible != ovrFalse; }
    static inline bool reorientRequested(const ovrSessionStatus& status) { return status.ShouldRecenter != ovrFalse; }
    static inline bool hmdMounted(const ovrSessionStatus& status) { return status.HmdMounted != ovrFalse; }
    static inline bool hasInputFocus(const ovrSessionStatus& status) { return status.HasInputFocus != ovrFalse; }

    // Convenience method for looping over each eye with a lambda
    static inline void for_each_eye(const std::function<void(ovrEyeType eye)>& f) {
        for (ovrEyeType eye = ovrEye_Left; eye < ovrEye_Count; eye = static_cast<ovrEyeType>(eye + 1)) {
            f(eye);
        }
    }

    static inline void for_each_hand(const std::function<void(ovrHandType eye)>& f) {
        for (ovrHandType hand = ovrHand_Left; hand < ovrHand_Count; hand = static_cast<ovrHandType>(hand + 1)) {
            f(hand);
        }
    }

    static inline glm::mat4 toGlm(const ovrMatrix4f& om) {
        return glm::transpose(glm::make_mat4(&om.M[0][0]));
    }

    static inline glm::mat4 toGlm(const ovrFovPort& fovport, float nearPlane = 0.01f, float farPlane = 10000.0f) {
        return toGlm(ovrMatrix4f_Projection(fovport, nearPlane, farPlane, true));
    }

    static inline glm::vec3 toGlm(const ovrVector3f& ov) {
        return glm::make_vec3(&ov.x);
    }

    static inline glm::vec2 toGlm(const ovrVector2f& ov) {
        return glm::make_vec2(&ov.x);
    }

    static inline glm::uvec2 toGlm(const ovrSizei& ov) {
        return glm::uvec2(ov.w, ov.h);
    }

    static inline glm::quat toGlm(const ovrQuatf& oq) {
        return glm::make_quat(&oq.x);
    }

    static inline glm::mat4 toGlm(const ovrPosef& op) {
        glm::mat4 orientation = glm::mat4_cast(toGlm(op.Orientation));
        glm::mat4 translation = glm::translate(glm::mat4(), toGlm(op.Position));
        return translation * orientation;
    }

    static inline ovrMatrix4f fromGlm(const glm::mat4& m) {
        ovrMatrix4f result;
        glm::mat4 transposed(glm::transpose(m));
        memcpy(result.M, &(transposed[0][0]), sizeof(float) * 16);
        return result;
    }

    static inline ovrVector3f fromGlm(const glm::vec3& v) {
        return { v.x, v.y, v.z };
    }

    static inline ovrVector2f fromGlm(const glm::vec2& v) {
        return { v.x, v.y };
    }

    static inline ovrSizei fromGlm(const glm::uvec2& v) {
        return { (int)v.x, (int)v.y };
    }

    static inline ovrQuatf fromGlm(const glm::quat& q) {
        return { q.x, q.y, q.z, q.w };
    }

    static inline ovrPosef poseFromGlm(const glm::mat4& m) {
        glm::vec3 translation = glm::vec3(m[3]) / m[3].w;
        glm::quat orientation = glm::quat_cast(m);
        ovrPosef result;
        result.Orientation = fromGlm(orientation);
        result.Position = fromGlm(translation);
        return result;
    }

    static controller::Pose toControllerPose(ovrHandType hand, const ovrPoseStatef& handPose);
    static controller::Pose toControllerPose(ovrHandType hand, const ovrPoseStatef& handPose, const ovrPoseStatef& lastHandPose);

};

}  // namespace hifi