// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using FlaxEditor.GUI.Drag;
using FlaxEditor.GUI.Timeline.Undo;
using FlaxEngine;
using FlaxEngine.GUI;

namespace FlaxEditor.GUI.Timeline
{
    /// <summary>
    /// The Timeline track that contains a header and custom timeline events/media.
    /// </summary>
    /// <seealso cref="FlaxEngine.GUI.ContainerControl" />
    [HideInEditor]
    public class Track : ContainerControl
    {
        /// <summary>
        /// The default prefix for drag data used for tracks dragging.
        /// </summary>
        public const string DragPrefix = "TRACK!?";

        /// <summary>
        /// The default node offset in y.
        /// </summary>
        public const float DefaultNodeOffsetY = 1.0f;

        /// <summary>
        /// The default drag insert position margin.
        /// </summary>
        public const float DefaultDragInsertPositionMargin = 4.0f;

        /// <summary>
        /// The header height.
        /// </summary>
        public const float HeaderHeight = 22.0f;

        private Timeline _timeline;
        private int _trackIndexCached = -1;
        private TrackFlags _flags;
        private Track _parentTrack;
        internal float _xOffset;
        private Margin _margin = new Margin(2.0f);
        private readonly List<Media> _media = new List<Media>();
        private readonly List<Track> _subTracks = new List<Track>();
        private bool _opened;
        private bool _isMouseDown;
        private bool _mouseOverArrow;
        private Float2 _mouseDownPos;

        /// <summary>
        /// The mute track checkbox.
        /// </summary>
        protected CheckBox _muteCheckbox;

        private DragTracks _dragTracks;
        private DragHandlers _dragHandlers;
        private DragItemPositioning _dragOverMode;
        private bool _isDragOverHeader;

        /// <summary>
        /// Gets the parent timeline.
        /// </summary>
        public Timeline Timeline => _timeline;

        /// <summary>
        /// Gets the parent track (null if this track is one of the root tracks in timeline).
        /// </summary>
        public Track ParentTrack
        {
            get => _parentTrack;
            set
            {
                if (_parentTrack != value)
                {
                    _parentTrack?.RemoveSubTrack(this);
                    value?.AdSubTrack(this);
                }
            }
        }

        /// <summary>
        /// Gets or sets the index of the track (in timeline track list).
        /// </summary>
        public int TrackIndex
        {
            get
            {
                if (_timeline == null)
                    return _trackIndexCached;
                int result = -1;
                for (int i = 0; i < _timeline.Tracks.Count; i++)
                {
                    if (_timeline.Tracks[i] == this)
                    {
                        result = i;
                        break;
                    }
                }
                return result;
            }
            set
            {
                if (_timeline != null)
                    _timeline.ChangeTrackIndex(this, value);
                else
                    _trackIndexCached = value;
            }
        }

        /// <summary>
        /// Gets the collection of the media events added to this track (read-only list).
        /// </summary>
        public IReadOnlyList<Media> Media => _media;

        /// <summary>
        /// Occurs when collection of the media events gets changed.
        /// </summary>
        public event Action<Track> MediaChanged;

        /// <summary>
        /// Gets the collection of the child tracks added to this track (read-only list).
        /// </summary>
        public IReadOnlyList<Track> SubTracks => _subTracks;

        /// <summary>
        /// Occurs when collection of the sub tracks gets changed.
        /// </summary>
        public event Action<Track> SubTracksChanged;

        /// <summary>
        /// The track text.
        /// </summary>
        public string Name;

        /// <summary>
        /// The track custom title text (name is used if title is null).
        /// </summary>
        public string Title;

        /// <summary>
        /// The track title color.
        /// </summary>
        public Color TitleTintColor = Color.White;

        /// <summary>
        /// The track icon.
        /// </summary>
        public SpriteHandle Icon;

        /// <summary>
        /// The icon color (tint).
        /// </summary>
        public Color IconColor = Color.White;

        /// <summary>
        /// The track color.
        /// </summary>
        public Color Color = Color.White;

        /// <summary>
        /// The track flags.
        /// </summary>
        public TrackFlags Flags
        {
            get => _flags;
            set
            {
                if (_flags == value)
                    return;
                _flags = value;
                _muteCheckbox.Checked = (Flags & TrackFlags.Mute) == 0;
                Timeline?.MarkAsEdited();
            }
        }

        /// <summary>
        /// Controls <see cref="TrackFlags.Mute"/> flag.
        /// </summary>
        public bool Mute
        {
            get => (Flags & TrackFlags.Mute) != 0;
            set => Flags = value ? (Flags | TrackFlags.Mute) : (Flags & ~TrackFlags.Mute);
        }

