Merge remote-tracking branch 'upstream/master' into 1914-prevent-duplicates-in-playlists

4 files changed, 141 insertions, 50 deletions

diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index 66de080a3..5e4217cd5 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -33,7 +33,7 @@ namespace MediaBrowser.Controller.Entities
     /// <summary>
     /// Class BaseItem
     /// </summary>
-    public abstract class BaseItem : IHasProviderIds, IHasLookupInfo<ItemLookupInfo>
+    public abstract class BaseItem : IHasProviderIds, IHasLookupInfo<ItemLookupInfo>, IEquatable<BaseItem>
     {
         /// <summary>
         /// The supported image extensions
@@ -2914,5 +2914,17 @@ namespace MediaBrowser.Controller.Entities
         public static readonly IReadOnlyCollection<ExtraType> DisplayExtraTypes = new[] { Model.Entities.ExtraType.BehindTheScenes, Model.Entities.ExtraType.Clip, Model.Entities.ExtraType.DeletedScene, Model.Entities.ExtraType.Interview, Model.Entities.ExtraType.Sample, Model.Entities.ExtraType.Scene };
 
         public virtual bool SupportsExternalTransfer => false;
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            return obj is BaseItem baseItem && this.Equals(baseItem);
+        }
+
+        /// <inheritdoc />
+        public bool Equals(BaseItem item) => Object.Equals(Id, item?.Id);
+
+        /// <inheritdoc />
+        public override int GetHashCode() => HashCode.Combine(Id);
     }
 }
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index a892be7a9..c72bd487e 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -807,11 +807,45 @@ namespace MediaBrowser.Controller.Entities
             return false;
         }
 
