// 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;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;

namespace WPFMA.Team
{
    /// <summary>
    /// Objects the teammate has selected are read-only here until they select something else, so two people never
    /// edit the same object at once. Whoever selected it first keeps it; on a tie the host keeps it. The lock is a
    /// NotEditable hide flag, which Unity would save into the scene, so it is lifted for every save and reload.
    /// </summary>
    [InitializeOnLoad]
    internal static class TeamLocks
    {
        private const string EnabledKey = "WPFMA.Team.Locks";
        private const string SavedKey = "WPFMA.Team.LockFlags";

        private static readonly Dictionary<int, bool> wasNotEditable = new Dictionary<int, bool>();
        private static readonly HashSet<int> lockedObjects = new HashSet<int>();
        private static readonly Dictionary<int, double> mySelectedAt = new Dictionary<int, double>();
        private static readonly Dictionary<int, double> theirSelectedAt = new Dictionary<int, double>();

        static TeamLocks()
        {
            Selection.selectionChanged += OnMySelection;
            EditorSceneManager.sceneSaving += (scene, path) => UnlockAll();
            EditorSceneManager.sceneSaved += scene => Refresh();
            TeamSession.Suspending += UnlockAll;
            TeamSession.Ended += UnlockAll;
            TeamSession.LinkUp += resumed => Refresh();
            EditorApplication.playModeStateChanged += change =>
            {
                if (change == PlayModeStateChange.ExitingEditMode)
                    UnlockAll();
                else if (change == PlayModeStateChange.EnteredEditMode)
                    Refresh();
            };
            UnityEditor.Editor.finishedDefaultHeaderGUI += DrawBanner;
            RestoreLeftovers();
        }

        internal static bool Enabled
        {
            get { return EditorPrefs.GetBool(EnabledKey, true); }
            set
            {
                EditorPrefs.SetBool(EnabledKey, value);
                Refresh();
            }
        }

        internal static int Count
        {
            get { return lockedObjects.Count; }
        }

        internal static bool IsLocked(GameObject go)
        {
            return go != null && lockedObjects.Contains(go.GetInstanceID());
        }

        internal static void RemoteSelectionChanged()
        {
            var now = TeamSession.Now;
            var current = new HashSet<int>();
            foreach (var go in RemoteSelected())
            {
                current.Add(go.GetInstanceID());
                if (!theirSelectedAt.ContainsKey(go.GetInstanceID()))
                    theirSelectedAt[go.GetInstanceID()] = now;
            }
            foreach (var id in theirSelectedAt.Keys.ToList())
                if (!current.Contains(id))
                    theirSelectedAt.Remove(id);
            Refresh();
        }

        private static void OnMySelection()
        {
            var now = TeamSession.Now;
            var current = new HashSet<int>(Selection.gameObjects.Where(g => g != null).Select(g => g.GetInstanceID()));
            foreach (var id in current)
                if (!mySelectedAt.ContainsKey(id))
                    mySelectedAt[id] = now;
            foreach (var id in mySelectedAt.Keys.ToList())
                if (!current.Contains(id))
                    mySelectedAt.Remove(id);
        }

        private static IEnumerable<GameObject> RemoteSelected()
        {
            if (!TeamSession.IsLinked)
                yield break;

            var ids = TeamSession.RemoteSelectionIds ?? new string[0];
            var paths = TeamSession.RemoteSelection ?? new string[0];
            for (int i = 0; i < Math.Max(ids.Length, paths.Length); i++)
            {
                GameObject go = i < ids.Length ? TeamScene.Find(ids[i]) : null;
                if (go == null && i < paths.Length)
                    go = TeamView.Resolve(paths[i]);
                if (go != null)
                    yield return go;
            }
        }

        /// <summary>Applies the locks that should be in place right now.</summary>
        internal static void Refresh()
        {
            var wanted = new HashSet<int>();
            if (Enabled && TeamSession.IsLinked && !EditorApplication.isPlayingOrWillChangePlaymode)
            {
                foreach (var go in RemoteSelected())
                {
                    int id = go.GetInstanceID();
                    double mine, theirs;
                    if (mySelectedAt.TryGetValue(id, out mine))
                    {
                        theirSelectedAt.TryGetValue(id, out theirs);
                        bool iWasFirst = mine < theirs - 0.25 || (Math.Abs(mine - theirs) <= 0.25 && TeamSession.IsHost);
                        if (iWasFirst)
                            continue;
                    }
                    wanted.Add(id);
                }
            }

            foreach (var id in lockedObjects.ToList())
                if (!wanted.Contains(id))
                    Unlock(id);
            foreach (var id in wanted)
                if (!lockedObjects.Contains(id))
                    Lock(id);

            Save();
            InternalEditorUtility_Repaint();
        }

        internal static void UnlockAll()
        {
            foreach (var id in lockedObjects.ToList())
                Unlock(id);
            Save();
        }

        private static void Lock(int id)
        {
            var go = EditorUtility.InstanceIDToObject(id) as GameObject;
            if (go == null)
                return;
            lockedObjects.Add(id);
            foreach (var target in Targets(go))
            {
                int key = target.GetInstanceID();
                if (!wasNotEditable.ContainsKey(key))
                    wasNotEditable[key] = (target.hideFlags & HideFlags.NotEditable) != 0;
                target.hideFlags |= HideFlags.NotEditable;
            }
        }

        private static void Unlock(int id)
        {
            lockedObjects.Remove(id);
            var go = EditorUtility.InstanceIDToObject(id) as GameObject;
            if (go == null)
                return;
            foreach (var target in Targets(go))
            {
                int key = target.GetInstanceID();
                bool was;
                if (!wasNotEditable.TryGetValue(key, out was))
                    continue;
                wasNotEditable.Remove(key);
                if (!was)
                    target.hideFlags &= ~HideFlags.NotEditable;
            }
        }

        private static IEnumerable<UnityEngine.Object> Targets(GameObject go)
        {
            yield return go;
            foreach (var component in go.GetComponents<Component>())
                if (component != null)
                    yield return component;
        }

        /// <summary>Remembers which flags were added, so a crash or reload never leaves an object stuck read-only.</summary>
        private static void Save()
        {
            var added = wasNotEditable.Where(p => !p.Value).Select(p => p.Key.ToString()).ToArray();
            if (added.Length == 0)
                SessionState.EraseString(SavedKey);
            else
                SessionState.SetString(SavedKey, string.Join(",", added));
        }

        private static void RestoreLeftovers()
        {
            string saved = SessionState.GetString(SavedKey, string.Empty);
            if (string.IsNullOrEmpty(saved))
                return;
            SessionState.EraseString(SavedKey);
            foreach (var part in saved.Split(','))
            {
                int id;
                if (!int.TryParse(part, out id))
                    continue;
                var target = EditorUtility.InstanceIDToObject(id);
                if (target != null)
                    target.hideFlags &= ~HideFlags.NotEditable;
            }
        }

        private static void DrawBanner(UnityEditor.Editor editor)
        {
            if (lockedObjects.Count == 0 || editor == null || editor.target == null)
                return;

            var go = editor.target as GameObject;
            var component = editor.target as Component;
            if (go == null && component != null)
                go = component.gameObject;
            if (go == null || !IsLocked(go))
                return;

            var who = TeamSession.WhoSelected(TeamScene.IdFor(go));
            EditorGUILayout.HelpBox(((who != null ? who.Name : TeamSession.RemoteName) ?? "Your teammate") +
                                    " is editing this, so it is read-only for you until they select something else.", MessageType.Info);
        }

        private static void InternalEditorUtility_Repaint()
        {
            UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
        }
    }
}
#endif