        /// <summary>
        /// Controls <see cref="TrackFlags.Loop"/> flag.
        /// </summary>
        public bool Loop
        {
            get => (Flags & TrackFlags.Loop) != 0;
            set => Flags = value ? (Flags | TrackFlags.Loop) : (Flags & ~TrackFlags.Loop);
        }

        /// <summary>
        /// The minimum amount of media items for this track.
        /// </summary>
        public int MinMediaCount = 0;

        /// <summary>
        /// The maximum amount of media items for this track.
        /// </summary>
        public int MaxMediaCount = 1024;

        /// <summary>
        /// The track archetype.
        /// </summary>
        public TrackArchetype Archetype;

        internal bool DrawDisabled;

        /// <summary>
        /// Gets a value indicating whether this track is expanded and all of its parents are also expanded.
        /// </summary>
        public bool IsExpandedAll => (ParentTrack == null || ParentTrack.IsExpandedAll) && (!CanExpand || IsExpanded);

        /// <summary>
        /// Gets a value indicating whether this all of this track parents are expanded.
        /// </summary>
        public bool HasParentsExpanded => (ParentTrack == null || ParentTrack.IsExpandedAll);

        /// <summary>
        /// Gets a value indicating whether this track has any sub-tracks.
        /// </summary>
        public bool HasSubTracks => _subTracks.Count > 0;

