using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using UnityEngine;
using UnityEditor;

[assembly: InternalsVisibleTo("Unity.Burst.Editor.Tests")]

namespace Unity.Burst.Editor
{
    internal class LongTextArea
    {
        internal const float naturalEnhancedPad = 20f;
        private const int kMaxFragment = 2048;

        internal struct Fragment
        {
            public int lineCount;
            public string text;
        }
        public enum Direction
        {
            Left,
            Right,
            Up,
            Down
        }
        internal struct Branch
        {
            public BurstDisassembler.AsmEdge Edge;

            public Rect StartHorizontal;
            public Rect VerticalLine;
            public Rect EndHorizontal;

            public Rect UpperLine;
            public Rect LowerLine;
            public float UpperAngle;
            public float LowerAngle;

            public Branch(BurstDisassembler.AsmEdge edge, Rect startHorizontal, Rect verticalLine, Rect endHorizontal, Rect upperLine, Rect lowerLine, float angle1, float angle2)
            {
                Edge = edge;

                StartHorizontal = startHorizontal;
                VerticalLine = verticalLine;
                EndHorizontal = endHorizontal;

                UpperLine = upperLine;
                LowerLine = lowerLine;
                UpperAngle = angle1;
                LowerAngle = angle2;
            }
        }

        internal float fontHeight = 0.0f;
        internal float fontWidth = 0.0f;

        public string GetText => m_Text;

        private string m_Text = "";
        private int _mTextLines = 0;
        private List<Fragment> m_Fragments = null;
        private bool invalidated = true;
        internal Vector2 finalAreaSize;

        private static readonly Texture2D backgroundTexture = Texture2D.whiteTexture;
        private static readonly GUIStyle textureStyle = new GUIStyle { normal = new GUIStyleState { background = backgroundTexture } };

        internal float horizontalPad = 50.0f;

        internal int[] lineDepth = null;
        internal bool[] _folded = null;
        internal int[] blockLine = null;
        private List<Fragment>[] _blocksFragments = null;

        private Fragment[] _blocksFragmentsStart = null;

        private Fragment GetFragmentStart(int blockIdx)
        {
            AddFoldedString(blockIdx);

            return _blocksFragmentsStart[blockIdx];
        }

        // Need two separate caches for start of blocks fragments, as we possibly differentiate between
        // rendered line and copied.
        private Fragment[] _blocksFragmentsStartPlain = null;
        private Fragment GetFragmentStartPlain(int blockIdx)
        {
            AddFoldedStringColorless(blockIdx);

            return _blocksFragmentsStartPlain[blockIdx];
        }

        // Used for searching when text is colored:
        internal List<Fragment>[] blocksFragmentsPlain = null;

        internal List<Fragment> GetPlainFragments(int blockIdx)
        {
            blocksFragmentsPlain[blockIdx] ??= RecomputeFragmentsFromBlock(blockIdx, false);

            return blocksFragmentsPlain[blockIdx];
        }

        private BurstDisassembler _disassembler;

        private int _selectBlockStart = -1;
        private float _selectStartY = -1f;
        private int _selectBlockEnd = -1;
        private float _selectEndY = -1f;

        private float _renderStartY = 0.0f;
        private int _renderBlockStart = -1;
        internal int _renderBlockEnd = -1;
        private int _initialLineCount = -1;

        private bool _mouseDown = false;
        private bool _mouseOutsideBounds = true;
        internal Vector2 selectPos = Vector2.zero;
        internal Vector2 selectDragPos = Vector2.zero;

        public bool HasSelection { get; private set; }

        private Color _selectionColor;
        private readonly Color _selectionColorDarkmode = new Color(0f, .6f, .9f, .5f);
        private readonly Color _selectionColorLightmode = new Color(0f, 0f, .9f, .2f);

        private readonly Color _lineHighlightColor = new Color(.56f, .56f, .56f, 0.2f);

        private readonly Color[] _regsColourWheel =
        {
            new Color(0f, 0f, .9f, .2f),
            new Color(0f, .9f, 0f, .2f),
            new Color(.9f, 0f, 0f, .2f)
        };

        private Color _hoverBoxColor;
        private Color _hoverTextColor;
        private readonly Color _hoverBoxColorDarkMode = new Color(.33f, .33f, .33f);
        private readonly Color _hoverBoxColorLightMode = new Color(.88f, .88f, .88f);

        // Current active hit should just be selection color
        private readonly Color _searchHitColor = new Color(.5f, .2f, .2f, .5f);

        private SearchCriteria _prevCriteria;
        internal int _activeSearchHitIdx = -1;
        internal readonly Dictionary<int, List<(int startIdx, int endIdx, int nr)>> searchHits = new Dictionary<int, List<(int startIdx, int endIdx, int nr)>>();

        private int _nrSearchHits = 0;

        public int NrSearchHits => _nrSearchHits;
        public int ActiveSearchNr => _activeSearchHitIdx;

        private readonly Color[] _colourWheel = new Color[]
            {Color.blue, Color.cyan, Color.green, Color.magenta, Color.red, Color.yellow, Color.white, Color.black};

        internal (int idx, int length) textSelectionIdx = (0, 0);
        private bool _textSelectionIdxValid = true;

        internal (int blockIdx, int textIdx) enhancedTextSelectionIdxStart = (0, 0);
        internal (int blockIdx, int textIdx) enhancedTextSelectionIdxEnd = (0, 0);

        internal bool CopyColorTags { get; private set; } = true;

        private bool _oldShowBranchMarkers = false;

        internal const int regLineThickness = 2;
        private const int highlightLineThickness = 3;
        private float _verticalPad = 0;

        internal Branch hoveredBranch;
        private BurstDisassembler.AsmEdge _prevHoveredEdge;

        private string _jobName;

        // Have this field, as NextHit needs the actual horizontal padding
        // in order to have correct horizontal scroll.
        private float _actualHorizontalPad = 0;

        internal int MaxLineDepth;

        /// <returns>
        /// (idx in regards to whole <see cref="str"/> , where color tags are removed from this line, idx from this line with color tags removed)
        /// </returns>
        internal readonly Func<string, int, (int total, int relative)> GetEndIndexOfColoredLine = BurstStringSearch.GetEndIndexOfColoredLine;


        internal readonly Func<string, int, (int total, int relative)> GetEndIndexOfPlainLine = BurstStringSearch.GetEndIndexOfPlainLine;


        internal bool IsTextSet(string jobName)
        {
            return _jobName == jobName;
        }

        public void SetText(string jobName, string textToRender, bool isDarkMode, BurstDisassembler disassembler, bool useDisassembler)
        {
            selectDragPos = Vector2.zero;
            StopSearching();
            StopSelection();
            ClearLinePress();

            _jobName = jobName;


            if (!useDisassembler)
            {
                m_Text = textToRender;
                _disassembler = null;
                m_Fragments = RecomputeFragments(m_Text);
                horizontalPad = 0.0f;
            }
            else
            {
                m_Fragments = null;
                SetDisassembler(disassembler);

                (_selectionColor, _hoverBoxColor, _hoverTextColor) = isDarkMode
                    ? (_selectionColorDarkmode, _hoverBoxColorDarkMode, _hoverBoxColorLightMode)
                    : (_selectionColorLightmode, _hoverBoxColorLightMode, _hoverBoxColorDarkMode);
            }

            invalidated = true;
        }

        public void ExpandAllBlocks()
        {
            StopSelection();
            ClearLinePress();

            int blockIdx = 0;
            foreach (var block in _disassembler.Blocks)
            {
                var changed = _folded[blockIdx];
                var blockLongEnoughForFold = block.Length > 1;

                _folded[blockIdx] = false;
                if (changed && blockLongEnoughForFold)
                {
                    finalAreaSize.y += Math.Max(block.Length - 1, 1) * fontHeight;
                }
                blockIdx++;
            }
        }

        private void ClearLinePress()
        {
            _lineRegCache.Clear();
            _pressedLine = -1;
        }

        public void FocusCodeBlocks()
        {
            StopSelection();
            ClearLinePress();

            var blockIdx = 0;
            foreach (var block in _disassembler.Blocks)
            {
                bool changed = false;
                switch (block.Kind)
                {
                    case BurstDisassembler.AsmBlockKind.None:
                    case BurstDisassembler.AsmBlockKind.Directive:
                    case BurstDisassembler.AsmBlockKind.Block:
                    case BurstDisassembler.AsmBlockKind.Data:
                        if (!_folded[blockIdx])
                        {
                            changed = true;
                        }
                        _folded[blockIdx] = true;
                        break;
                    case BurstDisassembler.AsmBlockKind.Code:
                        if (_folded[blockIdx])
                        {
                            changed = true;
                        }
                        _folded[blockIdx] = false;
                        break;
                }

                if (changed)
                {
                    if (_folded[blockIdx])
                    {
                        finalAreaSize.y -= Math.Max(block.Length - 1, 1) * fontHeight;
                    }
                    else
                    {
                        finalAreaSize.y += Math.Max(block.Length - 1, 1) * fontHeight;
                    }

                }
                blockIdx++;
            }
        }

        private void ComputeInitialLineCount()
        {
            var blockIdx = 0;
            _initialLineCount = 0;
            foreach (var block in _disassembler.Blocks)
            {
                switch (block.Kind)
                {
                    case BurstDisassembler.AsmBlockKind.None:
                    case BurstDisassembler.AsmBlockKind.Directive:
                    case BurstDisassembler.AsmBlockKind.Block:
                    case BurstDisassembler.AsmBlockKind.Data:
                        _folded[blockIdx] = true;
                        break;
                    case BurstDisassembler.AsmBlockKind.Code:
                        _folded[blockIdx] = false;
                        break;
                }
                var blockLongEnoughForFold = block.Length > 1;
                _folded[blockIdx] = _folded[blockIdx] && blockLongEnoughForFold;

                _initialLineCount += _folded[blockIdx] ? 1 : block.Length;
                blockIdx++;
            }
        }

        public void SetDisassembler(BurstDisassembler disassembler)
        {
            _disassembler = disassembler;
            if (disassembler == null)
            {
                return;
            }

            var numBlocks = _disassembler.Blocks.Count;
            var numLinesFromBlock = new int[numBlocks];
            lineDepth = new int[numBlocks];
            _folded = new bool[numBlocks];
            blockLine = new int[numBlocks];
            _blocksFragments = new List<Fragment>[numBlocks];
            _blocksFragmentsStart = new Fragment[numBlocks];
            _blocksFragmentsStartPlain = new Fragment[numBlocks];
            blocksFragmentsPlain = new List<Fragment>[numBlocks];

            ComputeInitialLineCount();

            // Count edges
            var edgeCount = 0;
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < numBlocks; i++)
            {
                sb.Append(_disassembler.GetOrRenderBlockToTextUncached(i, false));

                var block = _disassembler.Blocks[i];
                if (block.Edges != null)
                {
                    foreach (var edge in block.Edges)
                    {
                        if (edge.Kind == BurstDisassembler.AsmEdgeKind.OutBound)
                        {
                            edgeCount++;
                        }
                    }
                }
            }
            m_Text = sb.ToString();

            var edgeArray = new BurstDisassembler.AsmEdge[edgeCount];
            var edgeIndex = 0;
            foreach (var block in _disassembler.Blocks)
            {
                if (block.Edges != null)
                {
                    foreach (var edge in block.Edges)
                    {
                        if (edge.Kind == BurstDisassembler.AsmEdgeKind.OutBound)
                        {
                            edgeArray[edgeIndex++] = edge;
                        }
                    }
                }
            }

            Array.Sort(edgeArray, (a, b) =>
            {
                var src1BlockIdx = a.OriginRef.BlockIndex;
                var src1Line = _disassembler.Blocks[src1BlockIdx].LineIndex;
                src1Line += a.OriginRef.LineIndex;
                var dst1BlockIdx = a.LineRef.BlockIndex;
                var dst1Line = _disassembler.Blocks[dst1BlockIdx].LineIndex;
                dst1Line += a.LineRef.LineIndex;
                var Len1 = Math.Abs(src1Line - dst1Line);
                var src2BlockIdx = b.OriginRef.BlockIndex;
                var src2Line = _disassembler.Blocks[src2BlockIdx].LineIndex;
                src2Line += b.OriginRef.LineIndex;
                var dst2BlockIdx = b.LineRef.BlockIndex;
                var dst2Line = _disassembler.Blocks[dst2BlockIdx].LineIndex;
                dst2Line += b.LineRef.LineIndex;
                var Len2 = Math.Abs(src2Line - dst2Line);
                return Len1 - Len2;
            });

            // Iterate through the blocks to precompute the widths for branches
            var maxLine = 0;
            foreach (var edge in edgeArray)
            {
                if (edge.Kind != BurstDisassembler.AsmEdgeKind.OutBound) continue;

                var s = edge.OriginRef.BlockIndex;
                var e = edge.LineRef.BlockIndex;
                if (e == s + 1)
                {
                    continue;   // don't render if its pointing to next line
                }

                var m = 0;

                var l = s;
                var le = e;
                if (e < s)
                {
                    l = e;
                    le = s;
                }

                for (; l <= le; l++)
                {
                    numLinesFromBlock[l]++;
                    if (m < numLinesFromBlock[l])
                    {
                        m = numLinesFromBlock[l];
                    }
                    if (maxLine < m)
                    {
                        maxLine = m;
                    }
                }

                lineDepth[s] = m;
            }

            MaxLineDepth = maxLine;

            horizontalPad = naturalEnhancedPad + maxLine * 10;
        }

        // Changing the font size doesn't update the text field, so added this to force a recalculation
        public void Invalidate()
        {
            // Assumed to only happen on altering font size (or similar actions not leading to altered number of
            // assembly lines in view).
            // Hence we only have to clear the cached rects for highlighting, and not the actual line number _linePressed,
            // as that will stay constant.
            _lineRegCache.Clear();
            invalidated = true;
        }

        private struct HoverBox
        {
            public Rect box;
            public string info;
            /// <summary>
            /// Indicates start and end column of hovered token.
            /// </summary>
            public (int start, int end) columnRange;
            public int lineNumber;
            public bool valid;
        }

        private HoverBox hover;