+        private static BaseItem[] SortItemsByRequest(InternalItemsQuery query, IReadOnlyList<BaseItem> items)
+        {
+            var ids = query.ItemIds;
+            int size = items.Count;
+
+            // ids can potentially contain non-unique guids, but query result cannot,
+            // so we include only first occurrence of each guid
+            var positions = new Dictionary<Guid, int>(size);
+            int index = 0;
+            for (int i = 0; i < ids.Length; i++)
+            {
+                if (positions.TryAdd(ids[i], index))
+                {
+                    index++;
+                }
+            }
+
+            var newItems = new BaseItem[size];
+            for (int i = 0; i < size; i++)
+            {
+                var item = items[i];
+                newItems[positions[item.Id]] = item;
+            }
+
+            return newItems;
+        }
+
         public QueryResult<BaseItem> GetItems(InternalItemsQuery query)
         {
             if (query.ItemIds.Length > 0)
             {
-                return LibraryManager.GetItemsResult(query);
+                var result = LibraryManager.GetItemsResult(query);
+
+                if (query.OrderBy.Count == 0 && query.ItemIds.Length > 1)
+                {
+                    result.Items = SortItemsByRequest(query, result.Items);
+                }
+
+                return result;
             }
 
             return GetItemsInternal(query);
@@ -823,7 +857,14 @@ namespace MediaBrowser.Controller.Entities
 
             if (query.ItemIds.Length > 0)
             {
-                return LibraryManager.GetItemList(query);
+                var result = LibraryManager.GetItemList(query);
+
+                if (query.OrderBy.Count == 0 && query.ItemIds.Length > 1)
+                {
+                    return SortItemsByRequest(query, result);
+                }
+
+                return result.ToArray();
             }
 
             return GetItemsInternal(query).Items;
diff --git a/MediaBrowser.Controller/Library/Profiler.cs b/MediaBrowser.Controller/Library/Profiler.cs
index 9fe175a7c..46a97d181 100644
--- a/MediaBrowser.Controller/Library/Profiler.cs
+++ b/MediaBrowser.Controller/Library/Profiler.cs
@@ -28,7 +28,7 @@ namespace MediaBrowser.Controller.Library
         /// </summary>
         /// <param name="name">The name.</param>
         /// <param name="logger">The logger.</param>
-        public Profiler(string name, ILogger logger)
+        public Profiler(string name, ILogger<Profiler> logger)
         {
             this._name = name;
 
diff --git a/MediaBrowser.Controller/Sorting/AlphanumComparator.cs b/MediaBrowser.Controller/Sorting/AlphanumComparator.cs
index 65dc120ca..de7f72d1c 100644
--- a/MediaBrowser.Controller/Sorting/AlphanumComparator.cs
+++ b/MediaBrowser.Controller/Sorting/AlphanumComparator.cs
@@ -1,94 +1,132 @@
+#nullable enable
+
+using System;
 using System.Collections.Generic;
-using System.Text;
-using MediaBrowser.Controller.Sorting;
 
 namespace MediaBrowser.Controller.Sorting
 {
-    public class AlphanumComparator : IComparer<string>
+    public class AlphanumComparator : IComparer<string?>
     {
-        public static int CompareValues(string s1, string s2)
+        public static int CompareValues(string? s1, string? s2)
         {
-            if (s1 == null || s2 == null)
+            if (s1 == null && s2 == null)
             {
                 return 0;
             }
+            else if (s1 == null)
+            {
+                return -1;
+            }
+            else if (s2 == null)
+            {
+                return 1;
+            }
 
-            int thisMarker = 0, thisNumericChunk = 0;
-            int thatMarker = 0, thatNumericChunk = 0;
+            int len1 = s1.Length;
+            int len2 = s2.Length;
 
-            while ((thisMarker < s1.Length) || (thatMarker < s2.Length))
+            // Early return for empty strings
+            if (len1 == 0 && len2 == 0)
             {
-                if (thisMarker >= s1.Length)
+                return 0;
+            }
+            else if (len1 == 0)
+            {
+                return -1;
+            }
+            else if (len2 == 0)
+            {
+                return 1;
+            }
+
+            int pos1 = 0;
+            int pos2 = 0;
+
+            do
+            {
+                int start1 = pos1;
+                int start2 = pos2;
+
+                bool isNum1 = char.IsDigit(s1[pos1++]);
+                bool isNum2 = char.IsDigit(s2[pos2++]);
+
+                while (pos1 < len1 && char.IsDigit(s1[pos1]) == isNum1)
                 {
-                    return -1;
+                    pos1++;
                 }
-                else if (thatMarker >= s2.Length)
+
+                while (pos2 < len2 && char.IsDigit(s2[pos2]) == isNum2)
                 {
-                    return 1;
+                    pos2++;
                 }
-                char thisCh = s1[thisMarker];
-                char thatCh = s2[thatMarker];
 
-                var thisChunk = new StringBuilder();
-                var thatChunk = new StringBuilder();
-                bool thisNumeric = char.IsDigit(thisCh), thatNumeric = char.IsDigit(thatCh);
+                var span1 = s1.AsSpan(start1, pos1 - start1);
+                var span2 = s2.AsSpan(start2, pos2 - start2);
 
-                while (thisMarker < s1.Length && char.IsDigit(thisCh) == thisNumeric)
+                if (isNum1 && isNum2)
                 {
-                    thisChunk.Append(thisCh);
-                    thisMarker++;
-
-                    if (thisMarker < s1.Length)
+                    // Trim leading zeros so we can compare the length
+                    // of the strings to find the largest number
+                    span1 = span1.TrimStart('0');
+                    span2 = span2.TrimStart('0');
+                    var span1Len = span1.Length;
+                    var span2Len = span2.Length;
+                    if (span1Len < span2Len)
                     {
-                        thisCh = s1[thisMarker];
+                        return -1;
                     }
-                }
-
-                while (thatMarker < s2.Length && char.IsDigit(thatCh) == thatNumeric)
-                {
-                    thatChunk.Append(thatCh);
-                    thatMarker++;
-
-                    if (thatMarker < s2.Length)
+                    else if (span1Len > span2Len)
                     {
-                        thatCh = s2[thatMarker];
+                        return 1;
                     }
-                }
+                    else if (span1Len >= 20) // Number is probably too big for a ulong
+                    {
+                        // Trim all the first digits that are the same
+                        int i = 0;
+                        while (i < span1Len && span1[i] == span2[i])
+                        {
+                            i++;
+                        }
 
+                        // If there are no more digits it's the same number
+                        if (i == span1Len)
+                        {
+                            continue;
+                        }
 
-                // If both chunks contain numeric characters, sort them numerically
-                if (thisNumeric && thatNumeric)
-                {
-                    if (!int.TryParse(thisChunk.ToString(), out thisNumericChunk)
-                        || !int.TryParse(thatChunk.ToString(), out thatNumericChunk))
+                        // Only need to compare the most significant digit
+                        span1 = span1.Slice(i, 1);
+                        span2 = span2.Slice(i, 1);
+                    }
+
+                    if (!ulong.TryParse(span1, out var num1)
+                        || !ulong.TryParse(span2, out var num2))
                     {
                         return 0;
                     }
-
-                    if (thisNumericChunk < thatNumericChunk)
+                    else if (num1 < num2)
                     {
                         return -1;
                     }
-
-                    if (thisNumericChunk > thatNumericChunk)
+                    else if (num1 > num2)
                     {
                         return 1;
                     }
                 }
                 else
                 {
-                    int result = thisChunk.ToString().CompareTo(thatChunk.ToString());
+                    int result = span1.CompareTo(span2, StringComparison.InvariantCulture);
                     if (result != 0)
                     {
                         return result;
                     }
                 }
+            } while (pos1 < len1 && pos2 < len2);
 
-            }
-
-            return 0;
+            return len1 - len2;
         }
 
+        /// <inheritdoc />
         public int Compare(string x, string y)
         {
             return CompareValues(x, y);