using System;
using System.IO;
using System.Linq;
#if COMPILE_WITH_FSR1
using FidelityFX;
#endif
#if COMPILE_WITH_DLSS
using NVIDIA;
#endif
using FlaxEngine;
using FlaxEngine.Networking;

namespace Game;

public enum UpscalingMode
{
    None,
    FSR2,
    DLSS,
    FSR1,
}

// Holds Console variables and commands to control engine behaviour
public static class EngineConsoleCommands
{
    [ConsoleSubsystemInitializer]
    public static void Initialize()
    {
    }

#if COMPILE_WITH_FSR1
    private static FSR _fsrPlugin;
    public static FSR FsrPlugin
    {
        get
        {
            if (_fsrPlugin == null)
                _fsrPlugin = PluginManager.GetPlugin<FSR>();
            return _fsrPlugin;
        }
    }
#endif

#if COMPILE_WITH_DLSS
    private static DLSS _dlssPlugin;
    public static DLSS DlssPlugin
    {
        get
        {
            if (_dlssPlugin == null)
                _dlssPlugin = PluginManager.GetPlugin<DLSS>();
            return _dlssPlugin;
        }
    }
#endif

    // TODO: this should manually set all postprocessing values to 0 or disabled
    /*[ConsoleVariable("r_postprocessing")]
    public static string PostProcessing
    {
        get
        {
            PostFxVolume postFx = Level.FindActor<PostFxVolume>();
            if (postFx != null)
                return postFx.CameraArtifacts.OverrideFlags.ToString();
            return "";
        }
        set
        {
            bool valueBoolean = false;
            if (int.TryParse(value, out int valueInt))
                valueBoolean = valueInt != 0;
            else
                return;

            PostFxVolume postFx = Level.FindActor<PostFxVolume>();
            if (postFx != null)
            {
                var cameraArtifacts = postFx.CameraArtifacts;
                cameraArtifacts.OverrideFlags = valueBoolean ? CameraArtifactsSettingsOverride.None : CameraArtifactsSettingsOverride.All;
                postFx.CameraArtifacts = cameraArtifacts;
            }
        }
    }*/

    [ConsoleVariable("r_vignette")]
    public static string Vignette
    {
        get
        {
            return Graphics.PostProcessSettings.CameraArtifacts.VignetteIntensity.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.0f, 2.0f);

                PostProcessSettings postProcessSettings = Graphics.PostProcessSettings;
                CameraArtifactsSettings cameraArtifacts = postProcessSettings.CameraArtifacts;
                cameraArtifacts.VignetteIntensity = valueFloat;
                postProcessSettings.CameraArtifacts = cameraArtifacts;
                Graphics.PostProcessSettings = postProcessSettings;
            }
        }
    }

    [ConsoleVariable("cl_maxfps")]
    public static string MaxFps
    {
        get => Time.UpdateFPS.ToString();
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                if (valueFloat <= 0.0f)
                    valueFloat = 0.0f;
                else
                    valueFloat = Mathf.Clamp(valueFloat, 10f, 99999999999.0f);

                if (Time.UpdateFPS != valueFloat)
                    Time.UpdateFPS = valueFloat;
                if (Time.DrawFPS != valueFloat)
                    Time.DrawFPS = valueFloat;
            }
        }
    }

    [ConsoleVariable("r_renderscale")]
    public static string RenderScale
    {
        get => MainRenderTask.Instance.RenderingPercentage.ToString();
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.00001f, 4.0f);
                MainRenderTask.Instance.RenderingPercentage = valueFloat;
            }
        }
    }

    private static UpscalingMode GetUpscalingMode()
    {
        return (UpscalingMode)int.Parse(Upscaling);
    }

    [ConsoleVariable("r_upscaling")]
    public static string Upscaling
    {
        get
        {
#if COMPILE_WITH_DLSS
            if (DlssPlugin.PostFx?.Enabled ?? false)
                return ((int)UpscalingMode.DLSS).ToString();
#endif
#if COMPILE_WITH_FSR1
            if (FsrPlugin.PostFx?.Enabled ?? false)
                return ((int)UpscalingMode.FSR1).ToString();
#endif
            return ((int)UpscalingMode.None).ToString();
        }
        set
        {
            if (int.TryParse(value, out int intValue))
            {
                UpscalingMode upscaling = (UpscalingMode)intValue;

#if COMPILE_WITH_DLSS
                if (DlssPlugin.PostFx != null)
                {
                    if (upscaling == UpscalingMode.DLSS)
                    {
                        if (DlssPlugin.Support == DLSSSupport.Supported)
                            DlssPlugin.PostFx.Enabled = true;
                        else
                        {
                            DlssPlugin.PostFx.Enabled = false;
                            Console.Print("DLSS not supported");
                        }
                    }
                    else
                        DlssPlugin.PostFx.Enabled = false;
                }
#else
                if (upscaling == UpscalingMode.DLSS)
                {
                    Console.Print("DLSS not supported: compiled without COMPILE_WITH_DLSS");
                    upscaling = UpscalingMode.None;
                }
#endif
#if COMPILE_WITH_FSR1
                if (FsrPlugin.PostFx != null)
                    FsrPlugin.PostFx.Enabled = upscaling == UpscalingMode.FSR1;
#else
                if (upscaling == UpscalingMode.FSR1)
                {
                    Console.Print("FSR1 not supported: compiled without COMPILE_WITH_FSR1");
                    upscaling = UpscalingMode.None;
                }
#endif
            }
        }
    }

