// WPFMA-SDK needs Unity 2022.3 (VRChat's version); on older Unity this file is skipped and WPFMAUnityVersionNotice explains why.
#if UNITY_2022_3_OR_NEWER
using System.Collections.Generic;
using System.Reflection;
using UnityEditor;
using UnityEngine;

namespace WPFMA
{
    /// <summary>
    /// What each tool starts with. Settings edits these, and changing an option inside a tool saves it here too,
    /// so the tools remember how you like them after Unity restarts.
    /// </summary>
    internal static class WPFMAToolDefaults
    {
        private const string Prefix = "WPFMA.Defaults.";
        private static readonly Dictionary<string, object> Cache = new Dictionary<string, object>();
        private static readonly List<string> Keys = new List<string>();

        private static bool GetBool(string key, bool fallback)
        {
            object value;
            if (!Cache.TryGetValue(key, out value))
            {
                value = EditorPrefs.GetBool(Prefix + key, fallback);
                Remember(key, value);
            }
            return (bool)value;
        }

        private static void SetBool(string key, bool value)
        {
            object old;
            if (Cache.TryGetValue(key, out old) && (bool)old == value)
                return;
            Remember(key, value);
            EditorPrefs.SetBool(Prefix + key, value);
        }

        private static float GetFloat(string key, float fallback, float min, float max)
        {
            object value;
            if (!Cache.TryGetValue(key, out value))
            {
                value = Mathf.Clamp(EditorPrefs.GetFloat(Prefix + key, fallback), min, max);
                Remember(key, value);
            }
            return (float)value;
        }

        private static void SetFloat(string key, float value)
        {
            object old;
            if (Cache.TryGetValue(key, out old) && Mathf.Approximately((float)old, value))
                return;
            Remember(key, value);
            EditorPrefs.SetFloat(Prefix + key, value);
        }

        private static int GetInt(string key, int fallback)
        {
            object value;
            if (!Cache.TryGetValue(key, out value))
            {
                value = EditorPrefs.GetInt(Prefix + key, fallback);
                Remember(key, value);
            }
            return (int)value;
        }

        private static void SetInt(string key, int value)
        {
            object old;
            if (Cache.TryGetValue(key, out old) && (int)old == value)
                return;
            Remember(key, value);
            EditorPrefs.SetInt(Prefix + key, value);
        }

        private static void Remember(string key, object value)
        {
            if (!Cache.ContainsKey(key))
                Keys.Add(key);
            Cache[key] = value;
        }

        /// <summary>Puts every option whose name starts with <paramref name="group"/> back to how it shipped.</summary>
        internal static void Reset(string group)
        {
            // Read every option once so options in collapsed sections are known too.
            foreach (var property in typeof(WPFMAToolDefaults).GetProperties(BindingFlags.Static | BindingFlags.NonPublic))
                property.GetValue(null);

            foreach (string key in Keys.ToArray())
            {
                if (!key.StartsWith(group))
                    continue;
                EditorPrefs.DeleteKey(Prefix + key);
                Cache.Remove(key);
                Keys.Remove(key);
            }
        }

        // Shared by avatars and worlds.
        internal static int TextureMaxSize { get { return GetInt("Textures.MaxSize", 2048); } set { SetInt("Textures.MaxSize", value); } }
        internal static bool TextureCompress { get { return GetBool("Textures.Compress", true); } set { SetBool("Textures.Compress", value); } }
        internal static bool TextureCrunch { get { return GetBool("Textures.Crunch", false); } set { SetBool("Textures.Crunch", value); } }
        internal static int TextureCrunchQuality { get { return GetInt("Textures.CrunchQuality", 60); } set { SetInt("Textures.CrunchQuality", value); } }
        internal static bool TextureStreamingMips { get { return GetBool("Textures.StreamingMips", true); } set { SetBool("Textures.StreamingMips", value); } }
        internal static bool TextureQuest { get { return GetBool("Textures.Quest", true); } set { SetBool("Textures.Quest", value); } }
        internal static int TextureQuestMaxSize { get { return GetInt("Textures.QuestMaxSize", 1024); } set { SetInt("Textures.QuestMaxSize", value); } }
        internal static bool TextureKeepRamps { get { return GetBool("Textures.KeepRamps", true); } set { SetBool("Textures.KeepRamps", value); } }
        internal static bool TextureMipmaps { get { return GetBool("Textures.Mipmaps", false); } set { SetBool("Textures.Mipmaps", value); } }