        public void Interact(Rect workingArea, EventType eventT)
        {
            if (_disassembler == null)
            {
                return;
            }

            var pos = GetMousePosForHover();
            if (!workingArea.Contains(pos))
            {
                // Mouse position outside of assembly view
                return;
            }

            // lineNumber (absolute)
            var lineNumber = GetLineNumber(pos);

            // Mouse just pressed this line.
            if (eventT == EventType.MouseDown)
            {
                var lineStr = GetLineString(_disassembler.Lines[lineNumber]);
                var lineLen = (lineStr.Length) * fontWidth;

                var blockIdx = 0;
                var len = _disassembler.Blocks.Count;
                for (; blockIdx < len-1; blockIdx++)
                {
                    if (_disassembler.Blocks[blockIdx+1].LineIndex > lineNumber)
                    {
                        break;
                    }
                }

                if (_folded[blockIdx])
                {
                    lineLen += 4*fontWidth;
                }
                if (pos.x < _actualHorizontalPad || pos.x > _actualHorizontalPad + lineLen)
                {
                    _pressedLine = -1;
                }
                else
                {
                    _pressedLine = lineNumber;
                }
            }

            var column = Mathf.FloorToInt((pos.x - horizontalPad) / fontWidth);

            var sameToken = hover.lineNumber == lineNumber &&
                            BurstMath.WithinRange(hover.columnRange.start, hover.columnRange.end, column);
            if (hover.valid && (sameToken || hover.box.Contains(pos)))
            {
                // Use the cached info text.
                return;
            }
            // Cached instruction info text is not valid. So try query new.
            hover.valid = false;

            if (column < 0 || lineNumber < 0 || lineNumber >= _disassembler.Lines.Count)
            {
                return;
            }

            int tokIdx;
            try
            {
                // block 0 is queried as the absolut line number is given to the function.
                // This will give us the correct assembly token, as the function queries
                // assembly line based on offset from block start => line lineNumber is queried.
                tokIdx = _disassembler.GetTokenIndexFromColumn(0, lineNumber, column, out _);
            }
            catch (ArgumentOutOfRangeException)
            {
                return;
            }
            if (tokIdx < 0)
            {
                return;
            }
            // Found match

            var token = _disassembler.GetToken(tokIdx);
            var tokenString = _disassembler.GetTokenAsText(token);

            if (token.Kind != BurstDisassembler.AsmTokenKind.Instruction &&
                token.Kind != BurstDisassembler.AsmTokenKind.BranchInstruction &&
                token.Kind != BurstDisassembler.AsmTokenKind.CallInstruction &&
                token.Kind != BurstDisassembler.AsmTokenKind.FunctionBegin &&
                token.Kind != BurstDisassembler.AsmTokenKind.FunctionEnd &&
                token.Kind != BurstDisassembler.AsmTokenKind.JumpInstruction &&
                token.Kind != BurstDisassembler.AsmTokenKind.ReturnInstruction &&
                token.Kind != BurstDisassembler.AsmTokenKind.InstructionSIMD)
            {
                return;
            }
            if (_disassembler.GetInstructionInformation(tokenString, out var info))
            {
                hover.valid = true;
                // Don't know the actual size needed yet.
                hover.box = new Rect(pos, Vector2.zero);
                hover.info = info;
                hover.lineNumber = lineNumber;

                // Find column range of instruction:
                var line = _disassembler.Lines[lineNumber];
                var idx = line.ColumnIndex + (tokIdx - line.TokenIndex - 1);
                var colStart = _disassembler.ColumnIndices[idx];
                var colEnd = colStart + token.Length - 1;
                hover.columnRange = (colStart, colEnd);
            }
        }

        /// Not clipped, so use only if you know the line will be within the UI element
        private static void DrawLine(Vector2 start, Vector2 end, int width)
        {
            var matrix = GUI.matrix;
            Vector2 distance = end - start;
            float angle = Mathf.Rad2Deg * Mathf.Atan(distance.y / distance.x);
            if (distance.x < 0)
            {
                angle += 180;
            }

            int width2 = (int)Mathf.Ceil(width / 2);

            Rect pos = new Rect(start.x, start.y - width2, distance.magnitude, width);

            GUIUtility.RotateAroundPivot(angle, start);
            GUI.DrawTexture(pos, backgroundTexture);
            GUI.matrix = matrix; // restore initial matrix to avoid floating point inaccuracies with RotateAroundPivot(...)
        }

        private void DrawLine(Rect line, float angle)
        {
            var matrix = GUI.matrix;
            GUIUtility.RotateAroundPivot(angle, new Vector2(line.x, line.center.y));
            GUI.DrawTexture(line, backgroundTexture);
            GUI.matrix = matrix; // restore initial matrix to avoid floating point inaccuracies with RotateAroundPivot(...)
        }

        private void DrawHover(GUIStyle style, Rect workingArea)
        {
            if (!hover.valid)
            {
                return;
            }
            if (hover.box.size == Vector2.zero)
            {
                // Hover size has not been initialized yet.
                var sizex = (hover.info.Length + 1.5f) * fontWidth;
                var sizey = 2f * fontHeight;
                var posx = hover.box.x + 10;
                var posy = hover.box.y;
                if (posx + sizex > workingArea.width)
                {
                    // Box exceeds rightmost bound so cramp it in
                    var availableSpace = workingArea.xMax - posx;
                    var possiblyCharacters = Mathf.FloorToInt(availableSpace / fontWidth);
                    var neededLines = hover.info.Length / possiblyCharacters + 2; // +2 to ensure enough lines for the label

                    var availableSpacey = workingArea.yMax - posy;
                    var possibleLines = Mathf.FloorToInt(availableSpacey / fontHeight);

                    var tmp = neededLines - possibleLines;
                    if (tmp > 0)
                    {
                        posy -= tmp * fontHeight;
                    }

                    sizey = neededLines * fontHeight + fontHeight;
                    sizex = availableSpace;
                }
                hover.box.size = new Vector2(sizex, sizey);
                hover.box.position = new Vector2(posx, posy);
            }
            var col = GUI.color;
            GUI.color = _hoverBoxColor;

            var pos = hover.box.position;
            var size = hover.box.size;
            GUI.Box(hover.box, "", textureStyle);

            GUI.color = _hoverTextColor;
            var hoverStyle = style;
            hoverStyle.wordWrap = true;
            GUI.Label(
                new Rect(pos.x + fontWidth * 0.5f,
                    pos.y + fontHeight * 0.5f,
                    size.x - fontWidth/2f,
                    size.y - fontHeight),
                hover.info, hoverStyle);

            GUI.color = col;
        }

        private void MakeBranchThin(ref Branch branch)
        {
            int lineThickness = regLineThickness;

            branch.StartHorizontal.height = lineThickness;
            branch.VerticalLine.width = lineThickness;
            branch.EndHorizontal.height = lineThickness;

            branch.UpperLine.height = lineThickness;
            branch.LowerLine.height = lineThickness;

            // Adjusting position for arrow tip for thicker lines.
            branch.UpperLine.y += (highlightLineThickness - regLineThickness);

            branch.UpperLine.position -= new Vector2(.5f, .5f);
            branch.LowerLine.position -= new Vector2(.5f, -.5f);

            // Make end part of arrow expand upwards.
            branch.EndHorizontal.y += (highlightLineThickness - regLineThickness);
        }

        /// <summary>
        /// Use this for hover, as there is a slight visual mis-balance
        /// between cursor position and visual cursor.
        /// </summary>
        private Vector2 GetMousePosForHover()
        {
            Vector2 mousePos = Event.current.mousePosition;
            mousePos.y -= 0.5f;
            mousePos.x += 0.5f;
            return mousePos;
        }

        /// <summary>
        /// Calculate the position and size of an edge, and return it as a branch.
        /// </summary>
        /// <param name="edge"> The edge to base branch on. </param>
        /// <param name="x"> Start x position of branch. </param>
        /// <param name="y1"> Start y position of branch. </param>
        /// <param name="y2"> End y position of branch. </param>
        /// <param name="w"> Depth of branch. </param>
        private Branch CalculateBranch(BurstDisassembler.AsmEdge edge, float x, float y1, float y2, int w)
        {
            bool isEdgeHovered = edge.Equals(_prevHoveredEdge);

            int lineThickness = isEdgeHovered
                ? highlightLineThickness
                : regLineThickness;

            // Calculate rectangles for branch arrows:
            var start = new Vector2(x, y1 + _verticalPad);
            var end = start + new Vector2(-(w * 10), 0);

            var branchStartPos = new Rect(end.x - lineThickness / 2, start.y - 1, start.x - end.x + lineThickness / 2, lineThickness);

            start = end;
            end = start + new Vector2(0, y2 - y1);

            var branchVerticalPartPos = end.y < start.y
                ? new Rect(start.x - 1, end.y, lineThickness, start.y - end.y)
                : new Rect(start.x - 1, start.y, lineThickness, end.y - start.y);

            start = end;
            end = start + new Vector2(w * 10, 0);

            var branchEndPos = new Rect(start.x - lineThickness / 2, start.y - 1, end.x - start.x, lineThickness);

            // Calculate rectangles for arrow tip.
            Vector2 lowerArrowTipStart = end;
            Vector2 upperArrowtipStart = end;

            //   Moving the arrow tips closer together.
            upperArrowtipStart += new Vector2(0, 0.5f);
            lowerArrowTipStart -= new Vector2(0, 0.5f);

            //   Upper arrow tip.
            var upperArrowTipEnd = upperArrowtipStart + new Vector2(-5, -5);

            var upperLine = new Rect(upperArrowtipStart.x, upperArrowtipStart.y - (int)Mathf.Ceil(lineThickness / 2), (upperArrowTipEnd - upperArrowtipStart).magnitude, lineThickness);

            //   Lower arrow tip.
            var lowerArrowtipEnd = lowerArrowTipStart + new Vector2(-5, 5);
            var lowerLine = new Rect(lowerArrowTipStart.x, lowerArrowTipStart.y - (int)Mathf.Ceil(lineThickness / 2), (lowerArrowtipEnd - lowerArrowTipStart).magnitude, lineThickness);

            if (isEdgeHovered)
            {
                // Adjusting position for arrow tip for thicker lines.
                upperArrowtipStart.y -= (highlightLineThickness - regLineThickness);
                upperArrowTipEnd.y -= (highlightLineThickness - regLineThickness);
                upperLine.y -= (highlightLineThickness - regLineThickness);

                upperLine.position += new Vector2(.5f, .5f);
                lowerLine.position += new Vector2(.5f, -.5f);

                // Make end part of arrow expand upwards.
                branchEndPos.y -= (highlightLineThickness - regLineThickness);
            }

            var branch = new Branch(edge, branchStartPos, branchVerticalPartPos, branchEndPos, upperLine, lowerLine,
                BurstMath.CalculateAngle(upperArrowtipStart, upperArrowTipEnd), BurstMath.CalculateAngle(lowerArrowTipStart, lowerArrowtipEnd));

            // Handling whether mouse is hovering over edge.
            Vector2 mousePos = GetMousePosForHover();

            // Rotate mousePos so it seems like lower arrow tip is not rotated.
            Vector2 lowerArrowTipPivot = lowerArrowTipStart;
            lowerArrowTipPivot.y -= (int)Mathf.Ceil(lineThickness / 2);
            Vector2 angledMouseLower = BurstMath.AnglePoint(BurstMath.CalculateAngle(lowerArrowTipPivot, lowerArrowtipEnd), mousePos, new Vector2(lowerLine.x, lowerLine.center.y));
            angledMouseLower.y -= (int)Mathf.Ceil(lineThickness / 2);

            Vector2 upperArrowTipPivot = upperArrowtipStart;
            upperArrowTipPivot.y += (int)Mathf.Ceil(lineThickness / 2);
            Vector2 angleMouseUpper = BurstMath.AnglePoint(BurstMath.CalculateAngle(upperArrowTipPivot, upperArrowTipEnd) - 360, mousePos, new Vector2(upperLine.x, upperLine.center.y));
            angleMouseUpper.y += (int)Mathf.Ceil(lineThickness / 2);

            if (BurstMath.AdjustedContains(branchStartPos, mousePos) || BurstMath.AdjustedContains(branchVerticalPartPos, mousePos) || BurstMath.AdjustedContains(branchEndPos, mousePos)
                || BurstMath.AdjustedContains(lowerLine, angledMouseLower) || BurstMath.AdjustedContains(upperLine, angleMouseUpper))
            {
                // Handling whether another branch was already made thick is done in DrawBranch(...).
                if (!hoveredBranch.Edge.Equals(default(BurstDisassembler.AsmEdge)) && hoveredBranch.Edge.Equals(_prevHoveredEdge))
                {
                    return branch;
                }
                hoveredBranch = branch;
            }
            return branch;
        }



