using System;
using System.Linq;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
using System.Diagnostics;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.XR.Management;
using UnityEditor;
using UnityEditor.XR.Management.Metadata;
using UnityEditor.XR.Management;
using UnityEditor.PackageManager;
using UnityEditor.Build.Reporting;

public static class Build
{
    /// <summary>
    /// Allows us to get the Environmental Arguments passed in through the commandline.  
    /// </summary>
    private static readonly string[] Arguments = Environment.GetCommandLineArgs();

    /// <summary>
    /// Retrieves the value of a command-line argument by name, 
    /// searching for an argument starting with '--' followed by the 
    /// specified name and returning the following argument's value.
    /// </summary>
    private static string GetArgument(string name) =>
    Arguments[Array.IndexOf(Arguments, $"--{name}") + 1];

    /// <summary>
    /// We use this to retrieve the BuildDevice passed in from the pipeline variable or batcmode commandline.
    /// </summary>
    private static readonly BuildDevice BuildDevice = (BuildDevice)Enum.Parse(typeof(BuildDevice), GetArgument("deviceModel"), true);


    /// <summary>
    /// This section handles enabling all the project player settings, remove unused packages and directories, enabling 
    /// the device for XR Plug-in Managment, copying AndroidManifest files and setting the Scripting Define Symbols.
    /// Prepare is called from the Pipeline.Unity.csproj if there are no error the pipeline will continue onto the Invoke section
    /// of the build script. 
    /// </summary>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    /// <exception cref="Exception"></exception>
    public static void Prepare()
    {
        /// <summary>
        /// Used for holding the XR Management values and enabling the correct device when building the apk.
        /// </summary>
        string expectedLoader;

        /// <summary>
        /// Used for Unloading the uneccesary device packages not needed when building a specific device apk.
        /// </summary>
        string requiredPackageRegex;

        /// <summary>
        /// Used to define and remove device folder from the Project Assets folder
        /// </summary>
        string[] requiredDirectories;

        /// <summary>
        /// Used to hold all package names to compare against requiredPackageRegex
        /// </summary>
        var allPackageRegexes = new[] { "picoxr", "com.htc", "oculus" };

        /// <summary>
        /// Used to hold all Directories to compare against requiredDirectories
        /// </summary>
        var allDirectories = new[] { "Wave", "Oculus" };

        /// <summary>
        /// Switch is used to set and clean each pipeline project for the device that is being built.
        /// </summary>
        switch (BuildDevice)
        {
            case BuildDevice.Pico:
                UnityEngine.Debug.Log("!Pico Neo enabled");
                expectedLoader = "Unity.XR.PXR.PXR_Loader";
                requiredPackageRegex = "picoxr";
                requiredDirectories = Array.Empty<string>();
                break;

            case BuildDevice.Vive:
                UnityEngine.Debug.Log("!Vive Wave enabled");
                expectedLoader = "Unity.XR.WaveXR.WaveXRLoader";
                requiredPackageRegex = "com.htc";
                requiredDirectories = new[] { "Wave" };
                break;

            case BuildDevice.Oculus:
                UnityEngine.Debug.Log("!Oculus Quest enabled");
                expectedLoader = "Unity.XR.Oculus.OculusLoader";
                requiredPackageRegex = "oculus";
                requiredDirectories = new[] { "Oculus" };
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(BuildDevice), BuildDevice, "Unsupported build device.");
        }

        ///<summary>
        /// This section is used to remove unneeded directories in the Assets folder. It also reduces the
        /// the apps file size. 
        /// </summary>
        #region Remove Unused Directories

        var directoriesToExclude = allDirectories.Except(requiredDirectories);
        foreach (var directory in directoriesToExclude)
        {
            UnityEngine.Debug.Log($"!Directory removed {directory}");
            var error = AssetDatabase.MoveAsset(Path.Combine("Assets", directory), Path.Combine("Assets", $"{directory}~"));
        }

        #endregion

        ///<summary>
        /// This section is used to set the device under XR Plug-in Management you would find in project settings. 
        /// </summary>
        #region Set XR Plug-in Management