        /// <summary>
        /// Gets or sets a value indicating whether this track is expanded.
        /// </summary>
        public bool IsExpanded
        {
            get => _opened;
            set
            {
                if (value)
                    Expand();
                else
                    Collapse();
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether this track is collapsed.
        /// </summary>
        public bool IsCollapsed
        {
            get => !_opened;
            set
            {
                if (value)
                    Collapse();
                else
                    Expand();
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Track"/> class.
        /// </summary>
        /// <param name="options">The track initial options.</param>
        public Track(ref TrackCreateOptions options)
        {
            AutoFocus = false;
            Offsets = new Margin(0, 100, 0, HeaderHeight);

            Archetype = options.Archetype;
            Name = options.Archetype.Name;
            Icon = options.Archetype.Icon;
            _flags = options.Flags;

            // Mute checkbox
            const float buttonSize = 14;
            _muteCheckbox = new CheckBox
            {
                TooltipText = "Mute track",
                AutoFocus = true,
                Checked = (Flags & TrackFlags.Mute) == 0,
                AnchorPreset = AnchorPresets.MiddleRight,
                Offsets = new Margin(-buttonSize - 2, buttonSize, buttonSize * -0.5f, buttonSize),
                IsScrollable = false,
                Parent = this,
            };
            _muteCheckbox.StateChanged += OnMuteButtonStateChanged;
        }

        private void OnMuteButtonStateChanged(CheckBox checkBox)
        {
            if (Mute == !checkBox.Checked)
                return;
            using (new TrackUndoBlock(this))
                Mute = !checkBox.Checked;
        }

        /// <summary>
        /// Gets the arrow rectangle.
        /// </summary>
        protected Rectangle ArrowRect => new Rectangle(_xOffset + 2 + _margin.Left, (HeaderHeight - 12) * 0.5f, 12, 12);

        /// <summary>
        /// Called when parent timeline gets changed.
        /// </summary>
        /// <param name="timeline">The timeline.</param>
        public virtual void OnTimelineChanged(Timeline timeline)
        {
            _timeline = timeline;
            if (_trackIndexCached != -1)
                _timeline.ChangeTrackIndex(this, _trackIndexCached);

            for (var i = 0; i < _media.Count; i++)
            {
                _media[i].OnTimelineChanged(this);
            }

            UnlockChildrenRecursive();
        }

        /// <summary>
        /// Called when timeline zoom gets changed.
        /// </summary>
        public virtual void OnTimelineZoomChanged()
        {
            for (var i = 0; i < _media.Count; i++)
            {
                _media[i].OnTimelineZoomChanged();
            }
        }

        /// <summary>
        /// Called when timeline FPS gets changed.
        /// </summary>
        /// <param name="before">The before value.</param>
        /// <param name="after">The after value.</param>
        public virtual void OnTimelineFpsChanged(float before, float after)
        {
            for (var i = 0; i < _media.Count; i++)
            {
                _media[i].OnTimelineFpsChanged(before, after);
            }
        }

        /// <summary>
        /// Called when timeline current frame gets changed.
        /// </summary>
        /// <param name="frame">The frame.</param>
        public virtual void OnTimelineCurrentFrameChanged(int frame)
        {
        }

        /// <summary>
        /// Called when undo action gets reverted or applied for this track data. Can be used to update UI.
        /// </summary>
        public virtual void OnUndo()
        {
            for (var i = 0; i < _media.Count; i++)
            {
                _media[i].OnUndo();
            }
        }

        /// <summary>
        /// Called when parent track gets changed.
        /// </summary>
        /// <param name="parent">The parent track.</param>
        public virtual void OnParentTrackChanged(Track parent)
        {
            _parentTrack = parent;
        }

        /// <summary>
        /// Determines whether the specified track contains is contained in this track sub track or any sub track children.
        /// </summary>
        /// <param name="track">The track.</param>
        /// <returns><c>true</c> if this track contains the specified track; otherwise, <c>false</c>.</returns>
        public bool ContainsTrack(Track track)
        {
            return _subTracks.Any(x => x == track || x.ContainsTrack(track));
        }

        /// <summary>
        /// Called when track gets loaded from the serialized timeline data.
        /// </summary>
        public virtual void OnLoaded()
        {
        }

        /// <summary>
        /// Called when tracks gets spawned by the user.
        /// </summary>
        public virtual void OnSpawned()
        {
        }

        /// <summary>
        /// Called when tracks gets removed by the user.
        /// </summary>
        public virtual void OnDeleted()
        {
            for (var i = 0; i < _media.Count; i++)
            {
                _media[i].OnDeleted();
            }

            Dispose();
        }

        /// <summary>
        /// Called when track gets duplicated.
        /// </summary>
        /// <param name="clone">The cloned track instance.</param>
        public virtual void OnDuplicated(Track clone)
        {
        }

        /// <summary>
        /// Arranges the track and all its media. Called when timeline performs layout for the contents.
        /// </summary>
        public virtual void OnTimelineArrange()
        {
            if (ParentTrack == null)
            {
                _xOffset = 0;
                Visible = true;
            }
            else
            {
                _xOffset = ParentTrack._xOffset + 12.0f;
                Visible = ParentTrack.Visible && ParentTrack.IsExpanded;
            }

            for (int j = 0; j < Media.Count; j++)
            {
                var media = Media[j];

                media.Visible = Visible;
                media.Bounds = new Rectangle(media.X, Y + 2, media.Width, Height - 4);
            }
        }

        /// <summary>
        /// Gets the frame of the next keyframe (if found).
        /// </summary>
        /// <param name="time">The start time.</param>
        /// <param name="result">The result value.</param>
        /// <returns>True if found next keyframe, otherwise false.</returns>
        public virtual bool GetNextKeyframeFrame(float time, out int result)
        {
            result = 0;
            return false;
        }

        /// <summary>
        /// Gets the frame of the previous keyframe (if found).
        /// </summary>
        /// <param name="time">The start time.</param>
        /// <param name="result">The result value.</param>
        /// <returns>True if found previous keyframe, otherwise false.</returns>
        public virtual bool GetPreviousKeyframeFrame(float time, out int result)
        {
            result = 0;
            return false;
        }

        /// <summary>
        /// Adds the media.
        /// </summary>
        /// <param name="media">The media.</param>
        public virtual void AddMedia(Media media)
        {
            _media.Add(media);
            media.OnTimelineChanged(this);

            OnMediaChanged();

            media.UnlockChildrenRecursive();
            media.PerformLayout();
        }

        /// <summary>
        /// Removes the media.
        /// </summary>
        /// <param name="media">The media.</param>
        public virtual void RemoveMedia(Media media)
        {
            media.OnTimelineChanged(null);
            _media.Remove(media);

            OnMediaChanged();
        }

        /// <summary>
        /// Adds the sub track.
        /// </summary>
        /// <param name="track">The track.</param>
        public virtual void AdSubTrack(Track track)
        {
            _subTracks.Add(track);
            track.OnParentTrackChanged(this);

            OnSubTracksChanged();
        }

        /// <summary>
        /// Removes the sub track.
        /// </summary>
        /// <param name="track">The track.</param>
        public virtual void RemoveSubTrack(Track track)
        {
            track.OnParentTrackChanged(null);
            _subTracks.Remove(track);

            OnSubTracksChanged();
        }

        /// <summary>
        /// Called when collection of the media items gets changed.
        /// </summary>
        protected virtual void OnMediaChanged()
        {
            MediaChanged?.Invoke(this);
            _timeline?.ArrangeTracks();
        }

        /// <summary>
        /// Called when collection of the sub tracks gets changed.
        /// </summary>
        protected virtual void OnSubTracksChanged()
        {
            SubTracksChanged?.Invoke(this);
        }

        sealed class DragTracks : DragNames<DragEventArgs>
        {
            private Track _track;

            public DragTracks(Track track)
            : base(Track.DragPrefix, track.ValidateTrackDrag)
            {
                _track = track;
            }

            public List<Track> Tracks => Objects.ConvertAll(x => _track.Timeline.Tracks.FirstOrDefault(y => y.Name == x));

            /// <inheritdoc />
            public override DragDropEffect Effect
            {
                get
                {
                    var result = base.Effect;

                    // Reject drag over if one of the tracks cannot be moved to this track
                    if (result != DragDropEffect.None)
                    {
                        var tracks = Tracks;
                        for (int i = 0; i < tracks.Count; i++)
                        {
                            var track = tracks[i];
                            if (track == null)
                                continue;

                            bool blockDrag = false;
                            switch (_track._dragOverMode)
                            {
                            case DragItemPositioning.At:
                                blockDrag = !_track.CanAddChildTrack(track);
                                break;
                            case DragItemPositioning.Above:
                            case DragItemPositioning.Below:
                                var parent = _track.ParentTrack;
                                blockDrag = parent != null && !parent.CanAddChildTrack(track);
                                break;
                            }
                            if (blockDrag)
                                return DragDropEffect.None;
                        }
                    }

                    return result;
                }
            }
        }

        /// <summary>
        /// Called when drag and drop enters the track header area.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns>Drag action response.</returns>
        protected virtual DragDropEffect OnDragEnterHeader(DragData data)
        {
            if (_dragHandlers == null)
                _dragHandlers = new DragHandlers();

            // Check if drop tracks
            if (_dragTracks == null)
            {
                _dragTracks = new DragTracks(this);
                _dragHandlers.Add(_dragTracks);
            }
            if (_dragTracks.OnDragEnter(data))
                return _dragTracks.Effect;

            return DragDropEffect.None;
        }

        private bool ValidateTrackDrag(string name)
        {
            var track = _timeline.Tracks.FirstOrDefault(x => x.Name == name);

            // Reject dragging parents and itself
            return track != null && track != this && !track.ContainsTrack(this);
        }

        /// <summary>
        /// Called when drag and drop moves over the track header area.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns>Drag action response.</returns>
        protected virtual DragDropEffect OnDragMoveHeader(DragData data)
        {
            return _dragHandlers.Effect;
        }

        /// <summary>
        /// Called when drag and drop performs over the track header area.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns>Drag action response.</returns>
        protected virtual DragDropEffect OnDragDropHeader(DragData data)
        {
            var result = DragDropEffect.None;

            // Use drag positioning to change target parent and index
            Track newParent;
            int newOrder;
            if (_dragOverMode == DragItemPositioning.Above)
            {
                newParent = _parentTrack;
                newOrder = TrackIndex;
            }
            else if (_dragOverMode == DragItemPositioning.Below)
            {
                newParent = _parentTrack;
                newOrder = TrackIndex + 1;
            }
            else
            {
                newParent = this;
                newOrder = (_subTracks.Count > 0 ? _subTracks.Last().TrackIndex : TrackIndex) + 1;
            }

            // Drag tracks
            if (_dragTracks != null && _dragTracks.HasValidDrag)
            {
                var tracks = _dragTracks.Tracks;
                if (tracks.Count == 1 && tracks[0] != null)
                {
                    var track = tracks[0];
                    _timeline.Undo?.AddAction(new ReorderTrackAction(_timeline, track, track.TrackIndex, newOrder, track.ParentTrack?.Name, newParent?.Name));
                    track.ParentTrack = newParent;
                    track.TrackIndex = newOrder;
                }
                else
                {
                    var actions = new List<IUndoAction>(tracks.Count);
                    for (int i = 0; i < tracks.Count; i++)
                    {
                        var track = tracks[i];
                        if (track != null)
                        {
                            actions.Add(new ReorderTrackAction(_timeline, track, track.TrackIndex, newOrder, track.ParentTrack?.Name, newParent?.Name));
                            track.ParentTrack = newParent;
                            track.TrackIndex = newOrder;
                        }
                    }
                    _timeline.Undo?.AddAction(new MultiUndoAction(actions));
                }
                _timeline.OnTracksOrderChanged();
                _timeline.MarkAsEdited();

                result = DragDropEffect.Move;
            }

            // Clear cache
            _dragHandlers.OnDragDrop(null);

            // Expand if dropped sth
            if (result != DragDropEffect.None)
            {
                Expand();
            }

            return result;
        }

        /// <summary>
        /// Called when drag and drop leaves the track header area.
        /// </summary>
        protected virtual void OnDragLeaveHeader()
        {
            _dragHandlers.OnDragLeave();
        }

        /// <summary>
        /// Begins the drag drop operation.
        /// </summary>
        protected virtual void DoDragDrop()
        {
            DragData data;

            // Check if this node is selected
            if (_timeline.SelectedTracks.Contains(this))
            {
                // Get selected tracks
                var names = new List<string>();
                for (var i = 0; i < _timeline.SelectedTracks.Count; i++)
                {
                    var track = _timeline.SelectedTracks[i];
                    if (track.CanDrag)
                        names.Add(track.Name);
                }
                data = DragNames.GetDragData(DragPrefix, names);
            }
            else
            {
                data = DragNames.GetDragData(DragPrefix, Name);
            }

            // Start drag operation
            DoDragDrop(data);
        }

        /// <summary>
        /// Called when expanded state gets changed.
        /// </summary>
        protected virtual void OnExpandedChanged()
        {
            _timeline?.ArrangeTracks();
        }

        /// <summary>
        /// Gets a value indicating whether user can drag this track.
        /// </summary>
        public virtual bool CanDrag => true;

        /// <summary>
        /// Gets a value indicating whether user can rename this track.
        /// </summary>
        public virtual bool CanRename => true;

        /// <summary>
        /// Gets a value indicating whether user can copy and paste this track.
        /// </summary>
        public virtual bool CanCopyPaste => true;

        /// <summary>
        /// Gets a value indicating whether user can expand the track contents of the inner hierarchy.
        /// </summary>
        public virtual bool CanExpand => SubTracks.Count > 0;

        /// <summary>
        /// Determines whether this track can get the child track.
        /// </summary>
        /// <param name="track">The track.</param>
        /// <returns>True if can add this track, otherwise false.</returns>
        protected virtual bool CanAddChildTrack(Track track)
        {
            return false;
        }

        /// <summary>
        /// Updates the drag over mode based on the given mouse location.
        /// </summary>
        /// <param name="location">The location.</param>
        private void UpdateDrawPositioning(ref Float2 location)
        {
            if (new Rectangle(0, 0 - DefaultDragInsertPositionMargin - DefaultNodeOffsetY, Width, DefaultDragInsertPositionMargin * 2.0f).Contains(location))
                _dragOverMode = DragItemPositioning.Above;
            else if (IsCollapsed && new Rectangle(0, Height - DefaultDragInsertPositionMargin, Width, DefaultDragInsertPositionMargin * 2.0f).Contains(location))
                _dragOverMode = DragItemPositioning.Below;
            else
                _dragOverMode = DragItemPositioning.At;
        }

        /// <summary>
        /// Tests the header hit.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <returns>True if hits it.</returns>
        protected virtual bool TestHeaderHit(ref Float2 location)
        {
            return new Rectangle(0, 0, Width, HeaderHeight).Contains(ref location);
        }

        /// <summary>
        /// Starts the track renaming action.
        /// </summary>
        public void StartRenaming()
        {
            _timeline.Select(this, false);

            // Start renaming the track
            var dialog = RenamePopup.Show(this, new Rectangle(0, 0, Width, HeaderHeight), Name, false);
            dialog.Validate += OnRenameValidate;
            dialog.Renamed += OnRenamed;
        }

        private bool OnRenameValidate(RenamePopup popup, string value)
        {
            return _timeline.IsTrackNameValid(value);
        }

        private void OnRenamed(RenamePopup renamePopup)
        {
            var oldName = Name;
            OnRename(renamePopup.Text);
            _timeline.Undo?.AddAction(new RenameTrackAction(_timeline, this, oldName, Name));
        }

        /// <summary>
        /// Called when track should be renamed.
        /// </summary>
        /// <param name="newName">The new name.</param>
        protected virtual void OnRename(string newName)
        {
            Name = newName;
            _timeline?.MarkAsEdited();
        }

        /// <summary>
        /// Renames the track to the specified name and handles duplicated track names (adds number after the given name to make it unique).
        /// </summary>
        /// <param name="name">The base name.</param>
        public void Rename(string name)
        {
            string newName = name;
            int count = 0;
            while (_timeline != null && !_timeline.IsTrackNameValid(newName))
                newName = string.Format("{0} {1}", name, count++);
            OnRename(newName);
        }

        /// <summary>
        /// Deletes this track.
        /// </summary>
        public void Delete()
        {
            _timeline.Delete(this);
        }

        /// <summary>
        /// Expand track.
        /// </summary>
        public void Expand()
        {
            ExpandAllParents();

            if (_opened)
                return;

            _opened = true;

            OnExpandedChanged();
        }

        /// <summary>
        /// Collapse track.
        /// </summary>
        public void Collapse()
        {
            if (!_opened)
                return;

            _opened = false;

            OnExpandedChanged();
        }

        /// <summary>
        /// Expand track and all the children.
        /// </summary>
        public void ExpandAll()
        {
            bool wasLayoutLocked = IsLayoutLocked;
            IsLayoutLocked = true;

            Expand();

            for (int i = 0; i < SubTracks.Count; i++)
            {
                if (SubTracks[i].CanExpand)
                    SubTracks[i].ExpandAll();
            }

            IsLayoutLocked = wasLayoutLocked;
            PerformLayout();
        }

        /// <summary>
        /// Collapse track and all the children.
        /// </summary>
        public void CollapseAll()
        {
            bool wasLayoutLocked = IsLayoutLocked;
            IsLayoutLocked = true;

            Collapse();

            for (int i = 0; i < SubTracks.Count; i++)
            {
                if (SubTracks[i].CanExpand)
                    SubTracks[i].CollapseAll();
            }

            IsLayoutLocked = wasLayoutLocked;
            PerformLayout();
        }

        /// <summary>
        /// Ensure that all track parents are expanded.
        /// </summary>
        public void ExpandAllParents()
        {
            _parentTrack?.Expand();
        }

        /// <inheritdoc />
        public override void Draw()
        {
            // Cache data
            var style = Style.Current;
            bool isSelected = _timeline.SelectedTracks.Contains(this);
            bool isFocused = _timeline.ContainsFocus;
            var left = _xOffset + 16; // offset + arrow
            var height = HeaderHeight;
            var bounds = new Rectangle(Float2.Zero, Size);
            var textRect = new Rectangle(left, 0, bounds.Width - left, height);
            _margin.ShrinkRectangle(ref textRect);
            var textColor = style.Foreground * TitleTintColor;
            var backgroundColorSelected = style.BackgroundSelected;
            var backgroundColorHighlighted = style.BackgroundHighlighted;
            var backgroundColorSelectedUnfocused = style.LightBackground;
            var isMouseOver = IsMouseOver;

            // Draw background
            if (isSelected || isMouseOver)
            {
                Render2D.FillRectangle(bounds, (isSelected && isFocused) ? backgroundColorSelected : (isMouseOver ? backgroundColorHighlighted : backgroundColorSelectedUnfocused));
            }

            // Draw arrow
            if (CanExpand)
            {
                Render2D.DrawSprite(_opened ? style.ArrowDown : style.ArrowRight, ArrowRect, isMouseOver ? style.Foreground : style.ForegroundGrey);
            }

            // Draw icon
            if (Icon.IsValid)
            {
                Render2D.DrawSprite(Icon, new Rectangle(textRect.Left, (height - 16) * 0.5f, 16, 16), IconColor);
                textRect.X += 18.0f;
                textRect.Width -= 18.0f;
            }

            // Draw text
            Render2D.DrawText(style.FontSmall, Title ?? Name, textRect, textColor, TextAlignment.Near, TextAlignment.Center);

            // Disabled overlay
            DrawDisabled = Mute || (ParentTrack != null && ParentTrack.DrawDisabled);
            if (DrawDisabled)
            {
                Render2D.FillRectangle(bounds, new Color(0, 0, 0, 100));
            }

            // Draw drag and drop effect
            if (IsDragOver && _isDragOverHeader)
            {
                Color dragOverColor = style.BackgroundSelected * 0.6f;
                Rectangle rect;
                switch (_dragOverMode)
                {
                case DragItemPositioning.At:
                    rect = textRect;
                    break;
                case DragItemPositioning.Above:
                    rect = new Rectangle(textRect.X, textRect.Y - DefaultDragInsertPositionMargin - DefaultNodeOffsetY, textRect.Width, DefaultDragInsertPositionMargin * 2.0f);
                    break;
                case DragItemPositioning.Below:
                    rect = new Rectangle(textRect.X, textRect.Bottom - DefaultDragInsertPositionMargin, textRect.Width, DefaultDragInsertPositionMargin * 2.0f);
                    break;
                default:
                    rect = Rectangle.Empty;
                    break;
                }
                Render2D.FillRectangle(rect, dragOverColor);
            }

            base.Draw();
        }


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

            // Check if mouse hits bar and track isn't a root
            if (IsMouseOver)
            {
                // Check if left button goes down
                if (button == MouseButton.Left)
                {
                    _isMouseDown = true;
                    _mouseDownPos = location;
                }

                // Handled
                Focus();
                return true;
            }

            // Handled
            Focus();
            return true;
        }

        /// <summary>
        /// Called when showing timeline context menu to the user. Can be used to add custom buttons.
        /// </summary>
        /// <param name="menu">The menu.</param>
        /// <param name="time">The time (in seconds) at which context menu is shown (user clicked on a timeline).</param>
        public virtual void OnTimelineContextMenu(ContextMenu.ContextMenu menu, float time)
        {
        }

        /// <summary>
        /// Called when context menu is being prepared to show. Can be used to add custom options.
        /// </summary>
        /// <param name="menu">The menu.</param>
        protected virtual void OnContextMenu(ContextMenu.ContextMenu menu)
        {
        }

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

            // Check if mouse hits bar
            if (button == MouseButton.Right)
            {
                // Show context menu
                var menu = new ContextMenu.ContextMenu();
                if (CanRename)
                    menu.AddButton("Rename", "F2", StartRenaming);
                if (CanCopyPaste)
                    menu.AddButton("Duplicate", "Ctrl+D", () => Timeline.DuplicateSelectedTracks());
                menu.AddButton("Delete", "Del", Delete);
                if (CanExpand)
                {
                    menu.AddSeparator();
                    menu.AddButton("Expand All", ExpandAll);
                    menu.AddButton("Collapse All", CollapseAll);
                }
                if (SubTracks.Count > 1)
                {
                    menu.AddButton("Sort All", () => _timeline.SortTrack(this, _subTracks.Sort));
                }
                OnContextMenu(menu);
                menu.Show(this, location);
            }
            else if (button == MouseButton.Left)
            {
                // Clear flag
                _isMouseDown = false;
            }

            // Prevent from selecting track when user is just clicking at an arrow
            if (!_mouseOverArrow)
            {
                var window = Root;
                if (window.GetKey(KeyboardKeys.Control))
                {
                    // Add/Remove
                    if (_timeline.SelectedTracks.Contains(this))
                        _timeline.Deselect(this);
                    else
                        _timeline.Select(this, true);
                }
                else
                {
                    // Select
                    _timeline.Select(this, false);
                }
            }

            // Check if mouse hits arrow
            if (CanExpand && _mouseOverArrow)
            {
                // Toggle open state
                if (_opened)
                    Collapse();
                else
                    Expand();
            }

            // Handled
            Focus();
            return true;
        }

        /// <inheritdoc />
        public override void OnMouseMove(Float2 location)
        {
            base.OnMouseMove(location);

            // Cache flag
            _mouseOverArrow = CanExpand && ArrowRect.Contains(location);

            // Check if start drag and drop
            if (_isMouseDown && Float2.Distance(_mouseDownPos, location) > 10.0f)
            {
                // Clear flag
                _isMouseDown = false;

                // Start
                DoDragDrop();
            }
        }

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

            // Clear flags
            _mouseOverArrow = false;

            // Check if start drag and drop
            if (_isMouseDown)
            {
                // Clear flag
                _isMouseDown = false;

                // Start
                DoDragDrop();
            }

            // Hack fix for drag problems
            if (_isDragOverHeader)
            {
                _dragOverMode = DragItemPositioning.None;
                _isDragOverHeader = false;
                OnDragLeave();
            }
        }

        /// <inheritdoc />
        public override DragDropEffect OnDragEnter(ref Float2 location, DragData data)
        {
            var result = base.OnDragEnter(ref location, data);

            // Check if no children handled that event
            _dragOverMode = DragItemPositioning.None;
            if (result == DragDropEffect.None)
            {
                UpdateDrawPositioning(ref location);

                // Check if mouse is over header
                _isDragOverHeader = TestHeaderHit(ref location);
                if (_isDragOverHeader)
                {
                    // Check if mouse is over arrow
                    if (_children.Count > 0 && ArrowRect.Contains(location))
                    {
                        // Expand track
                        Expand();
                    }

                    result = OnDragEnterHeader(data);
                }

                if (result == DragDropEffect.None)
                    _dragOverMode = DragItemPositioning.None;
            }

            return result;
        }

        /// <inheritdoc />
        public override DragDropEffect OnDragMove(ref Float2 location, DragData data)
        {
            var result = base.OnDragMove(ref location, data);

            // Check if no children handled that event
            _dragOverMode = DragItemPositioning.None;
            if (result == DragDropEffect.None)
            {
                UpdateDrawPositioning(ref location);

                // Check if mouse is over header
                bool isDragOverHeader = TestHeaderHit(ref location);
                if (isDragOverHeader)
                {
                    // Check if mouse is over arrow
                    if (_children.Count > 0 && ArrowRect.Contains(location))
                    {
                        // Expand track
                        Expand();
                    }

                    if (!_isDragOverHeader)
                        result = OnDragEnterHeader(data);
                    else
                        result = OnDragMoveHeader(data);
                }
                else if (_isDragOverHeader)
                {
                    OnDragLeaveHeader();
                }
                _isDragOverHeader = isDragOverHeader;

                if (result == DragDropEffect.None || !isDragOverHeader)
                {
                    _dragOverMode = DragItemPositioning.None;
                }
            }

            return result;
        }

        /// <inheritdoc />
        public override DragDropEffect OnDragDrop(ref Float2 location, DragData data)
        {
            var result = base.OnDragDrop(ref location, data);

            // Check if no children handled that event
            if (result == DragDropEffect.None)
            {
                UpdateDrawPositioning(ref location);

                // Check if mouse is over header
                if (TestHeaderHit(ref location))
                {
                    result = OnDragDropHeader(data);
                }
            }

            // Clear cache
            _isDragOverHeader = false;
            _dragOverMode = DragItemPositioning.None;

            return result;
        }

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

            // Clear cache
            if (_isDragOverHeader)
            {
                _isDragOverHeader = false;
                OnDragLeaveHeader();
            }
            _dragOverMode = DragItemPositioning.None;
        }

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