        /// <summary>
        /// Draws a branch as a jump-able set of boxes.
        /// </summary>
        /// <param name="branch"> The branch to draw. </param>
        /// <param name="w"> Depth of the branch. </param>
        /// <param name="colourWheel"> Array of possible colors for branches. </param>
        /// <param name="workingArea"> Current view in inspector. </param>
        private void DrawBranch(Branch branch, int w, Rect workingArea)
        {
            bool isBranchHovered = branch.Edge.Equals(hoveredBranch.Edge);
            Vector2 scrollPos = workingArea.position;

            int lineThickness = isBranchHovered
                ? highlightLineThickness
                : regLineThickness;

            GUI.color = _colourWheel[w % _colourWheel.Length];

            // Check if hovered but not made thick yet:
            if (isBranchHovered && !branch.Edge.Equals(_prevHoveredEdge))
            {
                // alter thickness as edge is hovered over.
                branch.StartHorizontal.height = highlightLineThickness;
                branch.VerticalLine.width = highlightLineThickness;
                branch.EndHorizontal.height = highlightLineThickness;

                branch.UpperLine.height = highlightLineThickness;
                branch.LowerLine.height = highlightLineThickness;

                // Adjusting position for arrow tip for thicker lines.
                branch.UpperLine.y -= (highlightLineThickness - regLineThickness);

                branch.UpperLine.position += new Vector2(.5f, .5f);
                branch.LowerLine.position += new Vector2(.5f, -.5f);

                // Make end part of arrow expand upwards.
                branch.EndHorizontal.y -= (highlightLineThickness - regLineThickness);
            }
            else if (branch.EndHorizontal.height == highlightLineThickness && !isBranchHovered)
            {
                // the branch was previously hovered, but is now hidden behind
                // another branch, that is the one being visually hovered.
                MakeBranchThin(ref branch);
            }

            // Render actual arrows:
            GUI.Box(branch.StartHorizontal, "", textureStyle);
            GUI.Box(branch.VerticalLine, "", textureStyle);

            float yy = branch.EndHorizontal.y - scrollPos.y;
            if (yy >= 0 && yy < workingArea.height)
            {
                GUI.Box(branch.EndHorizontal, "", textureStyle);
                DrawLine(branch.UpperLine, branch.UpperAngle);
                DrawLine(branch.LowerLine, branch.LowerAngle);
            }

            // Use below instead of buttons, to make the currently hovered edge the jump-able,
            // and not the edge rendered first i.e. when two edges overlap.
            if (Event.current.type == EventType.MouseDown && isBranchHovered)
            {
                Vector2 mousePos = GetMousePosForHover();

                // Rotate mousePos so it seems like lower arrow tip is not rotated.
                Vector2 lowerLineEnd = branch.LowerLine.position;
                lowerLineEnd.y += (int)Mathf.Ceil(lineThickness / 2);
                lowerLineEnd += new Vector2(-5, 5);

                Vector2 angledMouseLower = BurstMath.AnglePoint(BurstMath.CalculateAngle(branch.LowerLine.position, lowerLineEnd),
                    mousePos, new Vector2(branch.LowerLine.x, branch.LowerLine.center.y));
                angledMouseLower.y -= (int)Mathf.Ceil(lineThickness / 2);

                // Rotate mousePos so it seems like upper arrow tip isn't rotated.
                Vector2 upperArrowTipPivot = branch.UpperLine.position;
                upperArrowTipPivot.y += 2 * (int)Mathf.Ceil(lineThickness / 2);

                Vector2 upperLineEnd = branch.UpperLine.position;
                upperLineEnd.y += (int)Mathf.Ceil(lineThickness / 2);
                upperLineEnd += new Vector2(-5, -5);

                Vector2 angleMouseUpper = BurstMath.AnglePoint(BurstMath.CalculateAngle(upperArrowTipPivot, upperLineEnd) - 360,
                    Event.current.mousePosition, new Vector2(branch.UpperLine.x, branch.UpperLine.center.y));
                angleMouseUpper.y += (int)Mathf.Ceil(lineThickness / 2);

                // Se if a jump should be made and jump.
                if (BurstMath.AdjustedContains(branch.StartHorizontal, mousePos))
                {
                    // make end arrow be at mouse cursor.
                    var target = branch.EndHorizontal;
                    target.y += branch.StartHorizontal.y < branch.EndHorizontal.y
                        ? (workingArea.yMax - mousePos.y)
                        : (workingArea.yMin - mousePos.y + highlightLineThickness / 2f);
                    GUI.ScrollTo(target);
                    Event.current.Use();
                }
                else if (BurstMath.AdjustedContains(branch.EndHorizontal, mousePos) || BurstMath.AdjustedContains(branch.LowerLine, angledMouseLower)
                    || BurstMath.AdjustedContains(branch.UpperLine, angleMouseUpper) || BurstMath.AdjustedContains(branch.VerticalLine, mousePos))
                {
                    var target = branch.StartHorizontal;
                    target.y += branch.StartHorizontal.y < branch.EndHorizontal.y
                        ? workingArea.yMin - mousePos.y + highlightLineThickness / 2
                        : workingArea.yMax - mousePos.y;
                    GUI.ScrollTo(target);
                    Event.current.Use();
                }
            }
        }

        private bool DrawFold(float x, float y, bool state, BurstDisassembler.AsmBlockKind kind)
        {
            var currentBg = GUI.backgroundColor;
            switch (kind)
            {
                case BurstDisassembler.AsmBlockKind.None:
                case BurstDisassembler.AsmBlockKind.Directive:
                case BurstDisassembler.AsmBlockKind.Block:
                    GUI.backgroundColor = Color.grey;
                    break;
                case BurstDisassembler.AsmBlockKind.Code:
                    GUI.backgroundColor = Color.green;
                    break;
                case BurstDisassembler.AsmBlockKind.Data:
                    GUI.backgroundColor = Color.magenta;
                    break;
            }

            var pressed = false;
            if (state)
            {
                pressed = GUI.Button(new Rect(x - fontWidth, y, fontWidth, fontHeight), "+");
            }
            else
            {
                pressed = GUI.Button(new Rect(x - fontWidth, y, fontWidth, fontHeight), "-");
            }

            GUI.backgroundColor = currentBg;

            return pressed;
        }

        internal void Layout(GUIStyle style, float hPad)
        {
            var oldFontHeight = fontHeight;
            var oldFontWidth = fontWidth;

#if UNITY_2023_1_OR_NEWER
            var cacheWidth0 = style.CalcSize(new GUIContent("W"));
            var cacheWidth1 = style.CalcSize(new GUIContent("WW"));

            var cacheHeight0 = style.CalcSize(new GUIContent("\n"));
            var cacheHeight1 = style.CalcSize(new GUIContent("\n\n"));

            fontHeight = cacheHeight1.y - cacheHeight0.y;
            fontWidth = cacheWidth1.x - cacheWidth0.x;
#else
            var cacheSize0 = style.CalcSize(new GUIContent("W\n"));
            var cacheSize1 = style.CalcSize(new GUIContent("WW\n\n"));

            fontHeight = cacheSize1.y - cacheSize0.y;
            fontWidth = cacheSize1.x - cacheSize0.x;
#endif

            _verticalPad = fontHeight * 0.5f;

            // oldFontWidth == 0 means we picked the first target after opening inspector.
            var diffX = oldFontWidth != 0 ? fontWidth / oldFontWidth : 0.0f;

            if (HasSelection && (oldFontWidth != fontWidth || oldFontHeight != fontHeight))
            {
                float diffY = fontHeight / oldFontHeight;

                // We only have to take padding into account for x-axis, as it's the only one with it.
                selectPos = new Vector2(((selectPos.x - hPad) * diffX) + hPad, diffY * selectPos.y);
                selectDragPos = new Vector2(((selectDragPos.x - hPad) * diffX) + hPad, diffY * selectDragPos.y);
            }

            invalidated = false;
            var oldFinalAreaSizeX = finalAreaSize.x;
            finalAreaSize = new Vector2(0.0f, 0.0f);

            if (_disassembler == null)
            {
                LayoutPlain(style);
            }
            else
            {
                finalAreaSize.y = _initialLineCount * fontHeight;
                finalAreaSize.x = oldFinalAreaSizeX * diffX;
            }
        }

        /// <summary>
        /// Find accumulated fragment number the block start at.
        /// </summary>
        /// <param name="start">Block index to start search at. Should match <see cref="acc"/>.</param>
        /// <param name="acc">Accumulated fragment number that block <see cref="start"/> start at.</param>
        internal int GetFragNrFromBlockIdx(int blockIdx, int start, int acc, ref float positionY)
        {
            int fragNr = acc;

            for (int b = start; b < blockIdx; b++)
            {
                if (_folded[b])
                {
                    fragNr += GetPlainFragments(b).Count;
                    positionY += fontHeight;
                }
                else
                {
                    foreach (var frag in GetPlainFragments(b))
                    {
                        fragNr++;
                        positionY += frag.lineCount * fontHeight;
                    }
                }
            }

            return fragNr;
        }

        internal bool SearchText(SearchCriteria searchCriteria, Regex regx, ref Rect workingArea, bool stopFirstMatch = false, bool focusTop = false) =>
            _disassembler == null
                ? SearchTextPlain(searchCriteria, regx, ref workingArea, stopFirstMatch, focusTop)
                : SearchTextEnhanced(searchCriteria, regx, ref workingArea, stopFirstMatch, focusTop);

        /// <summary>
        /// Searches <see cref="m_Text"/> for every match, and saves each match in <see cref="searchHits"/>.
        /// </summary>
        /// <param name="criteria">Search options.</param>
        /// <param name="regx">Used if <see cref="criteria"/> specifies a regex search.</param>
        /// <param name="workingArea">Inspector View.</param>
        /// <param name="stopFirstMatch">Whether search should stop at first match.</param>
        /// <param name="focusTop">Whether match focus should be at the top of view.</param>
        private bool SearchTextEnhanced(SearchCriteria criteria, Regex regx, ref Rect workingArea, bool stopFirstMatch = false, bool focusTop = false)
        {
            var renderStartY = workingArea.y;
            var renderStartX = workingArea.x;

            _nrSearchHits = 0;
            searchHits.Clear();
            _activeSearchHitIdx = -1;

            bool doRepaint = false;

            float positionY = 0f;
            int accFragNr = 0;
            int accBlockNr = 0;
            int accIdx;
            int idx = 0;
            int len;

            var run = true;
            while (run && idx < m_Text.Length && ((idx, len) = BurstStringSearch.FindMatch(m_Text, criteria, regx, idx)).idx != -1)
            {
                if (stopFirstMatch) run = false;
                if (len <= 0)
                {
                    idx++;
                    continue;
                }
                int idxEnd = idx + len;

                // Find block + fragment match starts in:
                var blockStartInfo = _disassembler.GetBlockIdxFromTextIdx(idx, accBlockNr, blocksFragmentsPlain.Length-1);
                // search hit within a folded block => unfold block.
                if (_folded[blockStartInfo.idx]) FoldUnfoldBlock(blockStartInfo.idx);
                // Finds the accumulated fragment number of the first fragment in block
                accFragNr = GetFragNrFromBlockIdx(blockStartInfo.idx, accBlockNr, accFragNr, ref positionY);

                int fragNrStart;
                // Finds actual accumulated fragment we just reached and it's index
                (fragNrStart, accIdx) = GetFragNrFromEnhancedTextIdx(idx, blockStartInfo.idx, accFragNr, blockStartInfo.l, ref positionY);

                var frag1Text = GetPlainFragments(blockStartInfo.idx)[fragNrStart - accFragNr].text;

                // Make idx relative to fragment:
                int idxStartInFrag1 = idx - accIdx;
                int idxEndInFrag1  = Math.Min(idxStartInFrag1 + len, frag1Text.Length);

                // positionY should be stationed at top of fragment we have hit in.
                // Need to push it down to the specific line the hit is in. But keep this in a temporary variable so as to not fuck up the property of positionY!!!
                int exactLineNr = BurstStringSearch.FindLineNr(frag1Text, idxStartInFrag1);
                float exactPositionY = positionY + exactLineNr * fontHeight;

                // Find block + fragment match ends in:
                var blockEndInfo = _disassembler.GetBlockIdxFromTextIdx(idxEnd, blockStartInfo.idx, blocksFragmentsPlain.Length-1);
                // Finds the accumulated fragment number of match's last fragment
                accFragNr = GetFragNrFromBlockIdx(blockEndInfo.idx, blockStartInfo.idx, accFragNr, ref positionY);
                int fragNrEnd;
                // Finds the actual accumulated fragment number of match last fragment
                (fragNrEnd, accIdx) = GetFragNrFromEnhancedTextIdx(idxEnd, blockEndInfo.idx, accFragNr, blockEndInfo.l, ref positionY);

                accBlockNr = blockEndInfo.idx;

                if (!searchHits.ContainsKey(fragNrStart)) searchHits.Add(fragNrStart, new List<(int startIdx, int endIdx, int nr)>());
                searchHits[fragNrStart].Add((idxStartInFrag1, idxEndInFrag1, _nrSearchHits));

                if (fragNrStart < fragNrEnd)
                {
                    // match span multiple fragments
                    fragNrStart++; // Already captured this fragment

                    // For every fragment in-between first and last we capture the whole fragment
                    for (; fragNrStart < fragNrEnd; fragNrStart++)
                    {
                        if (!searchHits.ContainsKey(fragNrStart)) searchHits.Add(fragNrStart, new List<(int startIdx, int endIdx, int nr)>());
                        searchHits[fragNrStart].Add((0, int.MaxValue, _nrSearchHits)); // Max value to indicate it's the entire fragment
                    }
                    int idxStartInFragN = accIdx;
                    int idxEndInFragN = idxEnd - idxStartInFragN;

                    if (!searchHits.ContainsKey(fragNrStart)) searchHits.Add(fragNrStart, new List<(int startIdx, int endIdx, int nr)>());
                    searchHits[fragNrStart].Add((0, idxEndInFragN, _nrSearchHits));
                }

                if (_activeSearchHitIdx < 0 && exactPositionY >= renderStartY)
                {
                    workingArea = SetScrollOnView(workingArea, frag1Text, exactLineNr, idxStartInFrag1, renderStartX, exactPositionY);
                    doRepaint = true;
                }
                idx += len;
                _nrSearchHits++;
            }
            return doRepaint;
        }

        private Rect SetScrollOnView(Rect workingArea, string text, int lineNr, int matchIdx, float renderStartX, float goToPosY)
        {
            _activeSearchHitIdx = _nrSearchHits;
            // Make it scroll to this hit
            var startOfLine = lineNr > 0 ? GetEndIndexOfPlainLine(text, lineNr - 1).total + 1 : 0;


            float positionX = matchIdx - startOfLine;
            if (positionX * fontWidth > renderStartX) positionX += matchIdx + 3 * fontWidth;
            else positionX -= 3 * fontWidth;

            workingArea.x = positionX;
            workingArea.y = goToPosY + 5 * fontHeight;

            return workingArea;
        }

        /// <remarks>Works on non-colored text.</remarks>
        /// <param name="goal">Index we want fragment number from.</param>
        /// <param name="blockNrStart">Block to start search in.</param>
        /// <param name="fragNrStart">Accumulated fragment number of <see cref="blockNrStart"/>.</param>
        /// <param name="start">Start index of <see cref="blockNrStart"/>.</param>
        /// <returns>(accumulated fragment number, total index for returning fragment number)</returns>
        internal (int fragNr, int idx) GetFragNrFromEnhancedTextIdx(int goal, int blockNrStart, int fragNrStart, int start, ref float positionY)
        {
            bool goThroughfrags(int goal, int blockIdx, ref int start, ref int f, ref float positionY)
            {
                var frags = GetPlainFragments(blockIdx);
                for (int i = 0; i < frags.Count; i++)
                {
                    Fragment frag = frags[i];
                    int len = frag.text.Length;
                    if (start + len >= goal)
                    {
                        return true;
                    }
                    start += len + 1; // +1 because of newline
                    f++;
                    positionY += frag.lineCount * fontHeight;
                }
                return false;
            }

            int f = fragNrStart;

            for (int b = blockNrStart; b < blocksFragmentsPlain.Length; b++)
            {
                if (goThroughfrags(goal, b, ref start, ref f, ref positionY)) break;
            }

            return (f, start);
        }