        if (!EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out XRGeneralSettingsPerBuildTarget buildTargetSettings))
        {
            throw new Exception("Unable to retrieve configuration object of XR general settings.");
        }

        var settings = buildTargetSettings.SettingsForBuildTarget(BuildTargetGroup.Android);
        settings.InitManagerOnStart = true;

        foreach (var loader in settings.AssignedSettings.activeLoaders.ToList())
        {
            var loaderTypeName = loader.GetType().FullName;
            if (loader.name != expectedLoader
                && !XRPackageMetadataStore.RemoveLoader(settings.Manager, loaderTypeName, BuildTargetGroup.Android))
            {
                throw new Exception($"Unable to remove loader '{loaderTypeName}'.");
            }
        }

        if (!XRPackageMetadataStore.AssignLoader(settings.Manager, expectedLoader, BuildTargetGroup.Android))
        {
            throw new Exception($"Unable to assign loader '{expectedLoader}'.");
        }

        #endregion

        ///<summary>
        /// There is no need to keep the packages of other devices in a specific device build. 
        /// It bloats the project file size and will show null errors in the logcat console.
        /// We use this section to remove packages that are not needed.
        /// </summary>
        #region Remove Unused Packages

        if (requiredPackageRegex != null)
        {
            var listRequest = Client.List(true, false);
            while (!listRequest.IsCompleted)
            {
                Thread.Sleep(100);
            }

            if (listRequest.Error != null)
            {
                throw new Exception($"Failed retrieving packages: {listRequest.Error.errorCode} - {listRequest.Error.message}");
            }

            var regexes = allPackageRegexes.Where(regex => regex != requiredPackageRegex).ToArray();
            var packagesToRemove = listRequest.Result.Where(package => regexes.Any(regex => Regex.IsMatch(package.name, regex)));
            foreach (var package in packagesToRemove)
            {
                var removalRequest = Client.Remove(package.name);
                UnityEngine.Debug.Log($"!Packages removed {package.name}");
                while (!removalRequest.IsCompleted)
                {
                    Thread.Sleep(100);
                }

                if (removalRequest.Error != null)
                {
                    throw new Exception($"Failed removing package '{package.name}': {removalRequest.Error.errorCode} - {removalRequest.Error.message}");
                }
            }
        }

        #endregion

        ///<summary>
        /// Each device has a specific androidmanifest it generates on build or can be custom set. 
        /// In our case we are using the custom setting and copying the specific requirements to each 
        /// device build.
        /// </summary>
        #region Copy Device AndroidManifest
        File.Copy(
            Path.Combine(Application.dataPath, "Editor", $"AndroidManifest-{BuildDevice}.xml"),
            Path.Combine(Application.dataPath, "Plugins", "Android", $"AndroidManifest.xml"),
            true);
        #endregion

        ///<summary>
        /// Each device has different api and project settings that need to be enabled. Most of them are the same but
        /// in this section we can set the specific setting to enable the player setting features. 
        /// </summary>
        #region Set Device PlayerSettings

        switch (BuildDevice)
        {
            case BuildDevice.Pico:
                PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new GraphicsDeviceType[] { GraphicsDeviceType.OpenGLES3 });
                PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);
                PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
                PlayerSettings.Android.minSdkVersion = AndroidSdkVersions.AndroidApiLevel29;
                PlayerSettings.SplashScreen.show = false;
                break;
            case BuildDevice.Vive:
                PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new GraphicsDeviceType[] { GraphicsDeviceType.OpenGLES3 });
                PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);
                PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
                PlayerSettings.Android.minSdkVersion = AndroidSdkVersions.AndroidApiLevel26;
                PlayerSettings.SplashScreen.show = false;
                break;
            case BuildDevice.Oculus:
                PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new GraphicsDeviceType[] { GraphicsDeviceType.OpenGLES3 });
                PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);
                PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;
                PlayerSettings.Android.minSdkVersion = AndroidSdkVersions.AndroidApiLevel29;
                PlayerSettings.SplashScreen.show = false;
                break;
        }

        #endregion

        /// <summary>
        /// This passes in the BuildDevice and setting the scripting symbol to enable the defines code in each script
        /// </summary>
        #region Set DefineSymbols
        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, $"{PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android)};BUILD_{BuildDevice.ToString().ToUpperInvariant()}");
        #endregion


    }

    /// <summary>
    /// This section is called if Prepare doesn't have any errors and fails the build cycle. 
    /// It is used to programatically create a build of your project. Log the success or failure or the build and has a condition for
    /// Quest that quite the adb.exe task that hangs after a Succeeded build. 
    /// </summary>
    /// <exception cref="Exception"></exception>
    public static void Invoke()
    {
        UnityEngine.Debug.LogError($"!Buidling Invoke Started");
        var report = BuildPipeline.BuildPlayer(new BuildPlayerOptions()
        {
            scenes = new[] { "Assets/Scenes/SampleScene.unity" },
            locationPathName = $"{GetArgument("outputPath")}/{PlayerSettings.GetApplicationIdentifier(BuildTargetGroup.Android)}-ArborXR-Demo-{BuildDevice}.apk",
            targetGroup = BuildTargetGroup.Android,
            target = BuildTarget.Android,
            options = BuildOptions.CompressWithLz4HC | BuildOptions.StrictMode
        });
        
        ///<summary>
        /// Used to give more insight to the failure of a build
        /// </summary>
        foreach (var buildstep in report.steps)
        {
            foreach (var message in buildstep.messages)
            {
                if (message.type == LogType.Error)
                {
                    UnityEngine.Debug.LogError($"!Build Error {message.content}");
                }
                if (message.type == LogType.Exception)
                {
                    UnityEngine.Debug.LogError($"!Build Exception {message.content}");
                }
                if (message.type == LogType.Assert)
                {
                    UnityEngine.Debug.LogError($"!Build Assert {message.content}");
                }
            }
        }
        switch (report.summary.result)
        {
            case BuildResult.Unknown:
            case BuildResult.Failed:              
                UnityEngine.Debug.LogError($"{report.summary.result}");
                break;
            case BuildResult.Cancelled:
                throw new Exception($"Build result is '{report.summary.result}'.");
            case BuildResult.Succeeded:
                if(BuildDevice == BuildDevice.Oculus)
                TerminateAdbProcess();
                UnityEngine.Debug.Log($"!Succeeded kill adb {report.summary.result}");
                break;
        }

    }

    /// <summary>
    /// Kills the adb.exe for Quest since it hangs after the build has succeeded.
    /// </summary>
    private static void TerminateAdbProcess()
    {
        try
        {
            // Execute the taskkill command to terminate "adb.exe" directly
            Process.Start("taskkill", "/IM adb.exe /F");
        }
        catch (System.Exception ex)
        {
            UnityEngine.Debug.LogError("Error terminating adb process: " + ex.Message);
        }
    }
}

public enum BuildDevice { Pico, Vive, Oculus}