// Copyright (c) Wojciech Figat. All rights reserved.

using System;
using System.Collections.Generic;
using System.Xml;
using FlaxEditor.Gizmo;
using FlaxEditor.GUI.ContextMenu;
using FlaxEditor.GUI.Input;
using FlaxEditor.Options;
using FlaxEngine;
using FlaxEngine.GUI;
using FlaxEngine.Json;

namespace FlaxEditor.Windows
{
    /// <summary>
    /// Provides in-editor play mode simulation.
    /// </summary>
    /// <seealso cref="FlaxEditor.Windows.EditorWindow" />
    public class GameWindow : EditorWindow
    {
        private readonly RenderOutputControl _viewport;
        private readonly GameRoot _guiRoot;
        private bool _showGUI = true, _editGUI = true;
        private bool _showDebugDraw = false;
        private bool _audioMuted = false;
        private float _audioVolume = 1;
        private bool _isMaximized = false, _isUnlockingMouse = false;
        private bool _isFloating = false, _isBorderless = false;
        private bool _cursorVisible = true;
        private float _gameStartTime;
        private GUI.Docking.DockState _maximizeRestoreDockState;
        private GUI.Docking.DockPanel _maximizeRestoreDockTo;
        private CursorLockMode _cursorLockMode = CursorLockMode.None;

        // Viewport scaling variables
        private List<ViewportScaleOptions> _defaultViewportScaling = new List<ViewportScaleOptions>();
        private List<ViewportScaleOptions> _customViewportScaling = new List<ViewportScaleOptions>();
        private float _viewportAspectRatio = 1;
        private float _windowAspectRatio = 1;
        private bool _useAspect = false;
        private bool _freeAspect = true;

        private List<PlayModeFocusOptions> _focusOptions = new List<PlayModeFocusOptions>()
        {
            new PlayModeFocusOptions
            {
                Name = "None",
                Tooltip = "Don't change focus.",
                FocusOption = InterfaceOptions.PlayModeFocus.None,
            },
            new PlayModeFocusOptions
            {
                Name = "Game Window",
                Tooltip = "Focus the Game Window.",
                FocusOption = InterfaceOptions.PlayModeFocus.GameWindow,
            },
            new PlayModeFocusOptions
            {
                Name = "Game Window Then Restore",
                Tooltip = "Focus the Game Window. On play mode end restore focus to the previous window.",
                FocusOption = InterfaceOptions.PlayModeFocus.GameWindowThenRestore,
            },
        };

        /// <summary>
        /// Gets the viewport.
        /// </summary>
        public RenderOutputControl Viewport => _viewport;