        /// <returns>(accumulated fragment number, total index for returning fragment number)</returns>
        private (int fragNr, int idx) GetFragNrFromPlainTextIdx(int goal, int fragNrStart, int start, ref float positionY)
        {
            int i = fragNrStart;
            for (; i < m_Fragments.Count; i++)
            {
                Fragment frag = m_Fragments[i];

                int len = frag.text.Length;
                if (start + len >= goal)
                {
                    break;
                }
                start += len + 1; // +1 because of newline
                positionY += frag.lineCount * fontHeight;
            }

            return (i, start);
        }

        private bool SearchTextPlain(SearchCriteria criteria, Regex regx, ref Rect workingArea, bool stopFirstMatch = false, bool focusTop = false)
        {
            var renderStartX = workingArea.x;
            var renderStartY = workingArea.y;

            _nrSearchHits = 0;
            searchHits.Clear();
            _activeSearchHitIdx = -1;

            bool doRepaint = false;

            float positionY = 0f;
            int idx = 0;
            int len;
            int accFragNr = 0;
            int accFragIdx = 0;
            var run = true;
            while (run && idx < m_Text.Length && ((idx, len) = BurstStringSearch.FindMatch(m_Text, criteria, regx, idx)).idx != -1)
            {
                if (stopFirstMatch) run = false;
                if (len <= 0)
                {
                    idx++;
                    continue;
                }
                int idxEnd = idx + len;

                // Find fragment match start in:
                (accFragNr, accFragIdx) = GetFragNrFromPlainTextIdx(idx, accFragNr, accFragIdx, ref positionY);
                int fragNrStart = accFragNr;

                string frag1Text = m_Fragments[fragNrStart].text;

                // Get relative index in fragment:
                int idxStartInFrag1 = idx - accFragIdx;
                int idxEndInFrag1 = Math.Min(idxStartInFrag1 + len, frag1Text.Length);

                int exactLineNr = BurstStringSearch.FindLineNr(frag1Text, idxStartInFrag1);
                float exactPositionY = positionY + exactLineNr * fontHeight;

                // Find fragment match end in:
                (accFragNr, accFragIdx) = GetFragNrFromPlainTextIdx(idxEnd, accFragNr, accFragIdx, ref positionY);
                int fragNrEnd = accFragNr;


                if (!searchHits.ContainsKey(fragNrStart)) searchHits.Add(fragNrStart, new List<(int startIdx, int endIdx, int nr)>());
                searchHits[fragNrStart].Add((idxStartInFrag1, idxEndInFrag1, _nrSearchHits));

                if (fragNrStart < fragNrEnd)
                {
                    // They must directly follow each other
                    int fragNr = fragNrStart + 1;
                    for (; fragNr < fragNrEnd; fragNr++)
                    {
                        if (!searchHits.ContainsKey(fragNr)) searchHits.Add(fragNr, new List<(int startIdx, int endIdx, int nr)>());
                        searchHits[fragNr].Add((0, m_Fragments[fragNr].text.Length, _nrSearchHits));
                    }

                    int idxStartInFrag2 = idxEnd - accFragIdx;
                    int idxEndInFrag2 = idxEnd - accFragIdx;

                    if (!searchHits.ContainsKey(fragNr)) searchHits.Add(fragNr, new List<(int startIdx, int endIdx, int nr)>());
                    searchHits[fragNr].Add((idxStartInFrag2, idxEndInFrag2, _nrSearchHits));
                }

                if (_activeSearchHitIdx < 0 && exactPositionY >= renderStartY)
                {
                    workingArea = SetScrollOnView(workingArea, frag1Text, exactLineNr, idxStartInFrag1, renderStartX, exactPositionY);
                    // ScrollToDuringRepaint(frag1Text, exactLineNr, idxStartInFrag1, len, renderStartX, exactPositionY, workingArea.height, focusTop);
                    doRepaint = true;
                }
                idx += len;
                _nrSearchHits++;
            }
            return doRepaint;
        }

        private void LayoutPlain(GUIStyle style)
        {
            foreach (var frag in m_Fragments)
            {
                // Calculate the size as we have hidden control codes in the string
                var size = style.CalcSize(new GUIContent(frag.text));
                finalAreaSize.x = Math.Max(finalAreaSize.x, size.x);
                finalAreaSize.y += frag.lineCount * fontHeight;
            }
        }

        private void AddFoldedStringColorless(int blockIdx)
        {
            if (_blocksFragmentsStartPlain[blockIdx].lineCount != 0) return;

            string text = null;
            if (!_disassembler.IsColored)
            {
                _blocksFragments[blockIdx] ??= RecomputeFragmentsFromBlock(blockIdx);
                text = _blocksFragments[blockIdx][0].text;
            }
            else
            {
                text = GetPlainFragments(blockIdx)[0].text;
            }
            var endOfFirstLineIdx = text.IndexOf('\n');
            if (endOfFirstLineIdx == -1) endOfFirstLineIdx = text.Length;

            _blocksFragmentsStartPlain[blockIdx] = new Fragment() { lineCount = 1, text = text.Substring(0, endOfFirstLineIdx) + " ..." };
        }

        private void AddFoldedString(int blockIdx)
        {
            if (_blocksFragmentsStart[blockIdx].lineCount != 0) return;

            // precomputing every block to avoid having runtime check at every access later on
            _blocksFragments[blockIdx] ??= RecomputeFragmentsFromBlock(blockIdx);

            // precompute string to present for folded block.
            var text = _blocksFragments[blockIdx][0].text;

            var endOfFirstLineIdx = text.IndexOf('\n');
            if (endOfFirstLineIdx == -1) endOfFirstLineIdx = text.Length;

            _blocksFragmentsStart[blockIdx] = new Fragment() { lineCount = 1, text = text.Substring(0, endOfFirstLineIdx) + " ..." };
        }

        internal void LayoutEnhanced(GUIStyle style, Rect workingArea, bool showBranchMarkers)
        {
            Vector2 scrollPos = workingArea.position;
            if (showBranchMarkers != _oldShowBranchMarkers)
            {
                // need to alter selection according to padding on x-axis.
                if (showBranchMarkers)
                {
                    selectPos.x += (horizontalPad - naturalEnhancedPad);
                    selectDragPos.x += (horizontalPad - naturalEnhancedPad);
                }
                else
                {
                    selectPos.x -= (horizontalPad - naturalEnhancedPad);
                    selectDragPos.x -= (horizontalPad - naturalEnhancedPad);
                }
                // register cache needs to be cleared:
                _lineRegCache.Clear();
            }
            _oldShowBranchMarkers = showBranchMarkers;

            // Also computes the first and last blocks to render this time and ensures
            float positionY = 0.0f;
            int lNum = 0;
            _renderBlockStart = -1;
            _renderBlockEnd = -1;

            _selectBlockStart = -1;
            _selectStartY = -1f;
            _selectBlockEnd = -1;
            _selectEndY = -1f;

            for (int idx = 0; idx<_disassembler.Blocks.Count; idx++)
            {
                var block = _disassembler.Blocks[idx];
                var blockHeight = block.Length * fontHeight;
                var lHeight = block.Length;

                if (_folded[idx])
                {
                    blockHeight = fontHeight;
                    lHeight = 1;
                }

                blockLine[idx] = lNum;

                if (_selectBlockStart == -1 && selectPos.y - blockHeight <= positionY)
                {
                    _selectBlockStart = idx;
                    _selectStartY = positionY;
                }
                if (_selectBlockEnd == -1 && (selectDragPos.y - blockHeight <= positionY || idx == _disassembler.Blocks.Count - 1))
                {
                    _selectBlockEnd = idx;
                    _selectEndY = positionY;
                }

                // Whole block is above view, or block starts below view.
                // If at last block and _renderBlockStart == -1, we must have had all block above our scrollPos.
                // Happens when Scroll view is at bottom and fontSize is decreased. As this forces the scroll view upwards,
                // we simply set the last block as the one being rendered (avoids an indexOutOfBounds exception).
                if (((positionY - scrollPos.y + blockHeight) < 0 || (positionY - scrollPos.y) > workingArea.size.y)
                    && !(idx == _disassembler.Blocks.Count - 1 && _renderBlockStart == -1))
                {
                    positionY += blockHeight;
                    lNum += lHeight;
                    continue;
                }

                if (_renderBlockStart == -1)
                {
                    _renderBlockStart = idx;
                    _renderStartY = positionY;
                }

                _renderBlockEnd = idx;

                if (_blocksFragments[idx] == null)
                {
                    AddFoldedString(idx);

                    foreach (var fragment in _blocksFragments[idx])
                    {
                        style.CalcMinMaxWidth(new GUIContent(fragment.text), out _, out var maxWidth);
                        if (finalAreaSize.x < maxWidth)
                        {
                            finalAreaSize.x = maxWidth;
                        }
                    }
                }

                positionY += blockHeight;
                lNum += lHeight;
            }
            // selection is below last line of assembly.
            if (_selectBlockStart == -1)
            {
                _selectBlockStart = _disassembler.Blocks.Count - 1;
            }
        }

        internal string GetStartingColorTag(int blockIdx, int textIdx)
        {
            if (!CopyColorTags || !(_disassembler?.IsColored ?? false)) return "";

            const int colorTagLength = 15;

            var text = _folded[blockIdx]
                ? GetFragmentStart(blockIdx).text// _blocksFragmentsStart[blockIdx].text
                : _disassembler.GetOrRenderBlockToText(blockIdx);

            var colorTagIdx = text.LastIndexOf("<color=", textIdx);
            if (colorTagIdx == -1) return "";

            // Checking that found tas is actually for this idx
            return text.IndexOf("</color>", colorTagIdx, textIdx - colorTagIdx) == -1
                ? text.Substring(colorTagIdx, colorTagLength)
                : "";
        }

        internal string GetEndingColorTag(int blockIdx, int textIdx)
        {
            if (!CopyColorTags || !(_disassembler?.IsColored ?? false)) return "";

            var text = _folded[blockIdx]
                ? GetFragmentStart(blockIdx).text// _blocksFragmentsStart[blockIdx].text
                : _disassembler.GetOrRenderBlockToText(blockIdx);

            var endColorTagIdx = text.IndexOf("</color>", textIdx);
            if (endColorTagIdx == -1) return "";

            // Check that tag actually belongs for thid idx
            return text.IndexOf("<color=", textIdx, endColorTagIdx - textIdx) == -1
                ? "</color>"
                : "";
        }

        internal void ChangeCopyMode()
        {
            CopyColorTags = !CopyColorTags;

            // Need to update text selection fields as it should now ignore/use color tags
            _textSelectionIdxValid = false;
            UpdateEnhancedSelectTextIdx(_oldShowBranchMarkers ? horizontalPad : naturalEnhancedPad);
        }

        internal void DoSelectionCopy()
        {
            // textIdxE = -1 to indicate we want till the end of the block of text.
            string GetStringFromBlock(int blockIdx, int textIdxS, int textIdxE = -1)
            {
                string text;
                if (_folded[blockIdx])
                {
                    text = (CopyColorTags
                        ? GetFragmentStart(blockIdx).text
                        : GetFragmentStartPlain(blockIdx).text)
                        + '\n';

                    return textIdxE == -1
                        ? text.Substring(textIdxS, text.Length - textIdxS)
                        : text.Substring(textIdxS, textIdxE - textIdxS);
                }

                if (CopyColorTags)
                {
                    text = _disassembler.GetOrRenderBlockToText(blockIdx);
                    if (textIdxE == -1) textIdxE = text.Length;
                }
                else
                {
                    text = m_Text;

                    // Transform textIdxS and textIdxE to absolute index into m_Text
                    var (blockStart, blockEnd) = _disassembler.BlockIdxs[blockIdx];
                    textIdxS += blockStart;
                    if (textIdxE == -1) textIdxE = blockEnd + 1; // +1 to take newline as well
                    else                textIdxE += blockStart;
                }

                return text.Substring(textIdxS, textIdxE - textIdxS);
            }

            if (!HasSelection) return;

            var sb = new StringBuilder();

            if (_disassembler != null && enhancedTextSelectionIdxStart != enhancedTextSelectionIdxEnd)
            {
                if (enhancedTextSelectionIdxStart.blockIdx < enhancedTextSelectionIdxEnd.blockIdx)
                {
                    // Multiple block selection
                    var blockIdx = enhancedTextSelectionIdxStart.blockIdx;

                    sb.Append(
                        GetStartingColorTag(enhancedTextSelectionIdxStart.blockIdx, enhancedTextSelectionIdxStart.textIdx) +
                        GetStringFromBlock(blockIdx++, enhancedTextSelectionIdxStart.textIdx));

                    for (; blockIdx < enhancedTextSelectionIdxEnd.blockIdx; blockIdx++)
                    {
                        sb.Append(GetStringFromBlock(blockIdx, 0));
                    }

                    sb.Append(
                        GetStringFromBlock(blockIdx, 0, enhancedTextSelectionIdxEnd.textIdx) +
                        GetEndingColorTag(enhancedTextSelectionIdxEnd.blockIdx, enhancedTextSelectionIdxEnd.textIdx));
                }
                else
                {
                    // Single block selection
                    sb.Append(
                        GetStartingColorTag(enhancedTextSelectionIdxStart.blockIdx, enhancedTextSelectionIdxStart.textIdx) +
                        GetStringFromBlock(
                            enhancedTextSelectionIdxStart.blockIdx,
                            enhancedTextSelectionIdxStart.textIdx,
                            enhancedTextSelectionIdxEnd.textIdx) +
                        GetEndingColorTag(enhancedTextSelectionIdxEnd.blockIdx, enhancedTextSelectionIdxEnd.textIdx));
                }
            }
            else
            {
                sb.Append(m_Text.Substring(textSelectionIdx.idx, textSelectionIdx.length));
            }
            EditorGUIUtility.systemCopyBuffer = sb.ToString();
        }

        internal void SelectAll()
        {
            HasSelection = true;
            selectPos = Vector2.zero;
            selectDragPos = finalAreaSize;

            if (_disassembler != null)
            {
                enhancedTextSelectionIdxStart = (0, 0);
                var blockIdx = _disassembler.Blocks.Count - 1;

                enhancedTextSelectionIdxEnd.blockIdx = blockIdx;
                // Make sure selection works on appropriate text:
                enhancedTextSelectionIdxEnd.textIdx = _folded[blockIdx]
                    ? CopyColorTags
                        ? GetFragmentStart(blockIdx).text.Length
                        : GetFragmentStartPlain(blockIdx).text.Length
                    : CopyColorTags
                        ? _disassembler.GetOrRenderBlockToText(blockIdx).Length
                        : _disassembler.BlockIdxs[blockIdx].endIdx - _disassembler.BlockIdxs[blockIdx].startIdx;

                _selectBlockStart = 0;
                _selectBlockEnd = blockIdx;
                _selectEndY = finalAreaSize.y -
                              (_folded[blockIdx] ? fontHeight : _disassembler.Blocks[blockIdx].Length * fontHeight);
            }
            else
            {
                textSelectionIdx = (0, m_Text.Length);
            }
            _textSelectionIdxValid = true;
        }