            if (CanRename && TestHeaderHit(ref location))
            {
                StartRenaming();
                return true;
            }

            return false;
        }

        /// <inheritdoc />
        public override bool OnKeyDown(KeyboardKeys key)
        {
            if (IsFocused)
            {
                Track toSelect = null;
                switch (key)
                {
                case KeyboardKeys.F2:
                    if (CanRename)
                        StartRenaming();
                    return true;
                case KeyboardKeys.Delete:
                    _timeline.DeleteSelectedTracks();
                    return true;
                case KeyboardKeys.D:
                    if (Root.GetKey(KeyboardKeys.Control) && CanCopyPaste)
                    {
                        _timeline.DuplicateSelectedTracks();
                        return true;
                    }
                    break;
                case KeyboardKeys.ArrowLeft:
                    if (CanExpand && IsExpanded)
                    {
                        Collapse();
                        return true;
                    }
                    else
                    {
                        toSelect = ParentTrack;
                    }
                    break;
                case KeyboardKeys.ArrowRight:
                    if (CanExpand)
                    {
                        if (IsExpanded && HasSubTracks)
                        {
                            toSelect = SubTracks[0];
                        }
                        else
                        {
                            Expand();
                            return true;
                        }
                    }
                    break;
                case KeyboardKeys.ArrowUp:
                {
                    int index = IndexInParent;
                    while (index != 0)
                    {
                        toSelect = Parent.GetChild(--index) as Track;
                        if (toSelect != null && toSelect.HasParentsExpanded)
                            break;
                        toSelect = null;
                    }
                    break;
                }
                case KeyboardKeys.ArrowDown:
                {
                    int index = IndexInParent;
                    while (index < Parent.ChildrenCount - 1)
                    {
                        toSelect = Parent.GetChild(++index) as Track;
                        if (toSelect != null && toSelect.HasParentsExpanded)
                            break;
                        toSelect = null;
                    }
                    break;
                }
                }
                if (toSelect != null)
                {
                    Timeline.Select(toSelect);
                    ((Panel)Timeline.TracksPanel.Parent).ScrollViewTo(toSelect);
                    toSelect.Focus();
                    return true;
                }
            }

            // Base
            if (_opened)
                return base.OnKeyDown(key);
            return false;
        }

