using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;
using System.Reflection;
using UnityEngine;
using UnityEngine.Android;
using UnityEngine.Rendering;
using UnityEngine.XR.Management;
using UnityEngine.XR;

#if UNITY_INPUT_SYSTEM && ENABLE_VR
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Layouts;
using UnityEngine.InputSystem.XR;
using Unity.XR.Oculus.Input;
#endif

#if UNITY_EDITOR
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.MPE;
#endif


namespace Unity.XR.Oculus
{
#if UNITY_INPUT_SYSTEM && ENABLE_VR
#if UNITY_EDITOR
    [InitializeOnLoad]
#endif
    static class InputLayoutLoader
    {
        static InputLayoutLoader()
        {
            RegisterInputLayouts();
        }

        public static void RegisterInputLayouts()
        {
            InputSystem.RegisterLayout<OculusHMD>(
                matches: new InputDeviceMatcher()
                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
                    .WithProduct("^(Oculus Rift)|^(Oculus Quest)|^(Oculus Go)"));
            InputSystem.RegisterLayout<OculusTouchController>(
                matches: new InputDeviceMatcher()
                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
                    .WithProduct(@"(^(Oculus Touch Controller))|(^(Oculus Quest Controller))"));
            InputSystem.RegisterLayout<OculusRemote>(
                matches: new InputDeviceMatcher()
                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
                    .WithProduct(@"Oculus Remote"));
            InputSystem.RegisterLayout<OculusTrackingReference>(
                matches: new InputDeviceMatcher()
                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
                    .WithProduct(@"((Tracking Reference)|(^(Oculus Rift [a-zA-Z0-9]* \(Camera)))"));
            InputSystem.RegisterLayout<OculusGoController>(
                matches: new InputDeviceMatcher()
                    .WithInterface(XRUtilities.InterfaceMatchAnyVersion)
                    .WithProduct("^(Oculus Tracked Remote)"));

            InputSystem.RegisterLayout<OculusHMDExtended>();
            InputSystem.RegisterLayout<GearVRTrackedController>();
        }
    }
#endif