        private void ScrollDownToSelection(Rect workingArea)
        {
            if (!workingArea.Contains(selectDragPos + new Vector2(fontWidth, fontHeight / 2)))
            {
                GUI.ScrollTo(new Rect(selectDragPos + new Vector2(fontWidth, fontHeight), Vector2.zero));
            }

            _textSelectionIdxValid = false;
        }

        private void ScrollUpToSelection(Rect workingArea)
        {
            if (!workingArea.Contains(selectDragPos - new Vector2(0, fontHeight / 2)))
            {
                GUI.ScrollTo(new Rect(selectDragPos - new Vector2(0, fontHeight), Vector2.zero));
            }

            _textSelectionIdxValid = false;
        }


        internal void MoveSelectionLeft(Rect workingArea, bool showBranchMarkers)
        {
            HasSelection = true;
            if (_disassembler != null)
            {
                float hPad = showBranchMarkers ? horizontalPad : naturalEnhancedPad;
                string text;
                int prevLineIdx = Mathf.FloorToInt((selectDragPos.y - _selectEndY) / fontHeight) - 1;

                if (selectDragPos.x < hPad + fontWidth)
                {
                    if (prevLineIdx < 0 && _selectBlockEnd == 0)
                    {
                        // we are at the beginning of the text.
                        return;
                    }

                    if (prevLineIdx < 0 && _selectBlockEnd > 0)
                    {
                        // get text from previous block, and do calculations for that.
                        _selectBlockEnd--;
                        _selectEndY -= _folded[_selectBlockEnd]
                            ? fontHeight
                            : _disassembler.Blocks[_selectBlockEnd].Length * fontHeight;

                        (text, prevLineIdx) = !_folded[_selectBlockEnd]
                            ? (_disassembler.GetOrRenderBlockToText(_selectBlockEnd), _disassembler.Blocks[_selectBlockEnd].Length - 1)
                            : (GetFragmentStart(_selectBlockEnd).text + '\n', 0);
                    }
                    else
                    {
                        text = _folded[_selectBlockEnd]
                            ? GetFragmentStart(_selectBlockEnd).text + '\n'
                            : _disassembler.GetOrRenderBlockToText(_selectBlockEnd);
                    }
                    var charsInLine = GetEndIndexOfColoredLine(text, prevLineIdx).relative;

                    selectDragPos.x = charsInLine * fontWidth + hPad + fontWidth / 2;
                    selectDragPos.y -= fontHeight;
                }
                else
                {
                    // simply move selection left.
                    text = _folded[_selectBlockEnd]
                        ? GetFragmentStart(_selectBlockEnd).text + '\n'
                        : _disassembler.GetOrRenderBlockToText(_selectBlockEnd);
                    var charsInLine = GetEndIndexOfColoredLine(text, prevLineIdx + 1).relative;

                    if (selectDragPos.x > charsInLine * fontWidth + hPad)
                        selectDragPos.x = hPad + charsInLine * fontWidth + fontWidth / 2;

                    selectDragPos.x -= fontWidth;
                }
            }
            else
            {
                int prevLineIdx = Mathf.FloorToInt((selectDragPos.y) / fontHeight) - 1;

                if (selectDragPos.x < fontWidth)
                {
                    if (prevLineIdx < 0)
                    {
                        // we are at beginning of the text
                        return;
                    }

                    int charsInLine = GetEndIndexOfPlainLine(m_Text, prevLineIdx).relative;

                    selectDragPos.x = charsInLine * fontWidth + fontWidth / 2;
                    selectDragPos.y -= fontHeight;
                }
                else
                {
                    // simply move selection left.
                    int charsInLine = GetEndIndexOfPlainLine(m_Text, prevLineIdx+1).relative;
                    if (selectDragPos.x > charsInLine * fontWidth)
                    {
                        selectDragPos.x = charsInLine * fontWidth + fontWidth / 2;
                    }

                    selectDragPos.x -= fontWidth;
                }
            }

            // check if we moved outside of view and scroll if true.
            ScrollUpToSelection(workingArea);
        }

        internal void MoveSelectionRight(Rect workingArea, bool showBranchMarkers)
        {
            HasSelection = true;
            if (_disassembler != null)
            {
                var hPad = showBranchMarkers ? horizontalPad : naturalEnhancedPad;

                var text     = _folded[_selectBlockEnd]
                    ? GetFragmentStart(_selectBlockEnd).text + '\n'
                    : _disassembler.GetOrRenderBlockToText(_selectBlockEnd);

                var thisLine    = Mathf.FloorToInt((selectDragPos.y - _selectEndY) / fontHeight);
                var charsInLine = GetEndIndexOfColoredLine(text, thisLine).relative;

                if (selectDragPos.x >= hPad + charsInLine * fontWidth)
                {
                    // move down a line:
                    thisLine++;

                    int lineCount = _folded[_selectBlockEnd] ? 1 : _disassembler.Blocks[_selectBlockEnd].Length;

                    if (thisLine > lineCount && _selectBlockEnd == _disassembler.Blocks.Count - 1)
                    {
                        // We are at the end of the text
                        return;
                    }

                    if (thisLine > lineCount)
                    {
                        // selected into next block.
                        _selectBlockEnd++;
                        _selectEndY += _folded[_selectBlockEnd - 1]
                            ? fontHeight
                            : _disassembler.Blocks[_selectBlockEnd - 1].Length * fontHeight;
                    }

                    selectDragPos.x = hPad + fontWidth/2;
                    selectDragPos.y += fontHeight;
                }
                else
                {
                    // simply move selection right.
                    if (selectDragPos.x < hPad)
                    {
                        selectDragPos.x = hPad + fontWidth / 2;
                    }

                    selectDragPos.x += fontWidth;
                }
            }
            else
            {
                int thisLine = Mathf.FloorToInt((selectDragPos.y) / fontHeight);

                int charsInLine = GetEndIndexOfColoredLine(m_Text, thisLine).relative;

                if (selectDragPos.x >= charsInLine*fontWidth)
                {
                    thisLine++;

                    if (thisLine >= _mTextLines)
                    {
                        // we are at end of the text
                        return;
                    }

                    selectDragPos.x = 0f;
                    selectDragPos.y += fontHeight;

                }
                else
                {
                    // simply move selection right.
                    selectDragPos.x += fontWidth;
                }
            }
            // check if we moved outside of view and scroll if true.
            ScrollDownToSelection(workingArea);
        }

        internal void MoveSelectionUp(Rect workingArea, bool showBranchMarkers)
        {
            HasSelection = true;
            if (_disassembler != null)
            {
                int thisLine = Mathf.FloorToInt((selectDragPos.y - _selectEndY) / fontHeight);

                // At the first line
                if (thisLine == 0 && _selectBlockEnd == 0) return;

                if (thisLine == 0)
                {
                    // We are moving on to a block above
                    _selectBlockEnd--;
                    _selectEndY -= _folded[_selectBlockEnd]
                        ? fontHeight
                        : _disassembler.Blocks[_selectBlockEnd].Length * fontHeight;
                }
            }
            else
            {
                int thisLine = Mathf.FloorToInt((selectDragPos.y) / fontHeight) - 1;

                if (thisLine < 0) return;
            }

            selectDragPos.y -= fontHeight;

            // check if we moved outside of view and scroll if true.
            ScrollUpToSelection(workingArea);
        }

        internal void MoveSelectionDown(Rect workingArea, bool showBranchMarkers)
        {
            HasSelection = true;
            if (_disassembler != null)
            {
                int thisLine = Mathf.FloorToInt((selectDragPos.y - _selectEndY) / fontHeight) + 1;

                int lineCount = _folded[_selectBlockEnd] ? 0 : _disassembler.Blocks[_selectBlockEnd].Length - 1;

                if (thisLine > lineCount)
                {
                    // At the last line
                    if (_selectBlockEnd == _disassembler.Blocks.Count - 1) { return; }

                    // Moved into next block
                    _selectBlockEnd++;
                    _selectEndY += _folded[_selectBlockEnd - 1]
                        ? fontHeight
                        : _disassembler.Blocks[_selectBlockEnd - 1].Length * fontHeight;
                }
            }
            else
            {
                int thisLine = Mathf.FloorToInt(selectDragPos.y / fontHeight) + 1;

                if (thisLine > _mTextLines) return;
            }

            selectDragPos.y += fontHeight;

            // check if we moved outside of view and scroll if true.
            ScrollDownToSelection(workingArea);
        }

        internal bool MouseOutsideView(Rect workingArea, Vector2 mousePos, int controlID)
        {
            if (!workingArea.Contains(mousePos))
            {
                if (GUIUtility.hotControl == controlID && Event.current.rawType == EventType.MouseUp)
                {
                    _mouseDown = false;
                }

                _mouseOutsideBounds = true;
                return true;
            }

            _mouseOutsideBounds = false;
            return false;
        }

        private Vector2 MouseClickAndClamp(bool showBranchMarkers, Vector2 mousePos)
        {
            HasSelection = true;
            if (_disassembler != null)
            {
                float hPad = showBranchMarkers ? horizontalPad : naturalEnhancedPad;

                // Make sure we cannot set cursor in the horizontal padding:
                if (mousePos.x < hPad) mousePos.x = hPad;
            }
            return mousePos;
        }

        private int GetLineNumber(Vector2 mousePos)
        {
            var lineNumber = Mathf.FloorToInt(mousePos.y / fontHeight);
            var len = _disassembler.Blocks.Count;
            for (var idx = 0; idx < len; idx++)
            {
                var block = _disassembler.Blocks[idx];
                if (lineNumber <= block.LineIndex)
                {
                    break;
                }
                if (_folded[idx])
                {
                    lineNumber += block.Length - 1;
                }
            }
            return lineNumber;
        }
        internal void MouseClicked(bool showBranchMarkers, bool withShift, Vector2 mousePos, int controlID)
        {
            if (_mouseOutsideBounds || mousePos.y > finalAreaSize.y) { return; }

            GUIUtility.hotControl = controlID;
            // FocusControl is to take keyboard focus away from the TreeView.
            GUI.FocusControl("long text");
            if (withShift)
            {
                mousePos = MouseClickAndClamp(showBranchMarkers, mousePos);

                selectDragPos = mousePos;
                _textSelectionIdxValid = false;
            }
            else
            {
                selectDragPos = mousePos;
                StopSelection();
            }
            _mouseDown = true;
        }


        internal void DragMouse(Vector2 mousePos, bool showBranchMarkers)
        {
            if (!_mouseDown || mousePos.y > finalAreaSize.y) { return; }

            mousePos = MouseClickAndClamp(showBranchMarkers, mousePos);

            selectDragPos = mousePos;
            _textSelectionIdxValid = false;
        }

        internal void MouseReleased()
        {
            GUIUtility.hotControl = 0;
            _mouseDown = false;
        }

        internal void DoScroll(Rect workingArea, float mouseRelMoveY)
        {
            if (!_mouseDown) { return; }

            var movingDown = mouseRelMoveY > 0;

            var room = Mathf.Max(0, movingDown
                ? finalAreaSize.y - workingArea.yMax
                : workingArea.yMin);

            // naturalEnhancedPad magic number taken from unity engine (GUI.cs under EndScrollView).
            var dist = Mathf.Min(Mathf.Abs(mouseRelMoveY * naturalEnhancedPad), room);
            selectDragPos.y += movingDown ? dist : -dist;

            _textSelectionIdxValid = false;
        }

        public void MoveView(Direction dir, Rect workingArea)
        {
            switch (dir)
            {
                case Direction.Left:
                    GUI.ScrollTo(new Rect(workingArea.xMin - 2*fontWidth, workingArea.y, 0, 0));
                    break;

                case Direction.Right:
                    GUI.ScrollTo(new Rect(workingArea.xMax + 2*fontWidth, workingArea.y, 0, 0));
                    break;

                case Direction.Up:
                    GUI.ScrollTo(new Rect(workingArea.x, workingArea.yMin - 2*fontWidth, 0, 0));
                    break;

                case Direction.Down:
                    GUI.ScrollTo(new Rect(workingArea.x, workingArea.yMax + 2*fontWidth, 0, 0));
                    break;
            }
        }

        public void StopSelection()
        {
            selectPos = selectDragPos;
            textSelectionIdx = (0, 0);
            _textSelectionIdxValid = true;
            HasSelection = false;
        }



        /// <summary>
        /// Renders a blue box relative to text at (positionX, positionY) from start idx to end idx.
        /// </summary>
        private void RenderLineSelection(float positionX, float positionY, int start, int end, bool IsSelection = true)
        {
            const int alignmentPad = 2;
            var oldColor = GUI.color;
            GUI.color = IsSelection ? _selectionColor : _searchHitColor;
            GUI.Box(new Rect(positionX + alignmentPad + start*fontWidth, positionY, (end - start)*fontWidth, fontHeight), "", textureStyle);
            GUI.color = oldColor;
        }

        internal struct FragmentSelectionInfo
        {
            public float startY;
            public float lastY;
            public float botY;

            public int startLineEndIdxRel;
            public int startLine;
            public int lastLine;

            public int charsIn;
            public int charsInDrag;
        }