        /// <inheritdoc />
        public override void OnKeyUp(KeyboardKeys key)
        {
            // Base
            if (_opened)
                base.OnKeyUp(key);
        }

        /// <inheritdoc />
        public override int Compare(Control other)
        {
            if (other is Track otherTrack)
            {
                var name = Title ?? Name;
                var otherName = otherTrack.Title ?? otherTrack.Name;
                return string.Compare(name, otherName, StringComparison.InvariantCulture);
            }
            return base.Compare(other);
        }

        /// <inheritdoc />
        public override void OnDestroy()
        {
            // Cleanup
            Archetype = new TrackArchetype();
            MediaChanged = null;
            _timeline = null;
            _muteCheckbox = null;

            base.OnDestroy();
        }

        /// <summary>
        /// Loads the name using UTF8 encoding by reading name length (as 32bit int) followed by the contents and null-terminated character.
        /// </summary>
        /// <param name="stream">The input stream.</param>
        /// <returns>The name.</returns>
        protected static string LoadName(BinaryReader stream)
        {
            var length = stream.ReadInt32();
            var data = stream.ReadBytes(length);
            var value = Encoding.UTF8.GetString(data, 0, length);
            if (stream.ReadChar() != 0)
                throw new Exception("Invalid track data.");
            return value;
        }

        /// <summary>
        /// Saves the name using UTF8 encoding by writing name length (as 32bit int) followed by the contents and null-terminated character.
        /// </summary>
        /// <param name="stream">The output stream.</param>
        /// <param name="value">The value to write (can be null).</param>
        protected static void SaveName(BinaryWriter stream, string value)
        {
            value = value ?? string.Empty;
            var data = Encoding.UTF8.GetBytes(value);
            if (data.Length != value.Length)
                throw new Exception(string.Format("The name bytes data has different size as UTF8 bytes. Type {0}.", value));

            stream.Write(data.Length);
            stream.Write(data);
            stream.Write('\0');
        }
    }
}