    public class OculusLoader : XRLoaderHelper
#if UNITY_EDITOR
    , IXRLoaderPreInit
#endif
    {
        private enum DeviceSupportedResult
        {
            Supported,             // we should attempt to initialize and run in VR
            NotSupported,          // we shouldn't attempt to initialize on this device, and should run in non-VR
            ExitApplication        // we're built for VR, but are on a non-Oculus Android device and should exit the application
        };

        static DeviceSupportedResult IsDeviceSupported()
        {
#if !ENABLE_VR
            return DeviceSupportedResult.NotSupported;
#elif UNITY_EDITOR_WIN
            if(RuntimePlatformChecks.IsSupportedPlatform())
                return DeviceSupportedResult.Supported;
            else
                return DeviceSupportedResult.NotSupported;
#elif (UNITY_STANDALONE_WIN && !UNITY_EDITOR)
            if(RuntimePlatformChecks.IsSupportedPlatform())
                return DeviceSupportedResult.Supported;
            else
                return DeviceSupportedResult.NotSupported;
#elif (UNITY_ANDROID && !UNITY_EDITOR)
            try
            {
                if (NativeMethods.GetIsSupportedDevice())
                    return DeviceSupportedResult.Supported;
                else
                    return DeviceSupportedResult.ExitApplication;
            }
            catch(DllNotFoundException)
            {
                // return NotSupported since we've been built with Oculus XR Plugin disabled
                return DeviceSupportedResult.NotSupported;
            }
#else
            return DeviceSupportedResult.NotSupported;
#endif
        }

#if ENABLE_VR
        private static List<XRDisplaySubsystemDescriptor> s_DisplaySubsystemDescriptors = new List<XRDisplaySubsystemDescriptor>();
        private static List<XRInputSubsystemDescriptor> s_InputSubsystemDescriptors = new List<XRInputSubsystemDescriptor>();

        public XRDisplaySubsystem displaySubsystem
        {
            get
            {
                return GetLoadedSubsystem<XRDisplaySubsystem>();
            }
        }

        public XRInputSubsystem inputSubsystem
        {
            get
            {
                return GetLoadedSubsystem<XRInputSubsystem>();
            }
        }
#endif

        private static NativeMethods.UnityVersion unityEngineVersion;

        public override bool Initialize()
        {
            if (!CheckUnityVersionCompatibility())
            {
                return false;
            }

            if (IsDeviceSupported() != DeviceSupportedResult.Supported
#if UNITY_EDITOR_WIN
                || SystemInfo.graphicsDeviceType != GraphicsDeviceType.Direct3D11
#endif
            )
            {
                return false;
            }

#if ENABLE_VR
#if UNITY_INPUT_SYSTEM
            InputLayoutLoader.RegisterInputLayouts();
#endif

            OculusSettings settings = GetSettings();

            if (settings != null)
            {
                NativeMethods.UserDefinedSettings userDefinedSettings;
                userDefinedSettings.sharedDepthBuffer = (ushort)(settings.SharedDepthBuffer ? 1 : 0);
                userDefinedSettings.dashSupport = (ushort)(settings.DashSupport ? 1 : 0);
                userDefinedSettings.stereoRenderingMode = (ushort)settings.GetStereoRenderingMode();
                userDefinedSettings.colorSpace = (ushort)((QualitySettings.activeColorSpace == ColorSpace.Linear) ? 1 : 0);
                userDefinedSettings.lowOverheadMode = (ushort)(settings.LowOverheadMode ? 1 : 0);
                userDefinedSettings.optimizeBufferDiscards = (ushort)(settings.OptimizeBufferDiscards ? 1 : 0);
                userDefinedSettings.symmetricProjection = (ushort)(settings.SymmetricProjection ? 1 : 0);
                userDefinedSettings.subsampledLayout = (ushort)(settings.SubsampledLayout ? 1 : 0);
                userDefinedSettings.foveatedRenderingMethod = (ushort)settings.FoveatedRenderingMethod;
                userDefinedSettings.lateLatching = (ushort)(settings.LateLatching ? 1 : 0);
                userDefinedSettings.lateLatchingDebug = (ushort)(settings.LateLatchingDebug ? 1 : 0);
                userDefinedSettings.enableTrackingOriginStageMode = (ushort)(settings.EnableTrackingOriginStageMode ? 1 : 0);
#if (UNITY_ANDROID && !UNITY_EDITOR)
                userDefinedSettings.spaceWarp = (ushort)(settings.SpaceWarp ? 1 : 0);
                userDefinedSettings.depthSubmission = (ushort)(settings.DepthSubmission ? 1 : 0);
                userDefinedSettings.optimizeMultiviewRenderRegions = (ushort)(settings.OptimizeMultiviewRenderRegions ? 1 : 0);
#else
                userDefinedSettings.spaceWarp = 0;
                userDefinedSettings.depthSubmission = 0;
                userDefinedSettings.optimizeMultiviewRenderRegions = 0;
#endif
                NativeMethods.SetUserDefinedSettings(userDefinedSettings, unityEngineVersion);
            }

            CreateSubsystem<XRDisplaySubsystemDescriptor, XRDisplaySubsystem>(s_DisplaySubsystemDescriptors, "oculus display");
            CreateSubsystem<XRInputSubsystemDescriptor, XRInputSubsystem>(s_InputSubsystemDescriptors, "oculus input");

            if (displaySubsystem == null && inputSubsystem == null)
            {
#if (UNITY_ANDROID && !UNITY_EDITOR)
                Debug.LogWarning("Unable to start Oculus XR Plugin.");
#else
                Debug.LogWarning("Unable to start Oculus XR Plugin.\n" +
                                 "Possible causes include a headset not being attached, or the Oculus runtime is not installed or up to date.\n" +
                                 "If you've recently installed or updated the Oculus runtime, you may need to reboot or close Unity and the Unity Hub and try again.");
#endif
            }
            else if (displaySubsystem == null)
            {
                Debug.LogError("Unable to start Oculus XR Plugin. Failed to load display subsystem.");
            }
            else if (inputSubsystem == null)
            {
                Debug.LogError("Unable to start Oculus XR Plugin. Failed to load input subsystem.");
            }
            else
            {
                RegisterUpdateCallback.Initialize();
            }


#if UNITY_2023_2_OR_NEWER && UNITY_URP_16
            if (settings != null && settings.FoveatedRenderingMethod == OculusSettings.FoveationMethod.EyeTrackedFoveatedRenderingUsingUnityAPIForURP)
            {
                // With Unity's generic foveation API, we will request eye tracking permission here to prevent needing code specific to a single plugin to control foveation
                Utils.eyeTrackedFoveatedRenderingEnabled = true;
            }
#endif

            return displaySubsystem != null && inputSubsystem != null;
#else
            return false;
#endif
        }

        public override bool Start()
        {
#if ENABLE_VR
            StartSubsystem<XRDisplaySubsystem>();
            StartSubsystem<XRInputSubsystem>();
#endif
            Development.OverrideDeveloperModeStart();

            return true;
        }

        public override bool Stop()
        {
#if ENABLE_VR
            StopSubsystem<XRDisplaySubsystem>();
            StopSubsystem<XRInputSubsystem>();
#endif
            Development.OverrideDeveloperModeStop();

            return true;
        }

        public override bool Deinitialize()
        {
            RegisterUpdateCallback.Deinitialize();

#if ENABLE_VR
            DestroySubsystem<XRDisplaySubsystem>();
            DestroySubsystem<XRInputSubsystem>();
#endif

            return true;
        }

#if UNITY_EDITOR_WIN
        [InitializeOnLoadMethod]
        static void EditorLoadOVRPlugin()
        {
            // early out for if this is invoked inside a secondary process (e.g. Standalone Profiler)
            if ((uint)ProcessService.level == (uint)ProcessLevel.Secondary)
                return;

            // early out for unsupported platforms like Windows Arm64
            if(!RuntimePlatformChecks.IsSupportedPlatform())
                return;

            string ovrpPath = "";

            // loop over all the native plugin importers and find the OVRPlugin the editor should use
            var importers = PluginImporter.GetAllImporters();
            foreach (var importer in importers)
            {
                if (!importer.GetCompatibleWithEditor() || !importer.assetPath.Contains("OVRPlugin"))
                    continue;

                if (!importer.GetCompatibleWithPlatform(BuildTarget.StandaloneWindows64) || !importer.assetPath.EndsWith(".dll"))
                    continue;

                ovrpPath = importer.assetPath;

                if (!importer.GetIsOverridable())
                    break;
            }

            if (ovrpPath == "")
            {
                Debug.LogError("Couldn't locate OVRPlugin.dll");
                return;
            }

            if (!NativeMethods.LoadOVRPlugin(AssetPathToAbsolutePath(ovrpPath)))
            {
                Debug.LogError("Failed to load OVRPlugin.dll");
                return;
            }
        }

        static string AssetPathToAbsolutePath(string assetPath)
        {
            var path = assetPath.Replace('/', Path.DirectorySeparatorChar);

            if (assetPath.StartsWith("Packages"))
            {
                path = String.Join(Path.DirectorySeparatorChar.ToString(), path.Split(Path.DirectorySeparatorChar).Skip(2));

                return Path.Combine(UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath).resolvedPath, path);
            }
            else
            {
                string assetsPath = Application.dataPath;
                assetsPath = assetsPath.Replace('/', Path.DirectorySeparatorChar);

                if (assetsPath.EndsWith("Assets"))
                {
                    assetsPath = assetsPath.Substring(0, assetsPath.LastIndexOf("Assets"));
                }

                return Path.Combine(assetsPath, assetPath);
            }
        }
#elif (UNITY_STANDALONE_WIN && !UNITY_EDITOR)
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
        static void RuntimeLoadOVRPlugin()
        {
            var supported = IsDeviceSupported();

            if (supported != DeviceSupportedResult.Supported)
                return;

            try
            {
                if (!NativeMethods.LoadOVRPlugin(""))
                    Debug.LogError("Failed to load OVRPlugin.dll");
            }
            catch
            {
                // handle Windows standalone build with Oculus XR Plugin installed but disabled in loader list.
            }
        }
#elif (UNITY_ANDROID && !UNITY_EDITOR)
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
        static void RuntimeLoadOVRPlugin()
        {
            var supported = IsDeviceSupported();

            if (supported == DeviceSupportedResult.ExitApplication)
            {
                Debug.LogError("\n\nExiting application:\n\nThis .apk was built with the Oculus XR Plugin loader enabled, but is attempting to run on a non-Oculus device.\nTo build for general Android devices, please disable the Oculus XR Plugin before building the Android player.\n\n\n");
                Application.Quit();
            }

            if (supported != DeviceSupportedResult.Supported)
                return;

            try
            {
                if (!NativeMethods.LoadOVRPlugin(""))
                    Debug.LogError("Failed to load libOVRPlugin.so");
            }
            catch
            {
                // handle Android standalone build with Oculus XR Plugin installed but disabled in loader list.
            }

        }
#endif

#if UNITY_EDITOR && XR_MGMT_GTE_320
#if UNITY_6000_1_OR_NEWER
        private void RemoveD3D12FromStandaloneGraphicsAPIs()
        {
            bool d3d12Removed = false;

            if (PlayerSettings.GetUseDefaultGraphicsAPIs(BuildTarget.StandaloneWindows64))
            {
                PlayerSettings.SetUseDefaultGraphicsAPIs(BuildTarget.StandaloneWindows64, false);
                d3d12Removed = true;
            }

            GraphicsDeviceType[] oldApis = PlayerSettings.GetGraphicsAPIs(BuildTarget.StandaloneWindows64);
            List<GraphicsDeviceType> newApisList = new List<GraphicsDeviceType>();

            // copy all entries except D3D12
            foreach (GraphicsDeviceType dev in oldApis)
            {
                if (dev == GraphicsDeviceType.Direct3D12)
                {
                    d3d12Removed = true;
                    continue;
                }

                newApisList.Add(dev);
            }

            // if we didn't remove D3D12 from the list, no need to do any further processing
            if (d3d12Removed == false)
                return;

            string removalWarning;

            if (newApisList.Count <= 0)
            {
                newApisList.Add(GraphicsDeviceType.Direct3D11);
                removalWarning = "Direct3D 12 is unsupported with the Oculus XR Plugin. It has been removed from your list of Windows graphics APIs and replaced with Direct3D 11.";
            }
            else
            {
                removalWarning = "Direct3D 12 is unsupported with the Oculus XR Plugin. It has been removed from your list of Windows graphics APIs.";
            }

            Debug.LogWarning(removalWarning);

            PlayerSettings.SetGraphicsAPIs(BuildTarget.StandaloneWindows64, newApisList.ToArray());

            // restart the editor
            string dialogMsg = removalWarning + "\n\nRestart the editor now to use the updated settings, otherwise a restart will be required later to run on device.";
            if (EditorUtility.DisplayDialog("Unity editor restart required", dialogMsg, "Restart", "Continue"))
            {
                typeof(EditorApplication).GetMethod("RestartEditorAndRecompileScripts", BindingFlags.NonPublic | BindingFlags.Static)?.Invoke(null, null);
            }
        }
#endif // UNITY_6000_1_OR_NEWER