        /// <summary>
        /// Gets or sets a value indicating whether show game GUI in the view or keep it hidden.
        /// </summary>
        public bool ShowGUI
        {
            get => _showGUI;
            set
            {
                if (value != _showGUI)
                {
                    _showGUI = value;
                    _guiRoot.Visible = value;
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether allow editing game GUI in the view or keep it visible-only.
        /// </summary>
        public bool EditGUI
        {
            get => _editGUI;
            set
            {
                if (value != _editGUI)
                {
                    _editGUI = value;
                    _guiRoot.Editable = value;
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether show Debug Draw shapes in the view or keep it hidden.
        /// </summary>
        public bool ShowDebugDraw
        {
            get => _showDebugDraw;
            set => _showDebugDraw = value;
        }


        /// <summary>
        /// Gets or set a value indicating whether Audio is muted.
        /// </summary>
        public bool AudioMuted
        {
            get => _audioMuted;
            set
            {
                Audio.MasterVolume = value ? 0 : AudioVolume;
                _audioMuted = value;
            }
        }

        /// <summary>
        /// Gets or sets a value that set the audio volume.
        /// </summary>
        public float AudioVolume
        {
            get => _audioVolume;
            set
            {
                if (!AudioMuted)
                    Audio.MasterVolume = value;
                _audioVolume = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the game window is maximized (only in play mode).
        /// </summary>
        private bool IsMaximized
        {
            get => _isMaximized;
            set
            {
                if (_isMaximized == value)
                    return;
                _isMaximized = value;
                if (value)
                {
                    IsFloating = true;
                    var rootWindow = RootWindow;
                    rootWindow.Maximize();
                }
                else
                {
                    IsFloating = false;
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the game window is floating (popup, only in play mode).
        /// </summary>
        private bool IsFloating
        {
            get => _isFloating;
            set
            {
                if (_isFloating == value)
                    return;
                _isFloating = value;
                var rootWindow = RootWindow;
                if (value)
                {
                    _maximizeRestoreDockTo = _dockedTo;
                    _maximizeRestoreDockState = _dockedTo.TryGetDockState(out _);
                    if (_maximizeRestoreDockState != GUI.Docking.DockState.Float)
                    {
                        var monitorBounds = Platform.GetMonitorBounds(PointToScreen(Size * 0.5f));
                        var size = DefaultSize;
                        var location = monitorBounds.Location + monitorBounds.Size * 0.5f - size * 0.5f;
                        ShowFloating(location, size, WindowStartPosition.Manual);
                    }
                }
                else
                {
                    // Restore
                    if (rootWindow != null)
                        rootWindow.Restore();
                    if (_maximizeRestoreDockTo != null && _maximizeRestoreDockTo.IsDisposing)
                        _maximizeRestoreDockTo = null;
                    Show(_maximizeRestoreDockState, _maximizeRestoreDockTo);
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the game window is borderless (only in play mode).
        /// </summary>
        private bool IsBorderless
        {
            get => _isBorderless;
            set
            {
                if (_isBorderless == value)
                    return;
                _isBorderless = value;
                if (value)
                {
                    IsFloating = true;
                    var rootWindow = RootWindow;
                    var monitorBounds = Platform.GetMonitorBounds(rootWindow.RootWindow.Window.ClientPosition);
                    rootWindow.Window.Position = monitorBounds.Location;
                    rootWindow.Window.SetBorderless(true);
                    rootWindow.Window.ClientSize = monitorBounds.Size;
                }
                else
                {
                    IsFloating = false;
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether center mouse position on window focus in play mode. Helps when working with games that lock mouse cursor.
        /// </summary>
        public bool CenterMouseOnFocus { get; set; }

        /// <summary>
        /// Gets or sets a value indicating what panel should be focused when play mode start.
        /// </summary>
        public InterfaceOptions.PlayModeFocus FocusOnPlayOption { get; set; }

        private enum ViewportScaleType
        {
            Resolution = 0,
            Aspect = 1,
        }

        private class ViewportScaleOptions
        {
            /// <summary>
            /// The name.
            /// </summary>
            public string Label;

            /// <summary>
            /// The Type of scaling to do.
            /// </summary>
            public ViewportScaleType ScaleType;

            /// <summary>
            /// The width and height to scale by.
            /// </summary>
            public Int2 Size;

            /// <summary>
            /// If the scaling is active.
            /// </summary>
            public bool Active;
        }

        private class PlayModeFocusOptions
        {
            /// <summary>
            /// The name.
            /// </summary>
            public string Name;

            /// <summary>
            /// The tooltip.
            /// </summary>
            public string Tooltip;

            /// <summary>
            /// The type of focus.
            /// </summary>
            public InterfaceOptions.PlayModeFocus FocusOption;

            /// <summary>
            /// If the option is active.
            /// </summary>
            public bool Active;
        }

        /// <summary>
        /// Root control for game UI preview in Editor. Supports basic UI editing via <see cref="UIEditorRoot"/>.
        /// </summary>
        private class GameRoot : UIEditorRoot
        {
            internal bool Editable = true;
            public override bool EnableInputs => !Time.GamePaused && Editor.IsPlayMode;
            public override bool EnableSelecting => (!Editor.IsPlayMode || Time.GamePaused) && Editable;
            public override TransformGizmo TransformGizmo => Editor.Instance.MainTransformGizmo;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="GameWindow"/> class.
        /// </summary>
        /// <param name="editor">The editor.</param>
        public GameWindow(Editor editor)
        : base(editor, true, ScrollBars.None)
        {
            Title = "Game";
            Icon = editor.Icons.Play64;
            AutoFocus = true;

            var task = MainRenderTask.Instance;

            // Setup viewport
            _viewport = new RenderOutputControl(task)
            {
                AnchorPreset = AnchorPresets.StretchAll,
                Offsets = Margin.Zero,
                AutoFocus = false,
                Parent = this
            };
            task.PostRender += OnPostRender;

            // Override the game GUI root
            _guiRoot = new GameRoot
            {
                Parent = _viewport
            };
            RootControl.GameRoot = _guiRoot.UIRoot;

            SizeChanged += control => { ResizeViewport(); };

            Editor.StateMachine.PlayingState.SceneDuplicating += PlayingStateOnSceneDuplicating;
            Editor.StateMachine.PlayingState.SceneRestored += PlayingStateOnSceneRestored;

            // Link editor options
            Editor.Options.OptionsChanged += OnOptionsChanged;
            OnOptionsChanged(Editor.Options.Options);

            InputActions.Add(options => options.TakeScreenshot, () => Screenshot.Capture(string.Empty));
            InputActions.Add(options => options.DebuggerUnlockMouse, UnlockMouseInPlay);
            InputActions.Add(options => options.ToggleFullscreen, () => { if (Editor.IsPlayMode) IsMaximized = !IsMaximized; });
            InputActions.Add(options => options.Play, Editor.Instance.Simulation.DelegatePlayOrStopPlayInEditor);
            InputActions.Add(options => options.Pause, Editor.Instance.Simulation.RequestResumeOrPause);
            InputActions.Add(options => options.StepFrame, Editor.Instance.Simulation.RequestPlayOneFrame);
#if USE_PROFILER
            InputActions.Add(options => options.ProfilerStartStop, () =>
            {
                bool recording = !Editor.Instance.Windows.ProfilerWin.LiveRecording;
                Editor.Instance.Windows.ProfilerWin.LiveRecording = recording;
                Editor.Instance.UI.AddStatusMessage($"Profiling {(recording ? "started" : "stopped")}.");
            });
            InputActions.Add(options => options.ProfilerClear, () =>
            {
                Editor.Instance.Windows.ProfilerWin.Clear();
                Editor.Instance.UI.AddStatusMessage("Profiling results cleared.");
            });
#endif
            InputActions.Add(options => options.Save, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.SaveAll();
            });
            InputActions.Add(options => options.Undo, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.PerformUndo();
                Focus();
            });
            InputActions.Add(options => options.Redo, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.PerformRedo();
                Focus();
            });
            InputActions.Add(options => options.Cut, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.SceneEditing.Cut();
            });
            InputActions.Add(options => options.Copy, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.SceneEditing.Copy();
            });
            InputActions.Add(options => options.Paste, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.SceneEditing.Paste();
            });
            InputActions.Add(options => options.Duplicate, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.SceneEditing.Duplicate();
            });
            InputActions.Add(options => options.Delete, () =>
            {
                if (Editor.IsPlayMode)
                    return;
                Editor.Instance.SceneEditing.Delete();
            });
            InputActions.Add(options => options.FocusConsoleCommand, () => Editor.Instance.Windows.OutputLogWin.FocusCommand());
        }

        private void ChangeViewportRatio(ViewportScaleOptions v)
        {
            if (v == null)
                return;

            if (v.Size.Y <= 0 || v.Size.X <= 0)
            {
                return;
            }

            if (string.Equals(v.Label, "Free Aspect", StringComparison.Ordinal) && v.Size == new Int2(1, 1))
            {
                _freeAspect = true;
                _useAspect = true;
            }
            else
            {
                switch (v.ScaleType)
                {
                case ViewportScaleType.Aspect:
                    _useAspect = true;
                    _freeAspect = false;
                    break;
                case ViewportScaleType.Resolution:
                    _useAspect = false;
                    _freeAspect = false;
                    break;
                }
            }

            _viewportAspectRatio = (float)v.Size.X / v.Size.Y;

            if (!_freeAspect)
            {
                if (!_useAspect)
                {
                    _viewport.KeepAspectRatio = true;
                    _viewport.CustomResolution = new Int2(v.Size.X, v.Size.Y);
                }
                else
                {
                    _viewport.CustomResolution = new Int2?();
                    _viewport.KeepAspectRatio = true;
                }
            }
            else
            {
                _viewport.CustomResolution = new Int2?();
                _viewport.KeepAspectRatio = false;
            }

            ResizeViewport();
        }

        private void ResizeViewport()
        {
            if (!_freeAspect)
            {
                _windowAspectRatio = Width / Height;
            }
            else
            {
                _windowAspectRatio = 1;
            }

            var scaleWidth = _viewportAspectRatio / _windowAspectRatio;
            var scaleHeight = _windowAspectRatio / _viewportAspectRatio;

            if (scaleHeight < 1)
            {
                _viewport.Bounds = new Rectangle(0, Height * (1 - scaleHeight) / 2, Width, Height * scaleHeight);
            }
            else
            {
                _viewport.Bounds = new Rectangle(Width * (1 - scaleWidth) / 2, 0, Width * scaleWidth, Height);
            }
            _viewport.SyncBackbufferSize();
            PerformLayout();
        }

        private void OnPostRender(GPUContext context, ref RenderContext renderContext)
        {
            // Debug Draw shapes
            if (_showDebugDraw)
            {
                var task = _viewport.Task;

                // Draw actors debug shapes manually if editor viewport is hidden (game viewport task is always rendered before editor viewports)
                var editWindowViewport = Editor.Windows.EditWin.Viewport;
                if (editWindowViewport.Task.LastUsedFrame != Engine.FrameCount)
                {
                    var drawDebugData = editWindowViewport.DebugDrawData;
                    drawDebugData.Clear();
                    var selectedParents = editWindowViewport.TransformGizmo.SelectedParents;
                    if (selectedParents.Count > 0)
                    {
                        for (int i = 0; i < selectedParents.Count; i++)
                        {
                            if (selectedParents[i].IsActiveInHierarchy)
                                selectedParents[i].OnDebugDraw(drawDebugData);
                        }
                    }
                    unsafe
                    {
                        fixed (IntPtr* actors = drawDebugData.ActorsPtrs)
                        {
                            DebugDraw.DrawActors(new IntPtr(actors), drawDebugData.ActorsCount, true);
                        }
                    }
                }

                DebugDraw.Draw(ref renderContext, task.OutputView);
            }
        }

        private void OnOptionsChanged(EditorOptions options)
        {
            CenterMouseOnFocus = options.Interface.CenterMouseOnGameWinFocus;
            FocusOnPlayOption = options.Interface.FocusOnPlayMode;
        }

        private void PlayingStateOnSceneDuplicating()
        {
            // Remove remaining GUI controls so loaded scene can add own GUI
            //_guiRoot.DisposeChildren();

            // Show GUI
            //_guiRoot.Visible = _showGUI;
        }

        private void PlayingStateOnSceneRestored()
        {
            // Remove remaining GUI controls so loaded scene can add own GUI
            //_guiRoot.DisposeChildren();

            // Hide GUI
            //_guiRoot.Visible = false;
        }

        /// <inheritdoc />
        protected override bool CanOpenContentFinder => !Editor.IsPlayMode;

        /// <inheritdoc />
        protected override bool CanUseNavigation => false;

        /// <inheritdoc />
        public override void OnPlayBegin()
        {
            _gameStartTime = Time.UnscaledGameTime;
        }

        /// <inheritdoc />
        public override void OnPlayEnd()
        {
            IsFloating = false;
            IsMaximized = false;
            IsBorderless = false;
            Cursor = CursorType.Default;
            Screen.CursorLock = CursorLockMode.None;
            if (Screen.MainWindow.IsMouseTracking)
                Screen.MainWindow.EndTrackingMouse();
            RootControl.GameRoot.EndMouseCapture();
        }

        /// <inheritdoc />
        public override void OnMouseLeave()
        {
            base.OnMouseLeave();

            // Remove focus from game window when mouse moves out and the cursor is hidden during game
            if (ContainsFocus && Parent != null && Editor.IsPlayMode && !Screen.CursorVisible && Screen.CursorLock == CursorLockMode.None)
            {
                Parent.Focus();
            }
        }

        /// <inheritdoc />
        public override void OnShowContextMenu(ContextMenu menu)
        {
            base.OnShowContextMenu(menu);

            // Focus on play
            {
                var pfMenu = menu.AddChildMenu("Focus On Play Override").ContextMenu;

                GenerateFocusOptionsContextMenu(pfMenu);

                pfMenu.AddSeparator();

                var button = pfMenu.AddButton("Remove override");
                button.TooltipText = "Reset the override to the value set in the editor options.";
                button.Clicked += () => FocusOnPlayOption = Editor.Instance.Options.Options.Interface.FocusOnPlayMode;
            }

            menu.AddSeparator();

            // Viewport Brightness
            {
                var brightness = menu.AddButton("Viewport Brightness");
                brightness.CloseMenuOnClick = false;
                var brightnessValue = new FloatValueBox(_viewport.Brightness, 140, 2, 50.0f, 0.001f, 10.0f, 0.001f)
                {
                    Parent = brightness
                };
                brightnessValue.ValueChanged += () => _viewport.Brightness = brightnessValue.Value;
            }

            // Viewport Resolution
            {
                var resolution = menu.AddButton("Viewport Resolution");
                resolution.CloseMenuOnClick = false;
                var resolutionValue = new FloatValueBox(_viewport.ResolutionScale, 140, 2, 50.0f, 0.1f, 4.0f, 0.001f)
                {
                    Parent = resolution
                };
                resolutionValue.ValueChanged += () => _viewport.ResolutionScale = resolutionValue.Value;
            }

            // Viewport aspect ratio
            {
                // Create default scaling options if they dont exist from deserialization.
                if (_defaultViewportScaling.Count == 0)
                {
                    _defaultViewportScaling.Add(new ViewportScaleOptions
                    {
                        Label = "Free Aspect",
                        ScaleType = ViewportScaleType.Aspect,
                        Size = new Int2(1, 1),
                        Active = true,
                    });
                    _defaultViewportScaling.Add(new ViewportScaleOptions
                    {
                        Label = "16:9 Aspect",
                        ScaleType = ViewportScaleType.Aspect,
                        Size = new Int2(16, 9),
                        Active = false,
                    });
                    _defaultViewportScaling.Add(new ViewportScaleOptions
                    {
                        Label = "16:10 Aspect",
                        ScaleType = ViewportScaleType.Aspect,
                        Size = new Int2(16, 10),
                        Active = false,
                    });
                    _defaultViewportScaling.Add(new ViewportScaleOptions
                    {
                        Label = "1920x1080 Resolution (Full HD)",
                        ScaleType = ViewportScaleType.Resolution,
                        Size = new Int2(1920, 1080),
                        Active = false,
                    });
                    _defaultViewportScaling.Add(new ViewportScaleOptions
                    {
                        Label = "2560x1440 Resolution (2K)",
                        ScaleType = ViewportScaleType.Resolution,
                        Size = new Int2(2560, 1440),
                        Active = false,
                    });
                }

                var vsMenu = menu.AddChildMenu("Viewport Size").ContextMenu;

                CreateViewportSizingContextMenu(vsMenu);
            }

            // Take Screenshot
            {
                var takeScreenshot = menu.AddButton("Take Screenshot");
                takeScreenshot.Clicked += TakeScreenshot;
            }

            menu.AddSeparator();

            // Show GUI
            {
                var button = menu.AddButton("Show GUI");
                button.CloseMenuOnClick = false;
                var checkbox = new CheckBox(140, 2, ShowGUI) { Parent = button };
                checkbox.StateChanged += x => ShowGUI = x.Checked;
            }

            // Edit GUI
            {
                var button = menu.AddButton("Edit GUI");
                var checkbox = new CheckBox(140, 2, EditGUI) { Parent = button };
                checkbox.StateChanged += x => EditGUI = x.Checked;
            }

            // Show Debug Draw
            {
                var button = menu.AddButton("Show Debug Draw");
                button.CloseMenuOnClick = false;
                var checkbox = new CheckBox(140, 2, ShowDebugDraw) { Parent = button };
                checkbox.StateChanged += x => ShowDebugDraw = x.Checked;
            }

            // Clear Debug Draw
            if (DebugDraw.CanClear())
            {
                var button = menu.AddButton("Clear Debug Draw");
                button.CloseMenuOnClick = false;
                button.Clicked += () => DebugDraw.Clear();
            }

            menu.AddSeparator();

            // Mute Audio
            {
                var button = menu.AddButton("Mute Audio");
                button.CloseMenuOnClick = false;
                var checkbox = new CheckBox(140, 2, AudioMuted) { Parent = button };
                checkbox.StateChanged += x => AudioMuted = x.Checked;
            }

            // Audio Volume
            {
                var button = menu.AddButton("Audio Volume");
                button.CloseMenuOnClick = false;
                var slider = new FloatValueBox(AudioVolume, 140, 2, 50, 0, 1) { Parent = button };
                slider.ValueChanged += () => AudioVolume = slider.Value;
            }

            menu.MinimumWidth = 200;
            menu.AddSeparator();
        }

        private void GenerateFocusOptionsContextMenu(ContextMenu pfMenu)
        {
            foreach (PlayModeFocusOptions f in _focusOptions)
            {
                f.Active = f.FocusOption == FocusOnPlayOption;

                var button = pfMenu.AddButton(f.Name);
                button.CloseMenuOnClick = false;
                button.Tag = f;
                button.TooltipText = f.Tooltip;
                button.Icon = f.Active ? Style.Current.CheckBoxTick : SpriteHandle.Invalid;
                button.Clicked += () =>
                {
                    foreach (var child in pfMenu.Items)
                    {
                        if (child is ContextMenuButton cmb && cmb.Tag is PlayModeFocusOptions p)
                        {
                            if (cmb == button)
                            {
                                p.Active = true;
                                button.Icon = Style.Current.CheckBoxTick;
                                FocusOnPlayOption = p.FocusOption;
                            }
                            else if (p.Active)
                            {
                                cmb.Icon = SpriteHandle.Invalid;
                                p.Active = false;
                            }
                        }
                    }
                };
            }
        }

        private void CreateViewportSizingContextMenu(ContextMenu vsMenu)
        {
            // Add default viewport sizing options
            for (int i = 0; i < _defaultViewportScaling.Count; i++)
            {
                var viewportScale = _defaultViewportScaling[i];
                var button = vsMenu.AddButton(viewportScale.Label);
                button.CloseMenuOnClick = false;
                button.Icon = viewportScale.Active ? Style.Current.CheckBoxTick : SpriteHandle.Invalid;
                button.Tag = viewportScale;
                if (viewportScale.Active)
                    ChangeViewportRatio(viewportScale);

                button.Clicked += () =>
                {
                    if (button.Tag == null)
                        return;

                    // Reset selected icon on all buttons
                    foreach (var child in vsMenu.Items)
                    {
                        if (child is ContextMenuButton cmb && cmb.Tag is ViewportScaleOptions v)
                        {
                            if (cmb == button)
                            {
                                v.Active = true;
                                button.Icon = Style.Current.CheckBoxTick;
                                ChangeViewportRatio(v);
                            }
                            else if (v.Active)
                            {
                                cmb.Icon = SpriteHandle.Invalid;
                                v.Active = false;
                            }
                        }
                    }
                };
            }
            if (_defaultViewportScaling.Count != 0)
                vsMenu.AddSeparator();

            // Add custom viewport options
            for (int i = 0; i < _customViewportScaling.Count; i++)
            {
                var viewportScale = _customViewportScaling[i];
                var childCM = vsMenu.AddChildMenu(viewportScale.Label);
                childCM.CloseMenuOnClick = false;
                childCM.Icon = viewportScale.Active ? Style.Current.CheckBoxTick : SpriteHandle.Invalid;
                childCM.Tag = viewportScale;
                if (viewportScale.Active)
                    ChangeViewportRatio(viewportScale);

                var applyButton = childCM.ContextMenu.AddButton("Apply");
                applyButton.Tag = childCM.Tag = viewportScale;
                applyButton.CloseMenuOnClick = false;
                applyButton.Clicked += () =>
                {
                    if (childCM.Tag == null)
                        return;

                    // Reset selected icon on all buttons
                    foreach (var child in vsMenu.Items)
                    {
                        if (child is ContextMenuButton cmb && cmb.Tag is ViewportScaleOptions v)
                        {
                            if (child == childCM)
                            {
                                v.Active = true;
                                childCM.Icon = Style.Current.CheckBoxTick;
                                ChangeViewportRatio(v);
                            }
                            else if (v.Active)
                            {
                                cmb.Icon = SpriteHandle.Invalid;
                                v.Active = false;
                            }
                        }
                    }
                };

                var deleteButton = childCM.ContextMenu.AddButton("Delete");
                deleteButton.CloseMenuOnClick = false;
                deleteButton.Clicked += () =>
                {
                    if (childCM.Tag == null)
                        return;

                    var v = (ViewportScaleOptions)childCM.Tag;
                    if (v.Active)
                    {
                        v.Active = false;
                        _defaultViewportScaling[0].Active = true;
                        ChangeViewportRatio(_defaultViewportScaling[0]);
                    }
                    _customViewportScaling.Remove(v);
                    vsMenu.DisposeAllItems();
                    CreateViewportSizingContextMenu(vsMenu);
                    vsMenu.PerformLayout();
                };
            }
            if (_customViewportScaling.Count != 0)
                vsMenu.AddSeparator();

            // Add button
            var add = vsMenu.AddButton("Add...");
            add.CloseMenuOnClick = false;
            add.Clicked += () =>
            {
                var popup = new ContextMenuBase
                {
                    Size = new Float2(230, 125),
                    ClipChildren = false,
                    CullChildren = false,
                };
                popup.Show(add, new Float2(add.Width, 0));

                var nameLabel = new Label
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    Text = "Name",
                    HorizontalAlignment = TextAlignment.Near,
                };
                nameLabel.LocalX += 10;
                nameLabel.LocalY += 10;

                var nameTextBox = new TextBox
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    IsMultiline = false,
                };
                nameTextBox.LocalX += 100;
                nameTextBox.LocalY += 10;

                var typeLabel = new Label
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    Text = "Type",
                    HorizontalAlignment = TextAlignment.Near,
                };
                typeLabel.LocalX += 10;
                typeLabel.LocalY += 35;

                var typeDropdown = new Dropdown
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    Items = { "Aspect", "Resolution" },
                    SelectedItem = "Aspect",
                    Width = nameTextBox.Width
                };
                typeDropdown.LocalY += 35;
                typeDropdown.LocalX += 100;

                var whLabel = new Label
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    Text = "Width & Height",
                    HorizontalAlignment = TextAlignment.Near,
                };
                whLabel.LocalX += 10;
                whLabel.LocalY += 60;

                var wValue = new IntValueBox(16)
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    MinValue = 1,
                    Width = 55,
                };
                wValue.LocalY += 60;
                wValue.LocalX += 100;

                var hValue = new IntValueBox(9)
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    MinValue = 1,
                    Width = 55,
                };
                hValue.LocalY += 60;
                hValue.LocalX += 165;

                var submitButton = new Button
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    Text = "Submit",
                    Width = 70,
                };
                submitButton.LocalX += 40;
                submitButton.LocalY += 90;

                submitButton.Clicked += () =>
                {
                    Enum.TryParse(typeDropdown.SelectedItem, out ViewportScaleType type);

                    var combineString = type == ViewportScaleType.Aspect ? ":" : "x";
                    var name = nameTextBox.Text + " (" + wValue.Value + combineString + hValue.Value + ") " + typeDropdown.SelectedItem;

                    var newViewportOption = new ViewportScaleOptions
                    {
                        ScaleType = type,
                        Label = name,
                        Size = new Int2(wValue.Value, hValue.Value),
                    };

                    _customViewportScaling.Add(newViewportOption);
                    vsMenu.DisposeAllItems();
                    CreateViewportSizingContextMenu(vsMenu);
                    vsMenu.PerformLayout();
                };

                var cancelButton = new Button
                {
                    Parent = popup,
                    AnchorPreset = AnchorPresets.TopLeft,
                    Text = "Cancel",
                    Width = 70,
                };
                cancelButton.LocalX += 120;
                cancelButton.LocalY += 90;

                cancelButton.Clicked += () =>
                {
                    nameTextBox.Clear();
                    typeDropdown.SelectedItem = "Aspect";
                    hValue.Value = 9;
                    wValue.Value = 16;
                    popup.Hide();
                };
            };
        }

        /// <inheritdoc />
        public override void Draw()
        {
            base.Draw();

            if (Camera.MainCamera == null)
            {
                var style = Style.Current;
                Render2D.DrawText(style.FontLarge, "No camera", new Rectangle(Float2.Zero, Size), style.ForegroundDisabled, TextAlignment.Center, TextAlignment.Center);
            }

            // Play mode hints and overlay
            if (Editor.StateMachine.IsPlayMode)
            {
                var style = Style.Current;
                float time = Time.UnscaledGameTime - _gameStartTime;
                float timeout = 3.0f;
                float fadeOutTime = 1.0f;
                float animTime = time - timeout;
                if (animTime < 0)
                {
                    var alpha = Mathf.Saturate(-animTime / fadeOutTime);
                    var rect = new Rectangle(new Float2(6), Size - 12);
                    var text = $"Press {Editor.Options.Options.Input.DebuggerUnlockMouse} to unlock the mouse";
                    Render2D.DrawText(style.FontSmall, text, rect + new Float2(1.0f), style.Background * alpha, TextAlignment.Near, TextAlignment.Far);
                    Render2D.DrawText(style.FontSmall, text, rect, style.Foreground * alpha, TextAlignment.Near, TextAlignment.Far);
                }

                timeout = 1.0f;
                fadeOutTime = 0.6f;
                animTime = time - timeout;
                if (animTime < 0)
                {
                    float alpha = Mathf.Saturate(-animTime / fadeOutTime);
                    Render2D.DrawRectangle(new Rectangle(new Float2(4), Size - 8), style.SelectionBorder * alpha);
                }

                // Add overlay during debugger breakpoint hang
                if (Editor.Simulation.IsDuringBreakpointHang)
                {
                    var bounds = new Rectangle(Float2.Zero, Size);
                    Render2D.FillRectangle(bounds, new Color(0.0f, 0.0f, 0.0f, 0.2f));
                    Render2D.DrawText(Style.Current.FontLarge, "Debugger breakpoint hit...", bounds, Color.White, TextAlignment.Center, TextAlignment.Center);
                }
            }
        }

        /// <summary>
        /// Unlocks the mouse if game window is focused during play mode.
        /// </summary>
        public void UnlockMouseInPlay()
        {
            if (Editor.StateMachine.IsPlayMode)
            {
                // Cache cursor
                _cursorVisible = Screen.CursorVisible;
                _cursorLockMode = Screen.CursorLock;
                Screen.CursorVisible = true;
                if (Screen.CursorLock == CursorLockMode.Clipped)
                    Screen.CursorLock = CursorLockMode.None;

                // Defocus
                _isUnlockingMouse = true;
                Focus(null);
                _isUnlockingMouse = false;
                Editor.Windows.MainWindow.Focus();
                if (Editor.Windows.PropertiesWin.IsDocked)
                    Editor.Windows.PropertiesWin.Focus();
            }
        }

        /// <summary>
        /// Focuses the game viewport. Shows the window if hidden or unselected.
        /// </summary>
        public void FocusGameViewport()
        {
            if (!IsDocked)
            {
                ShowFloating();
            }
            else if (!IsSelected)
            {
                SelectTab(false);
                RootWindow?.Window?.Focus();
            }
            Focus();
        }

        /// <summary>
        /// Apply the selected window mode to the game window.
        /// </summary>
        /// <param name="mode"></param>
        public void SetWindowMode(InterfaceOptions.GameWindowMode mode)
        {
            switch (mode)
            {
            case InterfaceOptions.GameWindowMode.Docked:
                break;
            case InterfaceOptions.GameWindowMode.PopupWindow:
                IsFloating = true;
                break;
            case InterfaceOptions.GameWindowMode.MaximizedWindow:
                IsMaximized = true;
                break;
            case InterfaceOptions.GameWindowMode.BorderlessWindow:
                IsBorderless = true;
                break;
            default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
            }
        }

        /// <summary>
        /// Takes the screenshot of the current viewport.
        /// </summary>
        public void TakeScreenshot()
        {
            Screenshot.Capture(_viewport.Task);
        }

        /// <summary>
        /// Takes the screenshot of the current viewport.
        /// </summary>
        /// <param name="path">The output file path.</param>
        public void TakeScreenshot(string path)
        {
            Screenshot.Capture(_viewport.Task, path);
        }

        /// <inheritdoc />
        public override bool OnKeyDown(KeyboardKeys key)
        {
            // Prevent closing the game window tab during a play session
            if (Editor.StateMachine.IsPlayMode && Editor.Options.Options.Input.CloseTab.Process(this, key))
            {
                return true;
            }

            return base.OnKeyDown(key);
        }

        /// <inheritdoc />
        public override void OnStartContainsFocus()
        {
            base.OnStartContainsFocus();

            if (Editor.StateMachine.IsPlayMode && !Editor.StateMachine.PlayingState.IsPaused)
            {
                // Center mouse in play mode
                if (CenterMouseOnFocus)
                {
                    var center = PointToWindow(Size * 0.5f);
                    Root.MousePosition = center;
                }

                // Restore cursor
                if (_cursorLockMode != CursorLockMode.None)
                    Screen.CursorLock = _cursorLockMode;
                if (!_cursorVisible)
                    Screen.CursorVisible = false;
            }
        }

        /// <inheritdoc />
        public override void OnEndContainsFocus()
        {
            base.OnEndContainsFocus();

            if (!_isUnlockingMouse)
            {
                // Cache cursor
                _cursorVisible = Screen.CursorVisible;
                _cursorLockMode = Screen.CursorLock;

                // Restore cursor visibility (could be hidden by the game)
                if (!_cursorVisible)
                    Screen.CursorVisible = true;
            }
        }

        /// <inheritdoc />
        public override Control OnNavigate(NavDirection direction, Float2 location, Control caller, List<Control> visited)
        {
            // Block leaking UI navigation focus outside the game window
            if (IsFocused && caller != this)
            {
                // Pick the first UI control if game UI is not focused yet
                foreach (var child in _guiRoot.Children)
                {
                    if (child.Visible)
                        return child.OnNavigate(direction, Float2.Zero, this, visited);
                }
            }
            return null;
        }

        /// <inheritdoc />
        public override bool OnMouseDown(Float2 location, MouseButton button)
        {
            var result = base.OnMouseDown(location, button);

            // Catch user focus
            if (!ContainsFocus)
                Focus();

            return result;
        }

        /// <inheritdoc />
        public override bool UseLayoutData => true;

        /// <inheritdoc />
        public override void OnLayoutSerialize(XmlWriter writer)
        {
            writer.WriteAttributeString("ShowGUI", ShowGUI.ToString());
            writer.WriteAttributeString("EditGUI", EditGUI.ToString());
            writer.WriteAttributeString("ShowDebugDraw", ShowDebugDraw.ToString());
            writer.WriteAttributeString("DefaultViewportScaling", JsonSerializer.Serialize(_defaultViewportScaling));
            writer.WriteAttributeString("CustomViewportScaling", JsonSerializer.Serialize(_customViewportScaling));
        }

        /// <inheritdoc />
        public override void OnLayoutDeserialize(XmlElement node)
        {
            if (bool.TryParse(node.GetAttribute("ShowGUI"), out bool value1))
                ShowGUI = value1;
            if (bool.TryParse(node.GetAttribute("EditGUI"), out value1))
                EditGUI = value1;
            if (bool.TryParse(node.GetAttribute("ShowDebugDraw"), out value1))
                ShowDebugDraw = value1;
            if (node.HasAttribute("CustomViewportScaling"))
                _customViewportScaling = JsonSerializer.Deserialize<List<ViewportScaleOptions>>(node.GetAttribute("CustomViewportScaling"));

            for (int i = 0; i < _customViewportScaling.Count; i++)
            {
                if (_customViewportScaling[i].Active)
                    ChangeViewportRatio(_customViewportScaling[i]);
            }

            if (node.HasAttribute("DefaultViewportScaling"))
                _defaultViewportScaling = JsonSerializer.Deserialize<List<ViewportScaleOptions>>(node.GetAttribute("DefaultViewportScaling"));

            for (int i = 0; i < _defaultViewportScaling.Count; i++)
            {
                if (_defaultViewportScaling[i].Active)
                    ChangeViewportRatio(_defaultViewportScaling[i]);
            }
        }

        /// <inheritdoc />
        public override void OnLayoutDeserialize()
        {
            ShowGUI = true;
            EditGUI = true;
            ShowDebugDraw = false;
        }
    }
}