        internal static void Load(WPFMATextureOptimizer.Settings settings)
        {
            settings.MaxSize = TextureMaxSize;
            settings.Compress = TextureCompress;
            settings.Crunch = TextureCrunch;
            settings.CrunchQuality = TextureCrunchQuality;
            settings.StreamingMips = TextureStreamingMips;
            settings.AndroidOverride = TextureQuest;
            settings.AndroidMaxSize = TextureQuestMaxSize;
            settings.KeepRamps = TextureKeepRamps;
            settings.Mipmaps = TextureMipmaps;
        }

        internal static void Save(WPFMATextureOptimizer.Settings settings)
        {
            TextureMaxSize = settings.MaxSize;
            TextureCompress = settings.Compress;
            TextureCrunch = settings.Crunch;
            TextureCrunchQuality = settings.CrunchQuality;
            TextureStreamingMips = settings.StreamingMips;
            TextureQuest = settings.AndroidOverride;
            TextureQuestMaxSize = settings.AndroidMaxSize;
            TextureKeepRamps = settings.KeepRamps;
            TextureMipmaps = settings.Mipmaps;
        }

        // Avatar tools.
        internal static bool ToggleStartsOn { get { return GetBool("Avatar.Toggle.StartsOn", true); } set { SetBool("Avatar.Toggle.StartsOn", value); } }
        internal static bool ToggleSaved { get { return GetBool("Avatar.Toggle.Saved", true); } set { SetBool("Avatar.Toggle.Saved", value); } }
        internal static bool ToggleSynced { get { return GetBool("Avatar.Toggle.Synced", true); } set { SetBool("Avatar.Toggle.Synced", value); } }
        internal static bool ToggleAddToMenu { get { return GetBool("Avatar.Toggle.AddToMenu", true); } set { SetBool("Avatar.Toggle.AddToMenu", value); } }
        /// <summary>A WPFMAToggleCreator.WriteDefaults value; 0 is Match avatar.</summary>
        internal static int ToggleWriteDefaults { get { return GetInt("Avatar.Toggle.WriteDefaults", 0); } set { SetInt("Avatar.Toggle.WriteDefaults", value); } }
        internal static bool ToggleCombined { get { return GetBool("Avatar.Toggle.Combined", true); } set { SetBool("Avatar.Toggle.Combined", value); } }

#if WPFMA_VRC_AVATARS
        internal static void Load(WPFMAToggleCreator.Request request)
        {
            request.DefaultOn = ToggleStartsOn;
            request.Saved = ToggleSaved;
            request.Synced = ToggleSynced;
            request.AddToMenu = ToggleAddToMenu;
            request.WriteDefaults = (WPFMAToggleCreator.WriteDefaults)ToggleWriteDefaults;
            request.Combined = ToggleCombined;
        }

        internal static void Save(WPFMAToggleCreator.Request request)
        {
            ToggleStartsOn = request.DefaultOn;
            ToggleSaved = request.Saved;
            ToggleSynced = request.Synced;
            ToggleAddToMenu = request.AddToMenu;
            ToggleWriteDefaults = (int)request.WriteDefaults;
            ToggleCombined = request.Combined;
        }
#endif

        internal static bool SetupViewFromEyes { get { return GetBool("Avatar.Setup.ViewFromEyes", true); } set { SetBool("Avatar.Setup.ViewFromEyes", value); } }
        internal static bool SetupLipSync { get { return GetBool("Avatar.Setup.LipSync", true); } set { SetBool("Avatar.Setup.LipSync", value); } }
        internal static bool SetupEyeLook { get { return GetBool("Avatar.Setup.EyeLook", true); } set { SetBool("Avatar.Setup.EyeLook", value); } }

#if WPFMA_VRC_AVATARS
        internal static void Load(WPFMAAvatarSetup.Request request)
        {
            request.ViewFromEyes = SetupViewFromEyes;
            request.LipSync = SetupLipSync;
            request.EyeLook = SetupEyeLook;
        }

        internal static void Save(WPFMAAvatarSetup.Request request)
        {
            SetupViewFromEyes = request.ViewFromEyes;
            SetupLipSync = request.LipSync;
            SetupEyeLook = request.EyeLook;
        }
#endif