        internal FragmentSelectionInfo PrepareInfoForSelection(float positionX, float positionY, float fragHeight, Fragment frag, Func<string, int, (int total, int relative)> GetEndIndexOfLine)
        {
            const float distanceFromBorder = 0.001f;
            var text = frag.text;

            var top = selectPos;
            var bot = selectDragPos;
            if (selectPos.y > selectDragPos.y)
            {
                top = selectDragPos;
                bot = selectPos;
            }
            // fixing so we only look at things within this current fragment.
            var start = top.y < positionY ? new Vector2(positionX, positionY) : top;
            // `y = ... - adjustBottomSlightly` so it is within current fragments outer "border".
            var last = bot.y < positionY + fragHeight ? bot : new Vector2(finalAreaSize.x, positionY + fragHeight - distanceFromBorder);

            // Make sure this cannot go beyond number of lines in fragment (zero indexed).
            var startLine = Math.Min(Mathf.FloorToInt((start.y - positionY) / fontHeight), frag.lineCount-1);
            var lastLine = Math.Min(Mathf.FloorToInt((last.y - positionY) / fontHeight), frag.lineCount-1);

            if (startLine == lastLine && start.x > last.x)
                (start, last) = (last, start);

            // Used for making sure charsIn and charsInDrag does not exceed line length.
            var (_, startLineEndIdxRel) = GetEndIndexOfLine(text, startLine);
            var (_, lastLineEndIdxRel) = GetEndIndexOfLine(text, lastLine);

            // Each fragment does not end on a newline, so we need to add one to idx.
            if (startLine == frag.lineCount - 1) startLineEndIdxRel++;
            if (lastLine == frag.lineCount - 1) lastLineEndIdxRel++;

            var charsIn = Math.Min(Mathf.FloorToInt((start.x - positionX) / fontWidth), startLineEndIdxRel);
            var charsInDrag = Math.Min(Mathf.FloorToInt((last.x - positionX) / fontWidth), lastLineEndIdxRel);
            charsIn = charsIn < 0 ? 0 : charsIn;
            charsInDrag = charsInDrag < 0 ? 0 : charsInDrag;

            return new FragmentSelectionInfo() {startY = start.y, lastY = last.y, botY = bot.y,
                startLineEndIdxRel = startLineEndIdxRel, startLine = startLine, lastLine = lastLine,
                charsIn = charsIn, charsInDrag = charsInDrag};
        }

        private void SelectText(float positionX, float positionY, float fragHeight, Fragment frag, Func<string, int, (int total, int relative)> GetEndIndexOfLine)
        {
            if (!HasSelection || !(BurstMath.WithinRange(selectPos.y, selectDragPos.y, positionY) ||
                                 BurstMath.WithinRange(selectPos.y, selectDragPos.y, positionY + fragHeight)
                                 || BurstMath.WithinRange(positionY, positionY + fragHeight, selectPos.y)))
            {
                return;
            }

            var inf = PrepareInfoForSelection(positionX, positionY, fragHeight, frag, GetEndIndexOfLine);
            var text = frag.text;

            if (BurstMath.RoundDownToNearest(inf.lastY, fontHeight) > BurstMath.RoundDownToNearest(inf.startY, fontHeight))
            {
                // Multi line selection in this text.
                int lineEndIdx = inf.startLineEndIdxRel;
                if (inf.startY != positionY)
                {
                    // Selection started in this fragment.
                    RenderLineSelection(positionX, positionY + (inf.startLine * fontHeight), inf.charsIn, lineEndIdx + 1);
                    inf.startLine++;
                }

                for (; inf.startLine < inf.lastLine; inf.startLine++)
                {
                    lineEndIdx = GetEndIndexOfLine(text, inf.startLine).relative;
                    RenderLineSelection(positionX, positionY + (inf.startLine * fontHeight), 0, lineEndIdx + 1);
                }

                if (positionY + fragHeight < inf.botY)
                {
                    // select going into next fragment
                    inf.charsInDrag++;
                }

                RenderLineSelection(positionX, positionY + (inf.startLine * fontHeight), 0, inf.charsInDrag);
            }
            else
            {
                // Single line selection in this text segment.
                int startIdx = inf.charsIn;
                int endIdx = inf.charsInDrag;
                if (inf.startY == positionY)
                {
                    // Selection started in text segment above.
                    startIdx = 0;
                }

                if (positionY + fragHeight < inf.botY)
                {
                    // Selection going into next text segment.
                    endIdx = inf.startLineEndIdxRel + 1;
                }

                RenderLineSelection(positionX, positionY + (inf.startLine * fontHeight), startIdx, endIdx);
            }
        }

        /// <summary>
        /// Updates _textSelectionIdx based on the position of _selectPos and _selectDragPos.
        /// </summary>
        /// <param name="GetEndIndexOfLine"> either  GetEndIndexOfPlainLine or GetEndIndexOfColoredLine</param>
        private void UpdateSelectTextIdx(Func<string, int, (int total, int relative)> GetEndIndexOfLine)
        {
            if (!_textSelectionIdxValid && HasSelection)
            {
                var start = selectPos;
                var last = selectDragPos;
                if (last.y < start.y)
                {
                    start = selectDragPos;
                    last = selectPos;
                }
                int startLine   = Mathf.FloorToInt(start.y / fontHeight);
                int lastLine    = Mathf.FloorToInt(last.y / fontHeight);

                if (startLine == lastLine && start.x > last.x)
                {
                    (start, last) = (last, start);
                }

                var (startLineEndIdxTotal, startLineEndIdxRel) = GetEndIndexOfLine(m_Text, startLine);
                var (lastLineEndIdxTotal, lastLineEndIdxRel) = GetEndIndexOfLine(m_Text, lastLine);

                int charsIn = Math.Min(Mathf.FloorToInt(start.x / fontWidth), startLineEndIdxRel);
                int charsInDrag = Math.Min(Mathf.FloorToInt(last.x / fontWidth), lastLineEndIdxRel);
                charsIn = charsIn < 0 ? 0 : charsIn;
                charsInDrag = charsInDrag < 0 ? 0 : charsInDrag;

                int selectStartIdx = startLineEndIdxTotal - (startLineEndIdxRel - charsIn);
                textSelectionIdx = (selectStartIdx, lastLineEndIdxTotal - (lastLineEndIdxRel - charsInDrag) - selectStartIdx);

                _textSelectionIdxValid = true;
            }
        }

        public void NextSearchHit(bool shift, Rect workingArea)
        {
            if (_nrSearchHits <= 0) return;

            // If shift is held down: Go backwards through active search
            _activeSearchHitIdx = shift
                ? (Math.Max(_activeSearchHitIdx, 0) - 1 + _nrSearchHits) % _nrSearchHits
                : (_activeSearchHitIdx + 1) % _nrSearchHits;

            // Find fragment number of _activeSearchHit
            var fragIdx = 0;
            int prevFragLastHitNr = -1;
            var activeSearchIdx = _activeSearchHitIdx;
            foreach (var key in searchHits.Keys)
            {
                var hits = searchHits[key];

                var nrHits = hits.Count;
                var hitsLastNr = hits.Last().nr;

                // If last hit continues into this fragment we subtracted too much
                if (hits.First().nr == prevFragLastHitNr) activeSearchIdx++;

                if (hitsLastNr >= _activeSearchHitIdx)
                {
                    fragIdx = key;
                    break;
                }
                activeSearchIdx -= nrHits;
                prevFragLastHitNr = hitsLastNr;
            }

            var hit = searchHits[fragIdx][activeSearchIdx];

            // Find y position of _activeSearchHit.
            int exactLineNumber;
            string text;
            var positionY = 0f;
            if (_disassembler == null)
            {
                int i = 0;
                for (; i < fragIdx; i++)
                {
                    positionY += m_Fragments[i].lineCount * fontHeight;
                }
                text = m_Fragments[i].text;
                exactLineNumber = BurstStringSearch.FindLineNr(text, hit.startIdx);
                positionY += exactLineNumber * fontHeight;
            }
            else
            {
                int blockIdx = 0;
                int innerFragIdx = 0;
                int tmpFragIdx = 0;

                for (; tmpFragIdx < fragIdx; blockIdx++)
                {
                    var frags = GetPlainFragments(blockIdx);

                    if (_folded[blockIdx])
                    {
                        positionY += fontHeight;
                        tmpFragIdx += frags.Count;
                    }
                    else
                    {
                        for (innerFragIdx = 0; ; innerFragIdx++, tmpFragIdx++)
                        {
                            if (innerFragIdx >= frags.Count)
                            {
                                innerFragIdx = 0;
                                break;
                            }
                            if (tmpFragIdx >= fragIdx) break;
                            positionY += frags[innerFragIdx].lineCount * fontHeight;

                        }
                    }
                    if (innerFragIdx != 0) break;
                }
                text = GetPlainFragments(blockIdx)[innerFragIdx].text;
                exactLineNumber = BurstStringSearch.FindLineNr(text, hit.startIdx);
                positionY += exactLineNumber * fontHeight;
            }

            int startOfLine = exactLineNumber > 0 ? GetEndIndexOfPlainLine(text, exactLineNumber-1).total + 1 : 0;
            int hitLength = hit.endIdx - hit.startIdx;

            float positionX = hit.startIdx - startOfLine;
            if (positionX * fontWidth > workingArea.x) positionX += hitLength + 3 * fontWidth;
            else positionX -= 3 * fontWidth;

            GUI.ScrollTo(new Rect(positionX * fontWidth + _actualHorizontalPad, positionY < workingArea.yMin ? positionY - 5 * fontHeight : positionY + 5 * fontHeight, 0, 0));
        }

        public void StopSearching()
        {
            _nrSearchHits = 0;
            searchHits.Clear();
            _activeSearchHitIdx = -1;
            _prevCriteria.filter = String.Empty;
        }

        private void RenderMultipleLinesSelection(string text, float positionX, float positionY, int startIdx, int endIdx, bool IsSelection = true)
        {
            int lineStart = BurstStringSearch.FindLineNr(text, startIdx);
            int lineEnd   = BurstStringSearch.FindLineNr(text, endIdx);

            // Make idx relative to line
            int startOfLine = lineStart == 0 ? 0 : GetEndIndexOfPlainLine(text, lineStart-1).total + 1;
            startIdx        = startIdx - startOfLine;

            startOfLine = lineEnd == 0 ? 0 : GetEndIndexOfPlainLine(text, lineEnd-1).total + 1;
            endIdx      = endIdx - startOfLine;


            positionY += (lineStart * fontHeight);

            if (lineStart == lineEnd)
            {
                RenderLineSelection(positionX, positionY, startIdx, endIdx, IsSelection);
            }
            else
            {
                int endOfLine = GetEndIndexOfPlainLine(text, lineStart).relative;
                RenderLineSelection(positionX, positionY, startIdx, endOfLine, IsSelection);
                lineStart++;
                positionY += fontHeight;

                for (; lineStart < lineEnd; lineStart++)
                {
                    endOfLine = GetEndIndexOfPlainLine(text, lineStart).relative;
                    RenderLineSelection(positionX, positionY, 0, endOfLine, IsSelection);
                    positionY += fontHeight;
                }

                RenderLineSelection(positionX, positionY, 0, endIdx, IsSelection);
            }
        }

        private void RenderPlainOldFragments(GUIStyle style, Rect workingArea, bool doSearch)
        {
            Vector2 scrollPos = workingArea.position;
            float positionY = 0.0f;
            for (int i = 0; i < m_Fragments.Count; i++)
            {
                // if fragment is below view
                if ((positionY - scrollPos.y) > workingArea.size.y) break;

                var fragment = m_Fragments[i];

                float fragHeight = fragment.lineCount * fontHeight;

                // if whole fragment is above view
                if ((positionY - scrollPos.y + fragHeight) < 0)
                {
                    positionY += fragHeight;
                    continue;
                }

                if (doSearch && searchHits.TryGetValue(i, out var lst))
                {
                    foreach (var (startI, endI, nr) in lst)
                    {
                        bool isActive = nr == _activeSearchHitIdx;
                        RenderMultipleLinesSelection(fragment.text, horizontalPad, positionY, startI, endI, isActive);
                    }
                }
                // we append \n here, as we want it for the selection but not the rendering.
                SelectText(horizontalPad, positionY, fragHeight, fragment, GetEndIndexOfPlainLine);

                GUI.Label(new Rect(horizontalPad, positionY, finalAreaSize.x, fragHeight + fontHeight*0.5f), fragment.text, style);
                positionY += fragHeight;
            }
            UpdateSelectTextIdx(GetEndIndexOfPlainLine);
        }

        /// <returns>Whether the GUI should be forced to repaint during this frame.</returns>
        public bool Render(GUIStyle style, Rect workingArea, bool showBranchMarkers, bool doSearch, SearchCriteria searchCriteria, Regex regx)
        {
            _actualHorizontalPad = showBranchMarkers ? horizontalPad : naturalEnhancedPad;
            style.richText = true;

            if (invalidated)
            {
                Layout(style, _actualHorizontalPad);
            }

            if (_disassembler != null)
            {
                // We always need to call this as its sets up the correct horizontal bar and block rendering
                LayoutEnhanced(style, workingArea, showBranchMarkers);
            }

            if (Event.current.type == EventType.Layout)
            {
                // working area will be valid only during repaint, for the layout event we don't draw the labels
                // Add correct size Rect to GUILayoutUtillity.topLevel for retrieval with next GetRect(.) call.
                GUILayoutUtility.GetRect(finalAreaSize.x + (showBranchMarkers ? horizontalPad : 20.0f), finalAreaSize.y);
                return false;
            }

            var newSearch = doSearch && (searchCriteria.filter != "" && !searchCriteria.Equals(_prevCriteria));
            _prevCriteria = searchCriteria;

            var doRepaint = false;
            if (newSearch)
            {
                doRepaint = SearchText(searchCriteria, regx, ref workingArea);
                if (doRepaint)
                {
                    // Search found at least one match, so move to the first
                    GUI.ScrollTo(workingArea);
                }
            }

            if (_disassembler == null)
            {
                RenderPlainOldFragments(style, workingArea, doSearch);
            }
            else
            {
                RenderEnhanced(style, workingArea, showBranchMarkers, _actualHorizontalPad, doSearch);
                RenderRegisterHighlight(workingArea, _actualHorizontalPad);
                RenderLineHighlight(_actualHorizontalPad);
            }

            DrawHover(style, workingArea);
            return doRepaint;
        }

        internal int GetLinesBlockIdx(int pressedLine)
        {
            // Find block that was pressed:
            var b = _renderBlockStart;
            var numBlocks = _blocksFragments.Length;
            for (; b <= _renderBlockEnd && b < numBlocks-1; b++)
            {
                var block = _disassembler.Blocks[b];
                if (block.LineIndex <= pressedLine && block.LineIndex + block.Length > pressedLine)
                {
                    break;
                }
            }

            return b;
        }

