Upload FastSeekWpf/Core/SearchEngine.cs

FastSeekWpf/Core/SearchEngine.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace FastSeekWpf.Core;
+
+public enum ResultKind
+{
+    App, Document, Image, Video, Audio, Archive, Folder, Other
+}
+
+public class SearchResult
+{
+    public string FullPath { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public byte Rank { get; set; }
+    public bool IsDir { get; set; }
+    public ResultKind Kind { get; set; }
+}
+
+public static class SearchEngine
+{
+    private static readonly string[] AppExtensions = { "exe", "lnk", "msi", "appx", "msix" };
+    private static readonly string[] AppPathMarkers = {
+        "\\program files\\", "\\program files (x86)\\",
+        "\\start menu\\", "\\desktop\\", "\\appdata\\"
+    };
+
+    private static readonly Dictionary<string, ResultKind> ExtensionMap = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["exe"] = ResultKind.App, ["lnk"] = ResultKind.App, ["msi"] = ResultKind.App,
+        ["doc"] = ResultKind.Document, ["docx"] = ResultKind.Document, ["pdf"] = ResultKind.Document,
+        ["txt"] = ResultKind.Document, ["xlsx"] = ResultKind.Document, ["xls"] = ResultKind.Document,
+        ["pptx"] = ResultKind.Document, ["ppt"] = ResultKind.Document, ["odt"] = ResultKind.Document,
+        ["ods"] = ResultKind.Document, ["odp"] = ResultKind.Document, ["rtf"] = ResultKind.Document,
+        ["md"] = ResultKind.Document, ["csv"] = ResultKind.Document, ["json"] = ResultKind.Document,
+        ["xml"] = ResultKind.Document, ["yaml"] = ResultKind.Document, ["toml"] = ResultKind.Document,
+        ["ini"] = ResultKind.Document, ["log"] = ResultKind.Document,
+        ["png"] = ResultKind.Image, ["jpg"] = ResultKind.Image, ["jpeg"] = ResultKind.Image,
+        ["gif"] = ResultKind.Image, ["bmp"] = ResultKind.Image, ["webp"] = ResultKind.Image,
+        ["svg"] = ResultKind.Image, ["ico"] = ResultKind.Image, ["tiff"] = ResultKind.Image,
+        ["heic"] = ResultKind.Image, ["raw"] = ResultKind.Image, ["psd"] = ResultKind.Image,
+        ["mp4"] = ResultKind.Video, ["mkv"] = ResultKind.Video, ["avi"] = ResultKind.Video,
+        ["mov"] = ResultKind.Video, ["wmv"] = ResultKind.Video, ["flv"] = ResultKind.Video,
+        ["webm"] = ResultKind.Video, ["m4v"] = ResultKind.Video,
+        ["mp3"] = ResultKind.Audio, ["flac"] = ResultKind.Audio, ["wav"] = ResultKind.Audio,
+        ["aac"] = ResultKind.Audio, ["ogg"] = ResultKind.Audio, ["m4a"] = ResultKind.Audio,
+        ["wma"] = ResultKind.Audio, ["opus"] = ResultKind.Audio,
+        ["zip"] = ResultKind.Archive, ["rar"] = ResultKind.Archive, ["7z"] = ResultKind.Archive,
+        ["tar"] = ResultKind.Archive, ["gz"] = ResultKind.Archive, ["bz2"] = ResultKind.Archive,
+        ["xz"] = ResultKind.Archive, ["zst"] = ResultKind.Archive,
+    };
+
+    public static ResultKind GetKind(string? ext, bool isDir, string fullPathLower)
+    {
+        if (isDir) return ResultKind.Folder;
+        if (ext == null) return ResultKind.Other;
+        if (ExtensionMap.TryGetValue(ext, out var kind))
+        {
+            if (kind == ResultKind.App && AppPathMarkers.Any(m => fullPathLower.Contains(m)))
+                return ResultKind.App;
+            return kind;
+        }
+        return ResultKind.Other;
+    }
+
+    public static List<SearchResult> Search(
+        IndexStore store,
+        string query,
+        int limit,
+        bool caseSensitive,
+        List<string> excludedDirs)
+    {
+        if (string.IsNullOrWhiteSpace(query))
+            return new List<SearchResult>();
+
+        string q = caseSensitive ? query : query.ToLowerInvariant();
+
+        var candidates = new List<(int idx, byte rank)>();
+        lock (store)
+        {
+            for (int i = 0; i < store.Entries.Count; i++)
+            {
+                var entry = store.Entries[i];
+                string name = caseSensitive ? store.Name(entry) : store.NameLower(entry);
+
+                byte rank;
+                if (name == q) rank = 1;
+                else if (name.StartsWith(q, StringComparison.Ordinal)) rank = 2;
+                else if (name.Contains(q, StringComparison.Ordinal)) rank = 3;
+                else continue;
+
+                candidates.Add((i, rank));
+            }
+        }
+
+        candidates.Sort((a, b) => a.rank.CompareTo(b.rank));
+        int overshoot = Math.Max(limit * 5, 1000);
+        if (candidates.Count > overshoot)
+            candidates.RemoveRange(overshoot, candidates.Count - overshoot);
+
+        var results = new List<SearchResult>(Math.Min(limit, candidates.Count));
+
+        foreach (var (idx, baseRank) in candidates)
+        {
+            var entry = store.Entries[idx];
+            string fullPath = store.BuildPath(entry.FileRef);
+            string fullPathLower = fullPath.ToLowerInvariant();
+
+            if (excludedDirs.Count > 0 && excludedDirs.Any(ex => fullPathLower.StartsWith(ex, StringComparison.Ordinal)))
+                continue;
+
+            string name = store.Name(entry);
+            string nameLower = store.NameLower(entry);
+
+            byte rank = baseRank;
+            if (baseRank <= 2)
+            {
+                int dotIdx = nameLower.LastIndexOf('.');
+                if (dotIdx >= 0)
+                {
+                    string ext = nameLower[(dotIdx + 1)..];
+                    if (AppExtensions.Contains(ext) && AppPathMarkers.Any(m => fullPathLower.Contains(m)))
+                        rank = 0;
+                }
+            }
+
+            string? fileExt = null;
+            if (!entry.IsDir)
+            {
+                int dot = name.LastIndexOf('.');
+                if (dot >= 0) fileExt = name[(dot + 1)..].ToLowerInvariant();
+            }
+
+            results.Add(new SearchResult
+            {
+                FullPath = fullPath,
+                Name = name,
+                Rank = rank,
+                IsDir = entry.IsDir,
+                Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
+            });
+        }
+
+        results.Sort((a, b) => a.Rank.CompareTo(b.Rank));
+        if (results.Count > limit)
+            results.RemoveRange(limit, results.Count - limit);
+
+        return results;
+    }
+
+    public static List<SearchResult> SearchByExtension(
+        IndexStore store,
+        string ext,
+        List<string> excludedDirs)
+    {
+        string dotExt = "." + ext.ToLowerInvariant();
+        var results = new List<SearchResult>();
+
+        lock (store)
+        {
+            foreach (var entry in store.Entries)
+            {
+                string name = store.NameLower(entry);
+                if (!name.EndsWith(dotExt)) continue;
+
+                string fullPath = store.BuildPath(entry.FileRef);
+                string fullPathLower = fullPath.ToLowerInvariant();
+
+                if (excludedDirs.Any(ex => fullPathLower.StartsWith(ex, StringComparison.Ordinal)))
+                    continue;
+
+                string? fileExt = null;
+                int dot = name.LastIndexOf('.');
+                if (dot >= 0) fileExt = name[(dot + 1)..];
+
+                results.Add(new SearchResult
+                {
+                    FullPath = fullPath,
+                    Name = store.Name(entry),
+                    Rank = 0,
+                    IsDir = entry.IsDir,
+                    Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
+                });
+
+                if (results.Count >= 50) break;
+            }
+        }
+
+        return results;
+    }
+}