#if !defined(RBX_PLATFORM_DURANGO) && !defined(RBX_PLATFORM_UWP)
#include "DeviceD3D11.h"

#include "FramebufferD3D11.h"

#include <d3d11.h>

LOGGROUP(VR)

FASTFLAGVARIABLE(DebugRenderVRHUD, false)

#include "../Rendering/LibOVR/Include/OVR_CAPI_D3D.h"

#pragma comment(lib, "../Rendering/LibOVR/Lib/Windows/Win32/Release/VS2012/LibOVR.lib")

#define OVR_CHECK(call) \
	do { \
		ovrResult vrResult = call; \
		if (OVR_FAILURE(vrResult)) FASTLOG1(FLog::VR, "VR ERROR: " #call " returned %d", vrResult); \
	} while (0)

namespace RBX
{
namespace Graphics
{
	typedef HRESULT (WINAPI *TypeCreateDXGIFactory)(REFIID riid, void **ppFactory);

	static TypeCreateDXGIFactory getFactoryCreationFunction()
    {
        HMODULE module = LoadLibraryA("d3d11.dll");
        if (!module) return NULL;

		return (TypeCreateDXGIFactory)GetProcAddress(module, "CreateDXGIFactory");
    }

	static IDXGIAdapter* getAdapterForLuid(LUID luid)
	{
        // Allow to use null/default adapter for applications that may render a window without an HMD.
		if ((luid.HighPart | luid.LowPart) == 0)
			return NULL;

		TypeCreateDXGIFactory createFactory = getFactoryCreationFunction();
		if (!createFactory)
			return NULL;

		// Try to find adapter by LUID
		IDXGIFactory* factory = NULL;
		if (FAILED(createFactory(__uuidof(IDXGIFactory), (void**)&factory)))
			return NULL;

		UINT index = 0;

        for (;;)
        {
            IDXGIAdapter* adapter = NULL;

			if (SUCCEEDED(factory->EnumAdapters(index, &adapter)) && adapter)
			{
				DXGI_ADAPTER_DESC desc;

				if (SUCCEEDED(adapter->GetDesc(&desc)) && desc.AdapterLuid.HighPart == luid.HighPart && desc.AdapterLuid.LowPart == luid.LowPart)
				{
					ReleaseCheck(factory);

					return adapter;
				}
			}
			else
				break;

			index++;
		}

		ReleaseCheck(factory);

		return NULL;
    }

	static DeviceVR::Pose getPose(const ovrPosef& pose, unsigned int statusFlags)
	{
		DeviceVR::Pose result = {};

		result.valid = (statusFlags & ovrStatus_OrientationTracked) != 0;

		result.position[0] = pose.Position.x;
		result.position[1] = pose.Position.y;
		result.position[2] = pose.Position.z;

		result.orientation[0] = pose.Orientation.x;
		result.orientation[1] = pose.Orientation.y;
		result.orientation[2] = pose.Orientation.z;
		result.orientation[3] = pose.Orientation.w;

		return result;
	}

	struct VRTexture
	{
		static const int kMaxCount = 4;

		shared_ptr<Framebuffer> fb[kMaxCount];
		ovrSwapTextureSet* textureSet;

		VRTexture(): textureSet(NULL)
		{
		}
	};

	struct OculusVRD3D11: DeviceVRD3D11
	{
		ovrSession session;
		ovrHmdDesc desc;
		VRTexture textures[2];
		ovrEyeRenderDesc eyeDesc[2];

		double sensorSampleTime;
		ovrTrackingState trackingState;

		OculusVRD3D11(): session(NULL), sensorSampleTime(0)
		{
		}

		~OculusVRD3D11()
		{
			for (int eye = 0; eye < 2; ++eye)
				ovr_DestroySwapTextureSet(session, textures[eye].textureSet);

			ovr_Destroy(session);
			ovr_Shutdown();
		}

		void update() override
		{
			double frameTime = ovr_GetPredictedDisplayTime(session, 0);

			// Keeping sensorSampleTime as close to ovr_GetTrackingState as possible - fed into the layer
			sensorSampleTime = ovr_GetTimeInSeconds();
			trackingState = ovr_GetTrackingState(session, frameTime, ovrTrue);
		}

		void recenter() override
		{
			ovr_RecenterPose(session);
		}

		Framebuffer* getEyeFramebuffer(int eye) override
		{
			RBXASSERT(eye == 0 || eye == 1);

			return textures[eye].fb[textures[eye].textureSet->CurrentIndex].get();
		}

		State getState() override
		{
			State result = {};

			result.headPose = getPose(trackingState.HeadPose.ThePose, trackingState.StatusFlags);
			result.handPose[0] = getPose(trackingState.HandPoses[0].ThePose, trackingState.HandStatusFlags[0]);
			result.handPose[1] = getPose(trackingState.HandPoses[1].ThePose, trackingState.HandStatusFlags[1]);

			for (int eye = 0; eye < 2; ++eye)
			{
				result.eyeOffset[eye][0] = eyeDesc[eye].HmdToEyeViewOffset.x;
				result.eyeOffset[eye][1] = eyeDesc[eye].HmdToEyeViewOffset.y;
				result.eyeOffset[eye][2] = eyeDesc[eye].HmdToEyeViewOffset.z;

				result.eyeFov[eye][0] = eyeDesc[eye].Fov.UpTan;
				result.eyeFov[eye][1] = eyeDesc[eye].Fov.DownTan;
				result.eyeFov[eye][2] = eyeDesc[eye].Fov.LeftTan;
				result.eyeFov[eye][3] = eyeDesc[eye].Fov.RightTan;
			}

			result.needsMirror = true;

			return result;
		}

		void submitFrame(DeviceContext* context) override
		{
			ovrLayerEyeFov ld = {};
			ld.Header.Type = ovrLayerType_EyeFov;
			ld.Header.Flags = 0;

			ovrVector3f hmdToEyeViewOffset[2] = { eyeDesc[0].HmdToEyeViewOffset, eyeDesc[1].HmdToEyeViewOffset };
			ovrPosef eyeRenderPoses[2];
			ovr_CalcEyePoses(trackingState.HeadPose.ThePose, hmdToEyeViewOffset, eyeRenderPoses);

			for (int eye = 0; eye < 2; ++eye)
			{
				ld.ColorTexture[eye] = textures[eye].textureSet;
				ld.Viewport[eye].Pos.x = 0;
				ld.Viewport[eye].Pos.y = 0;
				ld.Viewport[eye].Size.w = textures[eye].fb[0]->getWidth();
				ld.Viewport[eye].Size.h = textures[eye].fb[0]->getHeight();
				ld.Fov[eye] = eyeDesc[eye].Fov;
				ld.RenderPose[eye] = eyeRenderPoses[eye];
				ld.SensorSampleTime = sensorSampleTime;
			}

			ovrViewScaleDesc viewScaleDesc;
			viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f;
			viewScaleDesc.HmdToEyeViewOffset[0] = eyeDesc[0].HmdToEyeViewOffset;
			viewScaleDesc.HmdToEyeViewOffset[1] = eyeDesc[1].HmdToEyeViewOffset;

			ovrLayerHeader* layers = &ld.Header;
			OVR_CHECK(ovr_SubmitFrame(session, 0, &viewScaleDesc, &layers, 1));

			for (int eye = 0; eye < 2; ++eye)
			{
				textures[eye].textureSet->CurrentIndex += 1;
				textures[eye].textureSet->CurrentIndex %= textures[eye].textureSet->TextureCount;
			}

			if (FFlag::DebugRenderVRHUD)
			{
				static bool keyWasDown = false;
				bool keyIsDown = (GetAsyncKeyState(VK_CONTROL) < 0 && GetAsyncKeyState(VK_F8) < 0);

				if (keyIsDown && !keyWasDown)
				{
					int perfHudMode = ovr_GetInt(session, OVR_PERF_HUD_MODE, 0);

					perfHudMode += 1;
					perfHudMode %= ovrPerfHud_Count;
					
					ovr_SetInt(session, OVR_PERF_HUD_MODE, perfHudMode);
				}

				keyWasDown = keyIsDown;
			}
		}

		void setup(Device* device) override
		{
			ID3D11Device* device11 = static_cast<DeviceD3D11*>(device)->getDevice11();

			// Work around a bug in LibOVR
			ShowWindow(static_cast<HWND>(static_cast<DeviceD3D11*>(device)->getWindowHandle()), SW_SHOWNORMAL);

			ovrSizei idealSizeLeft = ovr_GetFovTextureSize(session, ovrEye_Left, desc.DefaultEyeFov[ovrEye_Left], 1.0f);
			ovrSizei idealSizeRight = ovr_GetFovTextureSize(session, ovrEye_Right, desc.DefaultEyeFov[ovrEye_Right], 1.0f);

			unsigned int width = std::max(idealSizeLeft.w, idealSizeRight.w);
			unsigned int height = std::max(idealSizeLeft.h, idealSizeRight.h);

			shared_ptr<Renderbuffer> depthStencil = shared_ptr<Renderbuffer>(new RenderbufferD3D11(device, Texture::Format_D24S8, width, height, 1));

			for (int eye = 0; eye < 2; ++eye)
			{
				D3D11_TEXTURE2D_DESC dsDesc;
				dsDesc.Width = width;
				dsDesc.Height = height;
				dsDesc.MipLevels = 1;
				dsDesc.ArraySize = 1;
				dsDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
				dsDesc.SampleDesc.Count = 1;
				dsDesc.SampleDesc.Quality = 0;
				dsDesc.Usage = D3D11_USAGE_DEFAULT;
				dsDesc.CPUAccessFlags = 0;
				dsDesc.MiscFlags = 0;
				dsDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;

				ovrResult result = ovr_CreateSwapTextureSetD3D11(session, device11, &dsDesc, ovrSwapTextureSetD3D11_Typeless, &textures[eye].textureSet);
				if (OVR_FAILURE(result))
					throw RBX::runtime_error("ovr_CreateSwapTextureSetD3D11 failed with %d", result);

				RBXASSERT(textures[eye].textureSet->TextureCount <= VRTexture::kMaxCount);

				for (int i = 0; i < textures[eye].textureSet->TextureCount; ++i)
				{
					ovrD3D11Texture* tex = reinterpret_cast<ovrD3D11Texture*>(&textures[eye].textureSet->Textures[i]);

					tex->D3D11.pTexture->AddRef();

					shared_ptr<Renderbuffer> colorBuffer(new RenderbufferD3D11(device, Texture::Format_RGBA8, width, height, 1, tex->D3D11.pTexture));

					textures[eye].fb[i] = device->createFramebuffer(colorBuffer, depthStencil);
				}
			}
		}
	};

	static void logCallback(uintptr_t userData, int level, const char* message)
	{
		FASTLOGS(FLog::VR, "VR: %s", message);
	}

	DeviceVRD3D11* DeviceVRD3D11::createOculus(IDXGIAdapter** outAdapter)
	{
		ovrInitParams params = {};

		params.LogCallback = logCallback;

		ovrResult vrResult = ovr_Initialize(&params);

		if (!OVR_SUCCESS(vrResult))
		{
			FASTLOG1(FLog::VR, "VR: ovr_Initialize returned %d", vrResult);
			return NULL;
		}

		ovrSession session;
		ovrGraphicsLuid vrLuid;

		vrResult = ovr_Create(&session, &vrLuid);

		if (!OVR_SUCCESS(vrResult))
		{
			FASTLOG1(FLog::VR, "VR: ovr_Create returned %d", vrResult);

			ovr_Shutdown();

			return NULL;
		}

		OculusVRD3D11* vr = new OculusVRD3D11();

		vr->session = session;
		vr->desc = ovr_GetHmdDesc(session);

		for (int eye = 0; eye < 2; ++eye)
			vr->eyeDesc[eye] = ovr_GetRenderDesc(session, (ovrEyeType)eye, vr->desc.DefaultEyeFov[eye]);

		if (outAdapter)
			*outAdapter = getAdapterForLuid(*reinterpret_cast<LUID*>(&vrLuid));

		FASTLOGS(FLog::VR, "VR: Connected to %s", vr->desc.ProductName);
		FASTLOG4(FLog::VR, "VR: Vendor %x Product %x Firmware %d.%d", vr->desc.VendorId, vr->desc.ProductId, vr->desc.FirmwareMajor, vr->desc.FirmwareMinor);

		return vr;
	}

}
}
#endif