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

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml;
using FlaxEditor.GUI;
using FlaxEditor.GUI.ContextMenu;
using FlaxEditor.Options;
using FlaxEngine;
using FlaxEngine.Assertions;
using FlaxEngine.GUI;
using Object = FlaxEngine.Object;

namespace FlaxEditor.Windows
{
    /// <summary>
    /// Editor window used to show debug info, warning and error messages. Captures <see cref="Debug"/> messages.
    /// </summary>
    /// <seealso cref="FlaxEditor.Windows.EditorWindow" />
    public class DebugLogWindow : EditorWindow
    {
        /// <summary>
        /// Debug log entry description;
        /// </summary>
        public struct LogEntryDescription
        {
            /// <summary>
            /// The log level.
            /// </summary>
            public LogType Level;

            /// <summary>
            /// The message title.
            /// </summary>
            public string Title;

            /// <summary>
            /// The message description.
            /// </summary>
            public string Description;

            /// <summary>
            /// The target object hint id (don't store ref, object may be an actor that can be removed and restored later or sth).
            /// </summary>
            public Guid ContextObject;

            /// <summary>
            /// The location of the issue (file path).
            /// </summary>
            public string LocationFile;

            /// <summary>
            /// The location line number (zero or less to not use it);
            /// </summary>
            public int LocationLine;
        };

        private enum LogGroup
        {
            Error = 0,
            Warning,
            Info,
            Max
        };

        private class LogEntry : Control
        {
            private bool _isRightMouseDown;

            /// <summary>
            /// The default height of the entries.
            /// </summary>
            public const float DefaultHeight = 32.0f;

            private DebugLogWindow _window;
            public LogGroup Group;
            public LogEntryDescription Desc;
            public SpriteHandle Icon;
            public int LogCount = 1;

            public LogEntry(DebugLogWindow window, ref LogEntryDescription desc)
            : base(0, 0, 120, DefaultHeight)
            {
                AnchorPreset = AnchorPresets.HorizontalStretchTop;
                IsScrollable = true;
                AutoFocus = true;

                _window = window;
                Desc = desc;
                switch (desc.Level)
                {
                case LogType.Warning:
                    Group = LogGroup.Warning;
                    Icon = _window._iconWarning;
                    break;
                case LogType.Info:
                    Group = LogGroup.Info;
                    Icon = _window._iconInfo;
                    break;
                default:
                    Group = LogGroup.Error;
                    Icon = _window._iconError;
                    break;
                }
            }

            /// <summary>
            /// Gets the information text.
            /// </summary>
            public string Info => Desc.Title + '\n' + Desc.Description;

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

                // Cache data
                var style = Style.Current;
                var index = IndexInParent;
                var clientRect = new Rectangle(Float2.Zero, Size);

                // Background
                if (_window._selected == this)
                {
                    Render2D.FillRectangle(clientRect, style.LightBackground);
                    // Small rectangle to signal that entry is selected
                    Rectangle selectionHighlightRect = clientRect with { Width = 5 };
                    Render2D.FillRectangle(selectionHighlightRect, style.BackgroundSelected);
                }
                else if (IsMouseOver)
                    Render2D.FillRectangle(clientRect, style.BackgroundHighlighted);
                else if (index % 2 == 0)
                    Render2D.FillRectangle(clientRect, style.Background * 0.9f);

                var color = Group == LogGroup.Error ? _window._colorError : (Group == LogGroup.Warning ? _window._colorWarning : _window._colorInfo);

                // Icon
                Render2D.DrawSprite(Icon, new Rectangle(8, 0, 32, 32), color);

                // Title
                var textRect = new Rectangle(43, 2, clientRect.Width - 40, clientRect.Height - 10);
                Render2D.PushClip(ref clientRect);
                bool coloredText = _window._colorDebugLogText;
                if (LogCount == 1)
                {
                    Render2D.DrawText(style.FontMedium, Desc.Title, textRect, coloredText ? color : style.Foreground);
                }
                else if (LogCount > 1)
                {
                    Render2D.DrawText(style.FontMedium, $"{Desc.Title} ({LogCount})", textRect, coloredText ? color : style.Foreground);
                }
                Render2D.PopClip();
            }

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

                _window.Selected = this;
            }