        private void SetAndroidMinSdkVersion()
        {
            if (PlayerSettings.Android.minSdkVersion < AndroidSdkVersions.AndroidApiLevel23)
            {
                Debug.Log("The Android Minimum API Level has been updated to 23 in Player Settings as this is the minimum required for Oculus builds.");
                PlayerSettings.Android.minSdkVersion = AndroidSdkVersions.AndroidApiLevel23;
            }
        }

        public override void WasAssignedToBuildTarget(BuildTargetGroup buildTargetGroup)
        {
#if UNITY_6000_1_OR_NEWER
            if (buildTargetGroup == BuildTargetGroup.Standalone)
            {
                RemoveD3D12FromStandaloneGraphicsAPIs();
            }
#endif

            if (buildTargetGroup == BuildTargetGroup.Android)
            {
                SetAndroidMinSdkVersion();
            }
        }
#endif // UNITY_EDITOR && XR_MGMT_GTE_320

        public OculusSettings GetSettings()
        {
            OculusSettings settings = null;
#if UNITY_EDITOR
            UnityEditor.EditorBuildSettings.TryGetConfigObject<OculusSettings>("Unity.XR.Oculus.Settings", out settings);
#else
            settings = OculusSettings.s_Settings;
#endif
            return settings;
        }

#if UNITY_EDITOR
        public string GetPreInitLibraryName(BuildTarget buildTarget, BuildTargetGroup buildTargetGroup)
        {
            return "OculusXRPlugin";
        }
#endif