#if !COMPILE_WITH_DLSS
    private static float dummy_DlssSharpness;
    private static int dummy_DlssQuality;
#endif

    [ConsoleVariable("r_dlss_sharpness")]
    public static string DlssSharpness
    {
        get
        {
#if COMPILE_WITH_DLSS
            return DlssPlugin.Sharpness.ToString();
#else
            return dummy_DlssSharpness.ToString();
#endif
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, -1f, 1f);
#if COMPILE_WITH_DLSS
                DlssPlugin.Sharpness = valueFloat;
#else
                dummy_DlssSharpness = valueFloat;
#endif
            }
        }
    }

    [ConsoleVariable("r_dlss_quality")]
    public static string DlssQuality
    {
        get
        {
#if COMPILE_WITH_DLSS
            return ((int)DlssPlugin.Quality).ToString();
#else
            return dummy_DlssQuality.ToString();
#endif
        }
        set
        {
            if (int.TryParse(value, out int intValue))
            {
#if COMPILE_WITH_DLSS
#if USE_NETCORE
                intValue = Math.Clamp(intValue, 0, (int)DLSSQuality.MAX-1);
#else
                intValue = (intValue > (int)DLSSQuality.MAX-1) ? ((int)DLSSQuality.MAX-1) : (intValue < 0 ? 0 : intValue);
#endif
                DlssPlugin.Quality = (DLSSQuality)intValue;
#else
                //intValue = Math.Clamp(intValue, 0, 4);
                intValue = (intValue > 4) ? 4 : (intValue < 0 ? 0 : intValue);
                dummy_DlssQuality = intValue;
#endif
            }
        }
    }

#if !COMPILE_WITH_FSR1
    private static float dummy_Fsr1Sharpness;