            /// <inheritdoc />
            protected override void OnVisibleChanged()
            {
                // Deselect on hide
                if (!Visible && _window.Selected == this)
                    _window.Selected = null;

                base.OnVisibleChanged();
            }

            /// <inheritdoc />
            public override bool OnKeyDown(KeyboardKeys key)
            {
                InputOptions options = FlaxEditor.Editor.Instance.Options.Options.Input;

                // Up
                if (key == KeyboardKeys.ArrowUp)
                {
                    int index = IndexInParent - 1;
                    if (index >= 0)
                    {
                        var target = Parent.GetChild(index);
                        target.Focus();
                        ((Panel)Parent.Parent).ScrollViewTo(target);
                        return true;
                    }
                }
                // Down
                else if (key == KeyboardKeys.ArrowDown)
                {
                    int index = IndexInParent + 1;
                    if (index < Parent.ChildrenCount)
                    {
                        var target = Parent.GetChild(index);
                        target.Focus();
                        ((Panel)Parent.Parent).ScrollViewTo(target);
                        return true;
                    }
                }
                // Enter
                else if (key == KeyboardKeys.Return)
                {
                    Open();
                }
                // Ctrl+C
                else if (options.Copy.Process(this))
                {
                    Copy();
                    return true;
                }

                return base.OnKeyDown(key);
            }

            /// <summary>
            /// Opens the entry location.
            /// </summary>
            public void Open()
            {
                if (!string.IsNullOrEmpty(Desc.LocationFile) && File.Exists(Desc.LocationFile))
                {
                    Editor.Instance.CodeEditing.OpenFile(Desc.LocationFile, Desc.LocationLine);
                }
            }

            /// <summary>
            /// Copies the entry information to the system clipboard (as text).
            /// </summary>
            public void Copy()
            {
                Clipboard.Text = Info.Replace("\r\n", "\n").Replace("\n", Environment.NewLine);
            }

            public override bool OnMouseDoubleClick(Float2 location, MouseButton button)
            {
                Open();
                return true;
            }

            /// <inheritdoc />
            public override bool OnMouseDown(Float2 location, MouseButton button)
            {
                if (base.OnMouseDown(location, button))
                    return true;

                if (button == MouseButton.Left)
                {
                    Focus();
                    return true;
                }
                if (button == MouseButton.Right)
                {
                    Focus();

                    _isRightMouseDown = true;
                    return true;
                }

                return false;
            }

            /// <inheritdoc />
            public override bool OnMouseUp(Float2 location, MouseButton button)
            {
                if (base.OnMouseUp(location, button))
                    return true;

                if (_isRightMouseDown && button == MouseButton.Right)
                {
                    Focus();

                    var menu = new ContextMenu();
                    menu.AddButton("Copy", Copy);
                    menu.AddButton("Open", Open).Enabled = !string.IsNullOrEmpty(Desc.LocationFile) && File.Exists(Desc.LocationFile);
                    menu.Show(this, location);
                }

                return false;
            }