        internal Rect GetLineHighlight(ref LineRegRectsCache cache, float hPad, int pressedLine)
        {
            // Find block that was pressed:
            var b = GetLinesBlockIdx(pressedLine);

            if (cache.IsLineHighlightCached(pressedLine, _folded[b]))
            {
                // Same old line
                return cache.lineHighlight;
            }

            var pressedLineRel = pressedLine - _disassembler.Blocks[b].LineIndex;
            var positionY =
                    _renderStartY + (blockLine[b] - blockLine[_renderBlockStart] + pressedLineRel) * fontHeight;
            const float lineHeight = 2f;

            // Cannot use tokens in disassembler, as it's not updated with the proper output created by
            // RenderLine(.).
            var line = _disassembler.Lines[pressedLine];
            var lineStr = _folded[b] ? GetFragmentStartPlain(b).text : GetLineString(line);
            var xEnd = lineStr.Length * fontWidth;
            var xStart = hPad;
            var yPos = positionY + fontHeight;
            var rect = new Rect(xStart, yPos, xEnd, lineHeight);
            cache.UpdateLineHighlight(pressedLine, rect, _folded[b]);
            return rect;
        }

        private void RenderLineHighlight(float hPad)
        {
            if (_pressedLine == -1)
            {
                return;
            }
            var firstRenderedLine = _disassembler.Blocks[_renderBlockStart].LineIndex;
            var tmp = _disassembler.Blocks[_renderBlockEnd];
            var lastRenderedLine = tmp.LineIndex + tmp.Length;
            if (!BurstMath.WithinRange(firstRenderedLine, lastRenderedLine, _pressedLine))
            {
                return;
            }

            var col = GUI.color;
            GUI.color = _lineHighlightColor;
            GUI.Box(GetLineHighlight(ref _lineRegCache, hPad, _pressedLine), "", textureStyle);
            GUI.color = col;
        }

        internal LineRegRectsCache _lineRegCache;
        internal int _pressedLine = -1;

        private void RenderRegisterHighlight(Rect workingArea, float hPad)
        {
            if (_pressedLine == -1)
            {
                return;
            }

            if (_disassembler.LineUsesRegs(_pressedLine, out var usedRegs) && _disassembler.Lines[_pressedLine].Kind != BurstDisassembler.AsmLineKind.Directive)
            {
                var oldColor = GUI.color;
                var regRects = GetRegisterRects(hPad, ref _lineRegCache, _pressedLine, usedRegs);

                var i = 0;
                foreach (var rects in regRects)
                {
                    GUI.color = _regsColourWheel[i % _regsColourWheel.Length];
                    foreach (var rect in rects)
                    {
                        if (!workingArea.Contains(rect.position))
                        {
                            continue;
                        }
                        GUI.Box(rect, "", textureStyle);
                    }

                    i++;
                }
                GUI.color = oldColor;
            }
            else if (_pressedLine != _lineRegCache.chosenLine)
            {
                // We need to clear the cache, as we pressed somewhere new.
                // Alternatively we only need to do this if a fold changed, or the view changed!
                _lineRegCache.Clear();
            }
        }

        internal string GetLineString(BurstDisassembler.AsmLine line)
        {
            _disassembler._output.Clear();

            _disassembler.RenderLine(ref line, false);

            var str = _disassembler._output.ToString();
            _disassembler._output.Length = 0;
            return str;
        }

        private (int start, int end) FindBlockIdx(int startBlock, int firstLine, int lastLine)
        {
            var blockIdx = startBlock;
            for (; blockIdx > 0; blockIdx--)
            {
                if (blockLine[blockIdx] <= firstLine)
                {
                    break;
                }
            }

            var blockIdxEnd = _renderBlockEnd;
            for (; blockIdxEnd < _blocksFragments.Length - 1; blockIdxEnd++)
            {
                var bLen = _folded[blockIdxEnd]
                    ? 1
                    : _disassembler.Blocks[blockIdxEnd].Length;
                if (blockLine[blockIdxEnd] + bLen >= lastLine)
                {
                    break;
                }
            }

            return (blockIdx, blockIdxEnd);
        }

        /// <summary>
        /// Finds all usages of <see cref="regs"/> within view, and returns a list of <see cref="Rect"/>
        /// presenting these usages.
        /// </summary>
        /// <param name="hPad">Horizontal padding in text area.</param>
        /// <param name="cache">Cache handling saving register rects.</param>
        /// <param name="pressedLine">The currently selected line.</param>
        /// <param name="regs">Registers to match against.</param>
        /// <remarks>
        /// This will return representation of ALL matching registers within <see cref="workingArea"/>.
        ///
        /// Depends on:
        /// <list type="bullet">
        /// <item>
        /// <see cref="_burstDisassember"/>.
        /// </item>
        /// <item>
        /// <see cref="LayoutEnhanced"/> been called at least once before this.
        /// </item>
        /// </list>
        /// </remarks>
        internal List<Rect>[] GetRegisterRects(float hPad, ref LineRegRectsCache cache, int pressedLine, List<string> regs)
        {
            const int extraLines = 5;
            const float horizontalAlignmentPad = 2f;

            var firstLine = Math.Max(blockLine[_renderBlockStart] - extraLines, 0);
            var lastLine = blockLine[_renderBlockEnd] + (_folded[_renderBlockEnd]
                ? 1
                : _disassembler.Blocks[_renderBlockEnd].Length-1) + extraLines;

            var (blockIdx, blockIdxEnd) = FindBlockIdx(_renderBlockStart, firstLine, lastLine);

            var positionY = Math.Max(_renderStartY - (extraLines * fontHeight), 0);
            // Convert lineIdx to absolut indexes. Needed for _disassembler.Lines[...]
            for (var i = 0; i < blockIdxEnd; i++)
            {
                if (_folded[i])
                {
                    var len = _disassembler.Blocks[i].Length - 1;
                    if (i < blockIdx) { firstLine += len; }
                    lastLine += len;
                }
            }
            // Make sure LastLine does not exceed number of lines
            lastLine = Math.Min(lastLine, _disassembler.Lines.Count - 1);

            if (cache.IsRegisterCachedOrClear(pressedLine, firstLine, lastLine))
            {
                return cache.rects;
            }

            // Clean up regs, so e.g. "rcx" and "ecx" only counts as one:
            regs = _disassembler.CleanRegs(regs);

            var currentLine = firstLine;
            var lineInBlock = firstLine - _disassembler.Blocks[blockIdx].LineIndex;

            var rects = cache.rects;
            if (rects == null)
            {
                rects = new List<Rect>[regs.Count];
                for (var i = 0; i < regs.Count; i++)
                {
                    rects[i] = new List<Rect>();
                }
            }

            while (blockIdx < _blocksFragments.Length && currentLine <= lastLine)
            {
                var lineNotCached = !cache.LinesRegsCached(currentLine);
                var line = _disassembler.Lines[currentLine];
                if (lineNotCached && line.Kind != BurstDisassembler.AsmLineKind.Directive)
                {
                    // Loop body
                    var lineStart = _disassembler.Tokens[line.TokenIndex].AlignedPosition;
                    var i = 0;
                    foreach (var reg in regs)
                    {
                        var regUsedNr = _disassembler.LineUsedReg(currentLine, reg);
                        if (regUsedNr > 0)
                        {
                            var tmpIdx = 0;
                            for (var r = 0; r < regUsedNr; r++)
                            {
                                // Find position and width/height of reg:
                                var height = fontHeight;
                                var width = reg.Length * fontWidth;
                                var y = positionY;

                                var tokenRegIdx = _disassembler.GetRegisterTokenIndex(line, reg, tmpIdx);
                                if (tokenRegIdx == -1)
                                {
                                    throw new Exception($"Could not find token index of \"{reg}\" on line {currentLine}.");
                                }

                                var regIdx = _disassembler.Tokens[tokenRegIdx].AlignedPosition - lineStart;
                                var regPos = regIdx * fontWidth;
                                var x = hPad + regPos + horizontalAlignmentPad;
                                rects[i].Add(new Rect(x, y, width, height));

                                tmpIdx = tokenRegIdx + 1;
                            }
                        }
                        i++;
                    }
                }

                // Loop end statements
                if (lineInBlock >= _disassembler.Blocks[blockIdx].Length)
                {
                    // Moved into next block
                    blockIdx++;
                    lineInBlock = 0;
                }

                if (_folded[blockIdx])
                {
                    currentLine += _disassembler.Blocks[blockIdx].Length;
                    blockIdx++;
                    lineInBlock = 0;
                }
                else
                {
                    currentLine++;
                    lineInBlock++;
                }
                positionY += fontHeight;
            }
            cache.UpdateRegisters(firstLine, lastLine, pressedLine, rects);

            return cache.rects;
        }

        internal struct LineRegRectsCache
        {
            [Flags]
            private enum CachedItem
            {
                None = 0,
                Line = 1,
                Registers = 2
            }

            private CachedItem _isCached;
            private bool _folded;
            /// <summary>
            /// First line we have cached up till.
            /// </summary>
            public int startLine;
            /// <summary>
            /// Last line we have cached down till.
            /// </summary>
            public int endLine;
            /// <summary>
            /// Line we have in focus.
            /// </summary>
            public int chosenLine;

            public Rect lineHighlight;
            /// <summary>
            /// Cached rects. Each row represent one register, and each column is a rect for that register.
            /// </summary>
            public List<Rect>[] rects;

            public bool LinesRegsCached(int pressedLine)
            {
                return (_isCached & CachedItem.Registers) > 0 && BurstMath.WithinRange(startLine, endLine, pressedLine);
            }

            public bool IsRegisterCachedOrClear(int pressedLine, int firstLine, int lastLine)
            {
                var isCached = false;
                if (!IsRegistersCached(pressedLine))
                {
                    // New line was pressed!
                    Clear();
                }
                else if (!ShouldUpdateCache(firstLine, lastLine))
                {
                    isCached = true;
                }

                return isCached;
            }

            public bool IsLineHighlightCached(int linePressed, bool folded) =>
                folded == _folded && (_isCached & CachedItem.Line) > 0 && linePressed == chosenLine;
            public bool IsRegistersCached(int linePressed) => (_isCached & CachedItem.Registers) > 0 && linePressed == chosenLine;

            private bool ShouldUpdateCache(int viewLineStart, int viewLineEnd) => viewLineStart < startLine || viewLineEnd > endLine;

            public void UpdateRegisters(int firstLine, int lastLine, int pressedLine, List<Rect>[] RegRects)
            {
                if (chosenLine != pressedLine && (_isCached & CachedItem.Line) > 0)
                {
                    _isCached ^= CachedItem.Line;
                }
                startLine = Math.Min(firstLine, startLine);
                endLine = Math.Max(lastLine, endLine);
                chosenLine = pressedLine;
                rects = RegRects;
                _isCached |= CachedItem.Registers;
            }

            public void UpdateLineHighlight(int pressedLine, Rect rect, bool folded)
            {
                _isCached |= CachedItem.Line;
                if (chosenLine != pressedLine && (_isCached & CachedItem.Registers) > 0)
                {
                    // line just changed so register cache is no longer valid.
                    _isCached ^= CachedItem.Registers;
                }

                lineHighlight = rect;
                chosenLine = pressedLine;
                _folded = folded;
            }

            public void Clear()
            {
                rects = null;
                chosenLine = -1;
                startLine = int.MaxValue;
                endLine = -1;
                _isCached = CachedItem.None;
            }
        }

        private void TestSelUnderscore(GUIStyle style, Vector2 scrollPos, Rect workingArea)
        {
            var current = GUI.color;

            // Selection
            GUI.color = Color.blue;
            GUI.Box(
                new Rect(horizontalPad + style.padding.left + fontWidth * 8, style.padding.top + fontHeight * 19,
                    3 * fontWidth, 1 * fontHeight), "", textureStyle);

            // Underscored
            Vector2 start = new Vector2(horizontalPad + style.padding.left + fontWidth * 8,
                style.padding.top + fontHeight * 20 - 2);
            Vector2 end = start + new Vector2((3 + 22) * fontWidth, 0 * fontHeight);

            GUI.color = Color.red;
            DrawLine(start, end, 2);

            GUI.color = current;
        }

        internal void RenderBranches(Rect workingArea)
        {
            var color = GUI.color;
            List<Branch> branches = new List<Branch>();
            hoveredBranch = default;
            for (int idx = 0;idx<_disassembler.Blocks.Count; idx++)
            {
                var block = _disassembler.Blocks[idx];
                if (block.Edges != null)
                {
                    foreach (var edge in block.Edges)
                    {
                        if (edge.Kind == BurstDisassembler.AsmEdgeKind.OutBound)
                        {
                            var srcLine = blockLine[idx];
                            if (!_folded[idx])
                            {
                                srcLine += edge.OriginRef.LineIndex;
                            }
                            var dstBlockIdx = edge.LineRef.BlockIndex;
                            var dstLine = blockLine[dstBlockIdx];
                            if (!_folded[dstBlockIdx])
                            {
                                dstLine += edge.LineRef.LineIndex;
                            }

                            int arrowMinY = srcLine;
                            int arrowMaxY = dstLine;
                            if (srcLine > dstLine)
                            {
                                (arrowMinY, arrowMaxY) = (dstLine, srcLine);
                            }

                            if ((dstBlockIdx == idx + 1 && edge.LineRef.LineIndex == 0) // pointing to next line
                                || !(workingArea.yMin <= arrowMaxY * fontHeight &&      // Arrow not inside view.
                                    workingArea.yMax >= arrowMinY * fontHeight))
                            {
                                continue;
                            }
                            branches.Add(CalculateBranch(edge, horizontalPad - (4 + fontWidth), srcLine * fontHeight,
                                dstLine * fontHeight, lineDepth[idx]));
                        }
                    }
                }
            }

            // Drawing branches while making sure the hovered is rendered at top.
            foreach (var branch in branches)
            {
                if (!branch.Edge.Equals(hoveredBranch.Edge))
                {
                    DrawBranch(branch, lineDepth[branch.Edge.OriginRef.BlockIndex], workingArea);
                }
            }
            if (!hoveredBranch.Edge.Equals(default(BurstDisassembler.AsmEdge)))
            {
                DrawBranch(hoveredBranch, lineDepth[hoveredBranch.Edge.OriginRef.BlockIndex], workingArea);
            }

            _prevHoveredEdge = hoveredBranch.Edge;
            GUI.color = color;
        }

        internal int BumpSelectionXByColorTag(string text, int lineIdxTotal, int charsIn)
        {
            bool lastWasStart = true;
            int colorTagStart = text.IndexOf("<color=", lineIdxTotal);

            while (colorTagStart != -1 && colorTagStart - lineIdxTotal < charsIn)
            {
                int colorTagEnd = text.IndexOf('>', colorTagStart + 1);
                // +1 as the index calculation is zero based.
                charsIn += colorTagEnd - colorTagStart + 1;

                if (lastWasStart)
                {
                    colorTagStart = text.IndexOf("</color>", colorTagEnd + 1);
                    lastWasStart = false;
                }
                else
                {
                    colorTagStart = text.IndexOf("<color=", colorTagEnd + 1);
                    lastWasStart = true;
                }
            }
            return charsIn;
        }