        private bool CheckUnityVersionCompatibility()
        {
#if !UNITY_2021_3_OR_NEWER
            Debug.LogWarning("This version of the Oculus XR Plugin requires at least Unity 2021.3.4f1.\n" +
                             "Please update to that version or higher of Unity, or use the verified Oculus XR Plugin package for this version of Unity.");
            return false;
#else
            // verify that 3.1.0+ versions of the package are on compatible versions of Unity
            var unityVersion = Application.unityVersion;
            var versionRegex = @"^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?<type>.)(?<buildNumber>\d+)";
            var match = Regex.Match(unityVersion, versionRegex);

            // if we can't parse the Unity version number, just assume success
            if (!match.Success)
                return true;

            int major = Int32.Parse((match.Groups["major"].Value));
            int minor = Int32.Parse((match.Groups["minor"].Value));
            int patch = Int32.Parse((match.Groups["patch"].Value));
            char type = Char.Parse(match.Groups["type"].Value);
            int buildNumber = Int32.Parse((match.Groups["buildNumber"].Value));

            // 2021.3 requires at least 2021.3.4f1. this is handled by the package.json, but handle here for internal development as well
            if (major == 2021)
            {
                if ((minor < 3) || ((minor == 3) && (patch < 4)))
                {
                    Debug.LogWarning("This version of the Oculus XR Plugin requires at least Unity 2021.3.4f1.\n" +
                                     "Please update to that version or higher of Unity, or use the verified Oculus XR Plugin package for this version of Unity.");
                    return false;
                }
            }

            // 2022.1 requires at least 2022.1.12f1
            if ((major == 2022) && (minor == 1) && (patch < 12))
            {
                Debug.LogWarning("This version of the Oculus XR Plugin requires at least Unity 2022.1.12f1.\n" +
                                 "Please update to that version or higher of Unity, or use the verified Oculus XR Plugin package for this version of Unity.");
                return false;
            }

            // 2022.2 requires at least 2022.0b1
            if ((major == 2022) && (minor == 2) && (patch == 0) && (type == 'a'))
            {
                Debug.LogWarning("This version of the Oculus XR Plugin requires at least Unity 2022.2.0b1.\n" +
                                 "Please update to that version or higher of Unity, or use the verified Oculus XR Plugin package for this version of Unity.");
                return false;
            }

            unityEngineVersion.major = major;
            unityEngineVersion.minor = minor;
            unityEngineVersion.patch = patch;
            unityEngineVersion.type = type;
            unityEngineVersion.buildNumber = buildNumber;

            return true;
#endif
        }
    }
}