#endif

    [ConsoleVariable("r_fsr_sharpness")]
    public static string FsrSharpness
    {
        get
        {
            // In shader, the value of 0 is the max sharpness...
#if COMPILE_WITH_FSR1
            float sharpness = 2.0f - FsrPlugin.PostFx.Sharpness;
#else
            float sharpness = 2.0f - dummy_Fsr1Sharpness;
#endif
            return sharpness.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0f, 2.0f);
#if COMPILE_WITH_FSR1
                FsrPlugin.PostFx.Sharpness = 2.0f - valueFloat;
#else
                dummy_Fsr1Sharpness = 2.0f - valueFloat;
#endif
            }
        }
    }

    [ConsoleVariable("cl_showweapon")]
    public static string ShowWeapon
    {
        get => Level.FindActor("ViewModelCamera").IsActive ? "1" : "0";
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            Level.FindActor("ViewModelCamera").IsActive = boolValue;
        }
    }


    // Horizontal field of view of the Camera
    [ConsoleVariable("fov")]
    public static string CameraFov
    {
        get
        {
            float valueFloat = Level.FindActor("PlayerCamera").As<Camera>().FieldOfView;
            float horizontalFov = (float)(180.0f / Math.PI *
                                          (2 * Math.Atan(4f / 3f *
                                                         Math.Tan(Math.PI / 180.0f * valueFloat / 2.0f))));
            return horizontalFov.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.01f, 360.0f);

                float verticalFov = (float)(180.0f / Math.PI *
                                            (2 * Math.Atan(3f / 4f *
                                                           Math.Tan(Math.PI / 180.0f * valueFloat / 2.0f))));
                Level.FindActor("PlayerCamera").As<Camera>().FieldOfView = verticalFov;
            }
        }
    }

    [ConsoleVariable("r_lighting")]
    public static string SceneLighting
    {
        get
        {
            return ((bool)AssetManager.Globals.GetValue("Scene Lighting") ? "1" : "0");
        }
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            AssetManager.Globals.SetValue("Scene Lighting", boolValue);

            AmbientOcclusion = AmbientOcclusion;
            GlobalIllumination = GlobalIllumination;
            //GlobalIllumination = value;
        }
    }

    private static bool _AmbientOcclusion;
    [ConsoleVariable("r_ambientocclusion")]
    public static string AmbientOcclusion
    {
        get
        {
            return _AmbientOcclusion ? "1" : "0";//Graphics.PostProcessSettings.AmbientOcclusion.Enabled ? "1" : "0";
        }
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            _AmbientOcclusion = boolValue;

            PostProcessSettings postProcessSettings = Graphics.PostProcessSettings;
            AmbientOcclusionSettings aoSettings = postProcessSettings.AmbientOcclusion;
            /*aoSettings.OverrideFlags = (aoSettings.OverrideFlags & ~AmbientOcclusionSettingsOverride.Enabled) |
                                        (boolValue
                                            ? AmbientOcclusionSettingsOverride.Enabled
                                            : 0 & AmbientOcclusionSettingsOverride.Enabled);*/


            aoSettings.Enabled = boolValue && SceneLighting == "1";
            postProcessSettings.AmbientOcclusion = aoSettings;

            Graphics.PostProcessSettings = postProcessSettings;
        }
    }

    [ConsoleVariable("r_vsync")]
    public static string Vsync
    {
        get
        {
            return Graphics.UseVSync ? "1" : "0";
        }
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            Graphics.UseVSync = boolValue;
        }
    }

    private static bool _GlobalIllumination;

    [ConsoleVariable("r_gi")]
    public static string GlobalIllumination
    {
        get
        {
            return _GlobalIllumination ? "1" : "0";//Graphics.PostProcessSettings.GlobalIllumination.Mode == GlobalIlluminationMode.DDGI ? "1" : "0";
        }
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            _GlobalIllumination = boolValue;

            PostProcessSettings postProcessSettings = Graphics.PostProcessSettings;

            GlobalIlluminationSettings giSettings = postProcessSettings.GlobalIllumination;
            giSettings.Mode = (boolValue && SceneLighting == "1") ? GlobalIlluminationMode.DDGI : GlobalIlluminationMode.None;
            postProcessSettings.GlobalIllumination = giSettings;

            Graphics.PostProcessSettings = postProcessSettings;

            //Graphics.EnableGlobalSDF = boolValue;
        }
    }

    [ConsoleVariable("r_gi_bounce")]
    public static string GlobalIlluminationBounce
    {
        get
        {
            return Graphics.PostProcessSettings.GlobalIllumination.BounceIntensity.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.0f, 999.0f);

                PostProcessSettings postProcessSettings = Graphics.PostProcessSettings;

                GlobalIlluminationSettings giSettings = postProcessSettings.GlobalIllumination;
                giSettings.BounceIntensity = valueFloat;
                postProcessSettings.GlobalIllumination = giSettings;

                Graphics.PostProcessSettings = postProcessSettings;
            }
        }
    }

    /*[ConsoleVariable("r_gi_spacing")]
    public static string GlobalIlluminationProbeSpacing
    {
        get
        {
            return Graphics.GIProbesSpacing.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.0f, 999.0f);

                Graphics.GIProbesSpacing = valueFloat;
            }
        }
    }*/

    [ConsoleVariable("r_gi_time")]
    public static string GlobalIlluminationTime
    {
        get
        {
            return Graphics.PostProcessSettings.GlobalIllumination.TemporalResponse.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.0f, 10.0f);

                PostProcessSettings postProcessSettings = Graphics.PostProcessSettings;

                GlobalIlluminationSettings giSettings = postProcessSettings.GlobalIllumination;
                giSettings.TemporalResponse = valueFloat;
                postProcessSettings.GlobalIllumination = giSettings;

                Graphics.PostProcessSettings = postProcessSettings;
            }
        }
    }

    [ConsoleVariable("r_gi_distance")]
    public static string GlobalIlluminationDistance
    {
        get
        {
            return Graphics.PostProcessSettings.GlobalIllumination.Distance.ToString();
        }
        set
        {
            if (float.TryParse(value, out float valueFloat))
            {
                valueFloat = Mathf.Clamp(valueFloat, 0.0f, 10000000.0f);

                PostProcessSettings postProcessSettings = Graphics.PostProcessSettings;

                GlobalIlluminationSettings giSettings = postProcessSettings.GlobalIllumination;
                giSettings.Distance = valueFloat;
                postProcessSettings.GlobalIllumination = giSettings;

                Graphics.PostProcessSettings = postProcessSettings;
            }
        }
    }

    [ConsoleVariable("r_shadows")]
    public static string SceneShadows
    {
        get
        {
            return (bool)AssetManager.Globals.GetValue("Scene Shadows") ? "1" : "0";
        }
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            AssetManager.Globals.SetValue("Scene Shadows", boolValue);
        }
    }

    [ConsoleVariable("r_staticbatch")]
    public static string StaticBatch
    {
        get
        {
            return (bool)AssetManager.Globals.GetValue("Static Batching") ? "1" : "0";
        }
        set
        {
            bool boolValue = false;
            if (int.TryParse(value, out int intValue))
                boolValue = intValue != 0;
            else if (float.TryParse(value, out float valueFloat))
                boolValue = valueFloat != 0f;

            AssetManager.Globals.SetValue("Static Batching", boolValue);
        }
    }

    [ConsoleCommand("quit", "exit")]
    public static void ExitCommand()
    {
        Engine.RequestExit();
    }

    [ConsoleCommand("debuglog")]
    public static void DebugLogCommand(string[] text)
    {
        Debug.Log(string.Join(" ", text));
    }
}