        internal static bool CopierOverwrite { get { return GetBool("Avatar.Copier.Overwrite", true); } set { SetBool("Avatar.Copier.Overwrite", value); } }
        internal static bool CopierCreateMissing { get { return GetBool("Avatar.Copier.CreateMissing", true); } set { SetBool("Avatar.Copier.CreateMissing", value); } }
        internal static bool ShaderSwapCopies { get { return GetBool("Avatar.ShaderSwap.Copies", true); } set { SetBool("Avatar.ShaderSwap.Copies", value); } }
        internal static bool PhysBonesUpdateExisting { get { return GetBool("Avatar.PhysBones.UpdateExisting", true); } set { SetBool("Avatar.PhysBones.UpdateExisting", value); } }
        internal static bool BlendshapeRemoveZero { get { return GetBool("Avatar.Blendshapes.RemoveZero", false); } set { SetBool("Avatar.Blendshapes.RemoveZero", value); } }
        internal static bool PerformanceOnlyProblems { get { return GetBool("Avatar.Performance.OnlyProblems", true); } set { SetBool("Avatar.Performance.OnlyProblems", value); } }
        internal static bool ParametersOnlyProblems { get { return GetBool("Avatar.Parameters.OnlyProblems", false); } set { SetBool("Avatar.Parameters.OnlyProblems", value); } }
        /// <summary>What every mesh's lighting follows: 0 chest, 1 hips, 2 head.</summary>
        internal static int BoundsAnchor { get { return GetInt("Avatar.Bounds.Anchor", 0); } set { SetInt("Avatar.Bounds.Anchor", value); } }
        internal static bool BoundsFixBounds { get { return GetBool("Avatar.Bounds.FixBounds", true); } set { SetBool("Avatar.Bounds.FixBounds", value); } }

        // World tools.
        internal static bool WorldPlacementOverlay { get { return GetBool("World.Placement.Overlay", true); } set { SetBool("World.Placement.Overlay", value); } }
        internal static bool WorldPostProcessing { get { return GetBool("World.Setup.PostProcessing", true); } set { SetBool("World.Setup.PostProcessing", value); } }
        internal static float WorldProbeSpacing { get { return GetFloat("World.Lighting.ProbeSpacing", 2f, 0.5f, 10f); } set { SetFloat("World.Lighting.ProbeSpacing", value); } }
        internal static bool WorldVolumePerObject { get { return GetBool("World.LightVolumes.PerObject", true); } set { SetBool("World.LightVolumes.PerObject", value); } }
        internal static int WorldAtlasSize { get { return GetInt("World.Atlas.Size", 2048); } set { SetInt("World.Atlas.Size", value); } }
        internal static float WorldSmallestOccluder { get { return GetFloat("World.Occlusion.Occluder", 2f, 0.5f, 10f); } set { SetFloat("World.Occlusion.Occluder", value); } }
        internal static float WorldSmallestHole { get { return GetFloat("World.Occlusion.Hole", 0.25f, 0.05f, 2f); } set { SetFloat("World.Occlusion.Hole", value); } }
        internal static float WorldCullBelowSize { get { return GetFloat("World.DrawDistance.Size", 1f, 0.1f, 5f); } set { SetFloat("World.DrawDistance.Size", value); } }
        internal static float WorldCullPercent { get { return GetFloat("World.DrawDistance.Percent", 2f, 0.2f, 10f); } set { SetFloat("World.DrawDistance.Percent", value); } }
        internal static bool WorldToggleSynced { get { return GetBool("World.Toggle.Synced", false); } set { SetBool("World.Toggle.Synced", value); } }
        internal static bool WorldToggleStartsOff { get { return GetBool("World.Toggle.StartsOff", true); } set { SetBool("World.Toggle.StartsOff", value); } }
        internal static float WorldAudioFade { get { return GetFloat("World.Audio.Fade", 1.5f, 0.1f, 6f); } set { SetFloat("World.Audio.Fade", value); } }
        internal static bool WorldPickupSynced { get { return GetBool("World.Pickup.Synced", true); } set { SetBool("World.Pickup.Synced", value); } }
        internal static bool WorldPickupGravity { get { return GetBool("World.Pickup.Gravity", true); } set { SetBool("World.Pickup.Gravity", value); } }
        internal static bool WorldPickupStaysPut { get { return GetBool("World.Pickup.StaysPut", false); } set { SetBool("World.Pickup.StaysPut", value); } }
        internal static bool WorldTeleportWalkIn { get { return GetBool("World.Teleport.WalkIn", true); } set { SetBool("World.Teleport.WalkIn", value); } }
        internal static bool WorldTeleportTwoWay { get { return GetBool("World.Teleport.TwoWay", false); } set { SetBool("World.Teleport.TwoWay", value); } }
        internal static float WorldSeatHeight { get { return GetFloat("World.Seat.Height", 0.45f, 0.1f, 1.2f); } set { SetFloat("World.Seat.Height", value); } }
        internal static bool WorldVideoStreams { get { return GetBool("World.Video.Streams", false); } set { SetBool("World.Video.Streams", value); } }
        internal static float WorldVideoWidth { get { return GetFloat("World.Video.Width", 4f, 1f, 30f); } set { SetFloat("World.Video.Width", value); } }
        internal static float WorldVideoRange { get { return GetFloat("World.Video.Range", 25f, 5f, 200f); } set { SetFloat("World.Video.Range", value); } }
    }
}
#endif