        internal void UpdateEnhancedSelectTextIdx(float hPad)
        {
            if (_textSelectionIdxValid || !HasSelection) return;

            int blockIdxStart = _selectBlockStart;
            int blockIdxEnd = _selectBlockEnd;
            float blockStartPosY = _selectStartY;
            float blockEndPosY = _selectEndY;

            var start = selectPos;
            var last = selectDragPos;
            if (last.y < start.y)
            {
                // we selected upwards.
                (start, last) = (last, start);
                (blockIdxStart, blockIdxEnd, blockStartPosY, blockEndPosY) = (blockIdxEnd, blockIdxStart, blockEndPosY, blockStartPosY);
            }

            // Math.Min to make sure line number does not exceed number of line in block (zero indexed).
            var blockStartline = Math.Min(Mathf.FloorToInt((start.y - blockStartPosY) / fontHeight),
                _folded[blockIdxStart]
                    ? 0
                    : _disassembler.Blocks[blockIdxStart].Length-1);
            var blockEndLine = Math.Min(Mathf.FloorToInt((last.y - blockEndPosY) / fontHeight),
                _folded[blockIdxEnd]
                    ? 0
                    : _disassembler.Blocks[blockIdxEnd].Length-1);

            if (blockStartline == blockEndLine && blockIdxStart == blockIdxEnd && start.x > last.x)
            {
                // _selectDragPos was above and behind _selectPos on same line.
                (start, last) = (last, start);
            }

            var text = _folded[blockIdxStart]
                ? CopyColorTags
                    ? GetFragmentStart(blockIdxStart).text + '\n'
                    : GetFragmentStartPlain(blockIdxStart).text + '\n'
                : CopyColorTags
                    ? _disassembler.GetOrRenderBlockToText(blockIdxStart)
                    : _disassembler.GetOrRenderBlockToTextUncached(blockIdxStart, false);

            var (startLineEndIdxTotal, startLineEndIdxRel) = GetEndIndexOfColoredLine(text, blockStartline);
            int startOfLineIdx = startLineEndIdxTotal - startLineEndIdxRel;

            int charsIn = Math.Min(Mathf.FloorToInt((start.x - hPad) / fontWidth), startLineEndIdxRel);
            charsIn = charsIn < 0 ? 0 : charsIn;

            // Adjust charsIn so it takes color tags into considerations.
            charsIn = BumpSelectionXByColorTag(text, startOfLineIdx, charsIn + 1) - 1; // +1 -1 to not bump charsIn when selecting char just after color tag.

            enhancedTextSelectionIdxStart = (blockIdxStart, startOfLineIdx + charsIn);

            if (blockIdxStart < blockIdxEnd)
            {
                text = _folded[blockIdxEnd]
                    ? CopyColorTags
                        ? GetFragmentStart(blockIdxEnd).text + '\n'
                        : GetFragmentStartPlain(blockIdxEnd).text + '\n'
                    : CopyColorTags
                        ? _disassembler.GetOrRenderBlockToText(blockIdxEnd)
                        : _disassembler.GetOrRenderBlockToTextUncached(blockIdxEnd, false);
            }

            var (lastLineEndIdxTotal, lastLineEndIdxRel) = GetEndIndexOfColoredLine(text, blockEndLine);
            startOfLineIdx = lastLineEndIdxTotal - lastLineEndIdxRel;

            int charsInDrag = Math.Min(Mathf.FloorToInt((last.x - hPad) / fontWidth), lastLineEndIdxRel);
            charsInDrag = charsInDrag < 0 ? 0 : charsInDrag;

            // Adjust charsInDrag so it takes color tags into considerations.
            charsInDrag = BumpSelectionXByColorTag(text, startOfLineIdx, charsInDrag);

            enhancedTextSelectionIdxEnd = (blockIdxEnd, startOfLineIdx + charsInDrag);

            _textSelectionIdxValid = true;
        }

        /// <summary>
        /// Updates selection based on whether <see cref="blockIdx"/> was folded or unfolded.
        /// </summary>
        /// <param name="hPad">horizontal padding.</param>
        /// <param name="blockIdx">Block idx of folded/unfolded block.</param>
        /// <param name="block">folded/unfolded block.</param>
        /// <param name="positionY">Blocks y-position in textarea.</param>
        private void UpdateSelectionByFolding(float hPad, int blockIdx, BurstDisassembler.AsmBlock block, float positionY)
        {
            // cursor start and end position of selection
            var start = selectPos;
            var end = selectDragPos;

            // selection block start and end
            var blockStart = _selectBlockStart;
            var blockEnd = _selectBlockEnd;

            // top y-coordinate of selections end block
            var blockEndY = _selectEndY;

            var rightWaySelect = true;
            if (start.y > end.y)
            {
                (start, end) = (end, start);
                (blockStart, blockEnd) = (blockEnd, blockStart);
                blockEndY = _selectStartY;
                rightWaySelect = false;
            }

            if (BurstMath.RoundDownToNearest(end.y, fontHeight) - BurstMath.RoundDownToNearest(start.y, fontHeight) < fontHeight
                && end.x < start.x)
            {
                (start, end) = (end, start);
                rightWaySelect = !rightWaySelect;
            }

            var changeY = _folded[blockIdx]
                ? -Math.Max(block.Length - 1, 1) * fontHeight
                : Math.Max(block.Length - 1, 1) * fontHeight;

            var charsInLine = GetEndIndexOfColoredLine(
                _folded[blockIdx]
                    ? GetFragmentStart(blockIdx).text + '\n'
                    : _disassembler.GetOrRenderBlockToText(blockIdx),
                0).relative;

            var thisLineSelect = Mathf.FloorToInt((start.y - positionY) / fontHeight);
            var thisLineDrag = Mathf.FloorToInt((end.y - positionY) / fontHeight);

            var selectPosCharsIn = Mathf.FloorToInt((start.x - hPad) / fontWidth);
            var selectDragPosCharsIn = Mathf.FloorToInt((end.x - hPad) / fontWidth);

            if (blockStart < blockIdx)
            {
                if (blockEnd == blockIdx)
                {
                    if (thisLineDrag > 0 || (end.x - hPad) / fontWidth > charsInLine)
                    {
                        /* selection starts above touched block but ends in the middle of it.
                         *
                         *  b-1 _xxx        b-1 _xxx
                         *  b   xxx_   =>   b   xxx
                         *  b+1 ____        b+1 ____
                         */

                        // Move selectDragPos onto end of this line.
                        end.y -= thisLineDrag * fontHeight;
                        end.x = charsInLine * fontWidth + hPad + fontWidth / 2;
                    }
                }
                else if (blockEnd > blockIdx)
                {
                    /* selection starts above touched block and ends below it.
                     *
                     *  b-1 _xxx
                     *  b   xxxx
                     *  b+1 xx__
                     */
                    end.y += changeY;
                    blockEndY += changeY;
                }
            }
            else if (blockStart == blockIdx)
            {
                if (blockEnd == blockIdx)
                {
                    if (thisLineSelect > 0 || selectPosCharsIn > charsInLine)
                    {
                        /* selection starts and ends in the middle of the touched block
                         *
                         *  b-1 ____        b-1 ____
                         *  b   _xx_    =>  b   _
                         *  b+1 ____        b+1 ____
                         */
                        // Make cursor go to the end of line
                        end.y -= thisLineDrag * fontHeight;
                        end.x = charsInLine * fontWidth + hPad + fontWidth / 2;

                        StopSelection();
                    }
                    else if (thisLineDrag > 0 || selectDragPosCharsIn > charsInLine)
                    {
                        /* selection starts at first line and ends within
                         *
                         *  b-1 ____        b-1 ____
                         *  b   _xx_    =>  b   x
                         *      xxx_
                         *  b+1 ____        b+1 ____
                         */
                        // Move selectDragPos onto end of this line.
                        end.y -= thisLineDrag * fontHeight;
                        end.x = charsInLine * fontWidth + hPad + fontWidth / 2;
                    }
                }
                else if (blockEnd > blockIdx)
                {
                    // selection starts either in first line or middle of touched block and ends below it
                    end.y += changeY;

                    if (thisLineSelect > 0 || selectPosCharsIn > charsInLine)
                    {
                        /* selection starts in middle of touched block and ends below it
                         *
                         *  b-1 ____        b-1 ____
                         *  b   ____    =>  b   ___x
                         *      x___
                         *  b+1 xx__        b+1 xx__
                         */
                        // Move selectPos onto end of this line.
                        start.y -= thisLineSelect * fontHeight;
                        start.x = charsInLine * fontWidth + hPad + fontWidth / 2;
                    }
                }
            }
            else
            {
                start.y += changeY;
                end.y += changeY;
            }

            // Write back changes made during folding/unfolding
            if (rightWaySelect)
            {
                selectPos = start;
                selectDragPos = end;
                _selectEndY = blockEndY;
            }
            else
            {
                selectPos = end;
                selectDragPos = start;
                _selectStartY = blockEndY;
            }

            if (!HasSelection) selectPos = selectDragPos;
            else _textSelectionIdxValid = false;
        }

        private void FoldUnfoldBlock(int blockIdx)
        {
            var block = _disassembler.Blocks[blockIdx];

            _folded[blockIdx] = !_folded[blockIdx];
            if (_folded[blockIdx])
            {
                finalAreaSize.y -= Math.Max(block.Length - 1, 1) * fontHeight;
                AddFoldedString(blockIdx);
            }
            else
            {
                finalAreaSize.y += Math.Max(block.Length - 1, 1) * fontHeight;
            }
        }

        private void RenderEnhanced(GUIStyle style, Rect workingArea, bool showBranchMarkers, float hPad, bool doSearch)
        {
            //TestSelUnderscore();
            if (showBranchMarkers)
            {
                RenderBranches(workingArea);
            }

            var positionY = _renderStartY;
            var fragNr = 0;
            for (var i = 0; i <= _renderBlockEnd; i++)
            {
                if (i < _renderBlockStart)
                {
                    if (doSearch)
                    {
                        foreach (var frag in GetPlainFragments(i))
                        {
                            fragNr++;
                        }
                    }

                    continue;
                }

                var block = _disassembler.Blocks[i];

                var blockLongEnoughForFold = block.Length > 1;
                if (blockLongEnoughForFold)
                {
                    var pressed = DrawFold(hPad - 2, positionY, _folded[i], block.Kind);
                    if (pressed)
                    {
                        FoldUnfoldBlock(i);

                        // Make sure cursor and selection is updated according to the changed folding.
                        UpdateSelectionByFolding(hPad, i, block, positionY);
                    }
                }

                if (doSearch)
                {
                    var tmpPositionY = positionY;
                    for (var tmp = 0; tmp < GetPlainFragments(i).Count; fragNr++, tmp++)
                    {
                        if (searchHits.TryGetValue(fragNr, out var hits))
                        {
                            if (_folded[i]) FoldUnfoldBlock(i);

                            foreach (var (startIdx, endIdx, nr) in hits)
                            {
                                var isActive = nr == _activeSearchHitIdx;
                                var realEndIdx = endIdx;

                                if (endIdx == int.MaxValue)
                                {
                                    var text = GetPlainFragments(i)[tmp].text;
                                    realEndIdx = text.Length;
                                    RenderMultipleLinesSelection(text, horizontalPad, tmpPositionY, startIdx,
                                        realEndIdx, isActive);
                                }
                                else
                                {
                                    RenderMultipleLinesSelection(
                                        GetPlainFragments(i)[tmp].text,
                                        horizontalPad,
                                        tmpPositionY,
                                        startIdx,
                                        realEndIdx,
                                        isActive);
                                }
                            }
                        }
                        tmpPositionY += GetPlainFragments(i)[tmp].lineCount * fontHeight;
                    }
                }

                if (!_folded[i] || !blockLongEnoughForFold)
                {
                    for (var j = 0; j < _blocksFragments[i].Count; j++)
                    {
                        var fragment = _blocksFragments[i][j];

                        var fragLineCount = fragment.lineCount;
                        var fragHeight = fragLineCount * fontHeight;

                        SelectText(hPad, positionY, fragHeight, fragment,
                            _disassembler.IsColored
                                ? GetEndIndexOfColoredLine
                                : GetEndIndexOfPlainLine);

                        GUI.Label(new Rect(hPad, positionY, finalAreaSize.x, fragHeight + fontHeight*0.5f),
                            fragment.text, style);
                        positionY += fragHeight;
                    }
                }
                else
                {
                    var frag = GetFragmentStart(i);

                    SelectText(hPad, positionY, fontHeight, frag,
                        _disassembler.IsColored
                            ? GetEndIndexOfColoredLine
                            : GetEndIndexOfPlainLine);

                    float fragHeight = fontHeight;

                    GUI.Label(new Rect(hPad, positionY, finalAreaSize.x, fragHeight*1.5f), frag.text, style);
                    positionY += fragHeight;
                }
            }
            UpdateEnhancedSelectTextIdx(hPad);
        }

        private List<Fragment> RecomputeFragments(string text)
        {
            List<Fragment> result = new List<Fragment>();

            string[] pieces = text.Split('\n');
            _mTextLines = pieces.Length;

            StringBuilder b = new StringBuilder();

            int lineCount = 0;
            for (int a = 0; a < pieces.Length; a++)
            {
                if (b.Length >= kMaxFragment)
                {
                    b.Remove(b.Length - 1, 1);
                    AddFragment(b, lineCount, result);
                    lineCount = 0;
                }

                b.Append(pieces[a]);
                b.Append('\n');
                lineCount++;
            }

            if (b.Length > 0)
            {
                b.Remove(b.Length - 1, 1);
                AddFragment(b, lineCount, result);
            }

            return result;
        }

        private List<Fragment> RecomputeFragmentsFromBlock(int blockIdx, bool colored)
        {
            var text = _disassembler.GetOrRenderBlockToTextUncached(blockIdx, colored).TrimEnd('\n');

            return RecomputeFragments(text);
        }

        internal List<Fragment> RecomputeFragmentsFromBlock(int blockIdx)
        {
            var text = _disassembler.GetOrRenderBlockToText(blockIdx).TrimEnd('\n');

            return RecomputeFragments(text);
        }

        private static void AddFragment(StringBuilder b, int lineCount, List<Fragment> result)
        {
            result.Add(new Fragment() { text = b.ToString(), lineCount = lineCount });
            b.Length = 0;
        }
    }
}