            /// <inheritdoc />
            public override void OnMouseLeave()
            {
                _isRightMouseDown = false;

                base.OnMouseLeave();
            }
        }

        private readonly SplitPanel _split;
        private readonly Label _logInfo;
        private readonly VerticalPanel _entriesPanel;
        private LogEntry _selected;
        private readonly int[] _logCountPerGroup = new int[(int)LogGroup.Max];
        private readonly Regex _logRegex = new Regex("at (.*) in (.*):(line (\\d*)|(\\d*))");
        private readonly ThreadLocal<StringBuilder> _stringBuilder = new ThreadLocal<StringBuilder>(() => new StringBuilder(), false);
        private InterfaceOptions.TimestampsFormats _timestampsFormats;

        private readonly object _locker = new object();
        private readonly List<LogEntry> _pendingEntries = new List<LogEntry>(32);

        private readonly ToolStripButton _clearOnPlayButton;
        private readonly ToolStripButton _collapseLogsButton;
        private readonly ToolStripButton _pauseOnErrorButton;
        private readonly ToolStripButton[] _groupButtons = new ToolStripButton[3];

        private LogType _iconType = LogType.Info;
        private SpriteHandle _iconInfo;
        private SpriteHandle _iconWarning;
        private SpriteHandle _iconError;
        private Color _colorInfo;
        private Color _colorWarning;
        private Color _colorError;
        private bool _colorDebugLogText;

        /// <summary>
        /// Initializes a new instance of the <see cref="DebugLogWindow"/> class.
        /// </summary>
        /// <param name="editor">The editor.</param>
        public DebugLogWindow(Editor editor)
        : base(editor, true, ScrollBars.None)
        {
            Title = "Debug Log";
            Icon = _iconInfo;
            FlaxEditor.Utilities.Utils.SetupCommonInputActions(this);

            // Toolstrip
            var toolstrip = new ToolStrip(22.0f)
            {
                Parent = this,
            };
            toolstrip.AddButton("Clear", Clear).LinkTooltip("Clears all log entries.");
            _clearOnPlayButton = (ToolStripButton)toolstrip.AddButton("Clear on Play", () =>
            {
                editor.Options.Options.Interface.DebugLogClearOnPlay = _clearOnPlayButton.Checked;
                editor.Options.Apply(editor.Options.Options);
            }).SetAutoCheck(true).LinkTooltip("Clears all log entries on enter playmode.");
            _collapseLogsButton = (ToolStripButton)toolstrip.AddButton("Collapse", () =>
            {
                editor.Options.Options.Interface.DebugLogCollapse = _collapseLogsButton.Checked;
                editor.Options.Apply(editor.Options.Options);
            }).SetAutoCheck(true).LinkTooltip("Collapses similar logs.");
            _pauseOnErrorButton = (ToolStripButton)toolstrip.AddButton("Pause on Error", () =>
            {
                editor.Options.Options.Interface.DebugLogPauseOnError = _pauseOnErrorButton.Checked;
                editor.Options.Apply(editor.Options.Options);
            }).SetAutoCheck(true).LinkTooltip("Performs auto pause on error.");
            toolstrip.AddSeparator();
            _groupButtons[0] = (ToolStripButton)toolstrip.AddButton(editor.Icons.Error32, () => { OnGroupButtonPressed(0); })
                                                         .SetAutoCheck(true).LinkTooltip("Shows/hides error messages.");
            _groupButtons[1] = (ToolStripButton)toolstrip.AddButton(editor.Icons.Warning32, () => { OnGroupButtonPressed(1); })
                                                         .SetAutoCheck(true).LinkTooltip("Shows/hides warning messages.");
            _groupButtons[2] = (ToolStripButton)toolstrip.AddButton(editor.Icons.Info32, () => { OnGroupButtonPressed(2); })
                                                         .SetAutoCheck(true).LinkTooltip("Shows/hides info messages.");
            UpdateCount();

            // Split panel
            _split = new SplitPanel(Orientation.Vertical, ScrollBars.Vertical, ScrollBars.Both)
            {
                AnchorPreset = AnchorPresets.StretchAll,
                Offsets = new Margin(0, 0, toolstrip.Bottom, 0),
                SplitterValue = 0.8f,
                Parent = this
            };

            // Info detail info
            _logInfo = new Label
            {
                Parent = _split.Panel2,
                AutoWidth = true,
                AutoHeight = true,
                Margin = new Margin(4),
                VerticalAlignment = TextAlignment.Near,
                HorizontalAlignment = TextAlignment.Near,
                Offsets = Margin.Zero,
                Pivot = Float2.Zero,
            };

            // Entries panel
            _entriesPanel = new VerticalPanel
            {
                AnchorPreset = AnchorPresets.HorizontalStretchTop,
                Pivot = Float2.Zero,
                Offsets = Margin.Zero,
                IsScrollable = true,
                Parent = _split.Panel1,
            };

            // Cache entries icons
            _iconInfo = Editor.Icons.Info64;
            _iconWarning = Editor.Icons.Warning64;
            _iconError = Editor.Icons.Error64;

            // Bind events
            Editor.Options.OptionsChanged += OnEditorOptionsChanged;
            Debug.Logger.LogHandler.SendLog += LogHandlerOnSendLog;
            Debug.Logger.LogHandler.SendExceptionLog += LogHandlerOnSendExceptionLog;

            // Init editor options
            OnEditorOptionsChanged(Editor.Options.Options);
        }

        private void OnGroupButtonPressed(int index)
        {
            UpdateLogTypeVisibility((LogGroup)index, _groupButtons[index].Checked);
            if (Input.GetKey(KeyboardKeys.Shift))
            {
                for (int i = 0; i < (int)LogGroup.Max; i++)
                {
                    if (i == index)
                        continue;
                    _groupButtons[i].Checked = !_groupButtons[index].Checked;
                    UpdateLogTypeVisibility((LogGroup)i, _groupButtons[i].Checked);
                }
            }

            var options = Editor.Options.Options.Interface;
            options.DebugLogShowErrorMessages = _groupButtons[0].Checked;
            options.DebugLogShowWarningMessages = _groupButtons[1].Checked;
            options.DebugLogShowInfoMessages = _groupButtons[2].Checked;
            Editor.Options.Apply(Editor.Options.Options);
        }

        private void OnEditorOptionsChanged(EditorOptions options)
        {
            _timestampsFormats = options.Interface.DebugLogTimestampsFormat;
            _clearOnPlayButton.Checked = options.Interface.DebugLogClearOnPlay;
            _collapseLogsButton.Checked = options.Interface.DebugLogCollapse;
            _pauseOnErrorButton.Checked = options.Interface.DebugLogPauseOnError;
            _groupButtons[0].Checked = options.Interface.DebugLogShowErrorMessages;
            _groupButtons[1].Checked = options.Interface.DebugLogShowWarningMessages;
            _groupButtons[2].Checked = options.Interface.DebugLogShowInfoMessages;
            _colorInfo = options.Visual.LogInfoColor;
            _colorWarning = options.Visual.LogWarningColor;
            _colorError = options.Visual.LogErrorColor;
            _colorDebugLogText = options.Visual.ColorDebugLogText;
        }

        /// <summary>
        /// Clears the log.
        /// </summary>
        public void Clear()
        {
            lock (_locker)
            {
                _pendingEntries.Clear();
            }
            if (_entriesPanel == null)
                return;
            RemoveEntries();
        }

        /// <summary>
        /// Adds the specified log entry.
        /// </summary>
        /// <param name="desc">The log entry description.</param>
        public void Add(ref LogEntryDescription desc)
        {
            if (_entriesPanel == null)
                return;

            // Create new entry
            switch (_timestampsFormats)
            {
            case InterfaceOptions.TimestampsFormats.Utc: desc.Title = $"[{DateTime.UtcNow}] {desc.Title}"; break;
            case InterfaceOptions.TimestampsFormats.LocalTime: desc.Title = $"[{DateTime.Now}] {desc.Title}"; break;
            case InterfaceOptions.TimestampsFormats.TimeSinceStartup: desc.Title = string.Format("[{0:g}] ", TimeSpan.FromSeconds(Time.TimeSinceStartup)) + desc.Title; break;
            }
            var newEntry = new LogEntry(this, ref desc);

            // Enqueue
            lock (_locker)
            {
                _pendingEntries.Add(newEntry);
            }

            if (newEntry.Group == LogGroup.Warning && _iconType < LogType.Warning)
            {
                _iconType = LogType.Warning;
                UpdateIcon();
            }

            if (newEntry.Group == LogGroup.Error && _iconType < LogType.Error)
            {
                _iconType = LogType.Error;
                UpdateIcon();
            }

            // Pause on Error (we should do it as fast as possible)
            if (newEntry.Group == LogGroup.Error && _pauseOnErrorButton.Checked && Editor.StateMachine.CurrentState == Editor.StateMachine.PlayingState)
            {
                Editor.Log("Pause Play mode on error (toggle this behaviour in the Debug Log panel)");
                Editor.Simulation.RequestPausePlay();
            }
        }

        /// <summary>
        /// Gets or sets the selected entry.
        /// </summary>
        private LogEntry Selected
        {
            get => _selected;
            set
            {
                // Check if value will change
                if (_selected != value)
                {
                    // Select
                    _selected = value;
                    _logInfo.Text = _selected?.Info ?? string.Empty;
                }
            }
        }

        private void UpdateLogTypeVisibility(LogGroup group, bool isVisible)
        {
            _entriesPanel.IsLayoutLocked = true;

            var children = _entriesPanel.Children;
            for (int i = 0; i < children.Count; i++)
            {
                if (children[i] is LogEntry logEntry && logEntry.Group == group)
                    logEntry.Visible = isVisible;
            }

            _entriesPanel.IsLayoutLocked = false;
            _entriesPanel.PerformLayout();
        }

        private void UpdateCount()
        {
            UpdateCount((int)LogGroup.Error, " Error");
            UpdateCount((int)LogGroup.Warning, " Warning");
            UpdateCount((int)LogGroup.Info, " Message");

            if (_logCountPerGroup[(int)LogGroup.Error] == 0)
            {
                _iconType = _logCountPerGroup[(int)LogGroup.Warning] == 0 ? LogType.Info : LogType.Warning;
                UpdateIcon();
            }
        }

        private void UpdateCount(int group, string msg)
        {
            if (_logCountPerGroup[group] != 1)
                msg += 's';
            _groupButtons[group].Text = _logCountPerGroup[group] + msg;
        }

        private void UpdateIcon()
        {
            if (_iconType == LogType.Warning)
            {
                Icon = Editor.Icons.Warning32;
            }
            else if (_iconType == LogType.Error)
            {
                Icon = Editor.Icons.Error32;
            }
            else
            {
                Icon = Editor.Icons.Info32;
            }
        }

        private void LogHandlerOnSendLog(LogType level, string msg, Object o, string stackTrace)
        {
            var desc = new LogEntryDescription
            {
                Level = level,
                Title = msg,
                ContextObject = o?.ID ?? Guid.Empty,
            };

            if (!string.IsNullOrEmpty(stackTrace))
            {
                // Detect code location and remove leading internal stack trace part
                var matches = _logRegex.Matches(stackTrace);
                bool foundStart = false, noLocation = true;
                var fineStackTrace = _stringBuilder.Value;
                fineStackTrace.Clear();
                fineStackTrace.Capacity = Mathf.Max(fineStackTrace.Capacity, stackTrace.Length);
                for (int i = 0; i < matches.Count; i++)
                {
                    var match = matches[i];
                    var matchLocation = match.Groups[1].Value.Trim();
                    if (matchLocation.StartsWith("FlaxEngine.Debug.", StringComparison.Ordinal))
                    {
                        // C# start
                        foundStart = true;
                    }
                    else if (matchLocation.StartsWith("DebugLog::", StringComparison.Ordinal))
                    {
                        // C++ start
                        foundStart = true;
                    }
                    else if (foundStart)
                    {
                        if (noLocation)
                        {
                            desc.LocationFile = match.Groups[2].Value;
                            int.TryParse(match.Groups[4].Value, out desc.LocationLine);
                            noLocation = false;
                        }
                        fineStackTrace.AppendLine(match.Groups[0].Value);
                    }
                }
                desc.Description = fineStackTrace.ToString();
            }

            Add(ref desc);
        }

        private void LogHandlerOnSendExceptionLog(Exception exception, Object o)
        {
            LogEntryDescription desc = new LogEntryDescription
            {
                Level = LogType.Error,
                Title = exception.Message,
                Description = exception.StackTrace,
                ContextObject = o?.ID ?? Guid.Empty,
            };

            // Detect code location
            if (!string.IsNullOrEmpty(exception.StackTrace))
            {
                var match = _logRegex.Match(exception.StackTrace);
                if (match.Success)
                {
                    desc.LocationFile = match.Groups[2].Value;
                    int.TryParse(match.Groups[4].Value, out desc.LocationLine);
                }
            }

            Add(ref desc);
        }

        private void RemoveEntries()
        {
            _entriesPanel.IsLayoutLocked = true;

            Selected = null;
            for (int i = 0; i < _entriesPanel.ChildrenCount; i++)
            {
                if (_entriesPanel.GetChild(i) is LogEntry entry)
                {
                    _logCountPerGroup[(int)entry.Group]--;
                    entry.Dispose();
                    i--;
                }
            }
            UpdateCount();

            _entriesPanel.IsLayoutLocked = false;
            _entriesPanel.PerformLayout();
        }

        /// <inheritdoc />
        public override void Update(float deltaTime)
        {
            lock (_locker)
            {
                if (_pendingEntries.Count > 0)
                {
                    // Check if user want's to scroll view by var (or is viewing earlier entry)
                    var panelScroll = (Panel)_entriesPanel.Parent;
                    bool scrollView = (panelScroll.VScrollBar.Maximum - panelScroll.VScrollBar.TargetValue) < LogEntry.DefaultHeight * 1.5f;

                    // Add pending entries
                    LogEntry newEntry = null;
                    bool anyVisible = false;
                    _entriesPanel.IsLayoutLocked = true;
                    var spacing = _entriesPanel.Spacing;
                    var margin = _entriesPanel.Margin;
                    var offset = _entriesPanel.Offset;
                    var width = _entriesPanel.Width - margin.Width;
                    var top = _entriesPanel.Children.Count != 0 ? _entriesPanel.Children[_entriesPanel.Children.Count - 1].Bottom + spacing : margin.Top;
                    for (int i = 0; i < _pendingEntries.Count; i++)
                    {
                        if (_collapseLogsButton.Checked)
                        {
                            bool logExists = false;
                            foreach (var child in _entriesPanel.Children)
                            {
                                if (child is LogEntry entry)
                                {
                                    var pendingEntry = _pendingEntries[i];
                                    if (string.Equals(entry.Desc.Title, pendingEntry.Desc.Title, StringComparison.Ordinal) &&
                                        string.Equals(entry.Desc.LocationFile, pendingEntry.Desc.LocationFile, StringComparison.Ordinal) &&
                                        entry.Desc.Level == pendingEntry.Desc.Level &&
                                        string.Equals(entry.Desc.Description, pendingEntry.Desc.Description, StringComparison.Ordinal) &&
                                        entry.Desc.LocationLine == pendingEntry.Desc.LocationLine)
                                    {
                                        entry.LogCount += 1;
                                        newEntry = entry;
                                        logExists = true;
                                        break;
                                    }
                                }
                            }
                            if (logExists)
                                continue;
                        }
                        newEntry = _pendingEntries[i];
                        newEntry.Visible = _groupButtons[(int)newEntry.Group].Checked;
                        anyVisible |= newEntry.Visible;
                        newEntry.Parent = _entriesPanel;
                        newEntry.Bounds = new Rectangle(margin.Left + offset.X, top + offset.Y, width, newEntry.Height);
                        top = newEntry.Bottom + spacing;
                        _logCountPerGroup[(int)newEntry.Group]++;
                    }
                    _entriesPanel.Height = top + margin.Bottom;
                    _entriesPanel.IsLayoutLocked = false;
                    _pendingEntries.Clear();
                    UpdateCount();
                    Assert.IsNotNull(newEntry);

                    // Scroll to the new entry (if any added to view)
                    if (scrollView && anyVisible)
                    {
                        panelScroll.ScrollViewTo(newEntry, true);

                        bool scrollViewNew = (panelScroll.VScrollBar.Maximum - panelScroll.VScrollBar.TargetValue) < LogEntry.DefaultHeight * 1.5f;
                        if (scrollViewNew != scrollView)
                        {
                            // Make sure scrolling doesn't stop in case too many entries were added at once
                            panelScroll.ScrollViewTo(new Float2(float.MaxValue, float.MaxValue), true);
                        }
                    }
                }
            }

            base.Update(deltaTime);
        }

        /// <inheritdoc />
        public override void OnPlayBeginning()
        {
            // Clear on Play
            if (Editor.Options.Options.Interface.DebugLogClearOnPlay)
            {
                Clear();
            }
        }

        /// <inheritdoc />
        public override void OnStartContainsFocus()
        {
            _iconType = LogType.Info;
            UpdateIcon();
            base.OnStartContainsFocus();
        }

        /// <inheritdoc />
        public override void OnDestroy()
        {
            if (IsDisposing)
                return;

            // Unbind events
            Editor.Options.OptionsChanged -= OnEditorOptionsChanged;
            Debug.Logger.LogHandler.SendLog -= LogHandlerOnSendLog;
            Debug.Logger.LogHandler.SendExceptionLog -= LogHandlerOnSendExceptionLog;

            base.OnDestroy();
        }

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

        /// <inheritdoc />
        public override void OnLayoutSerialize(XmlWriter writer)
        {
            LayoutSerializeSplitter(writer, "Split", _split);
        }

        /// <inheritdoc />
        public override void OnLayoutDeserialize(XmlElement node)
        {
            LayoutDeserializeSplitter(node, "Split", _split);
        }

        /// <inheritdoc />
        public override void OnLayoutDeserialize()
        {
            _split.SplitterValue = 0.8f;
        }
    }
}
