using Explorer.Domain;

namespace Explorer.Domain.Tests;

public class NameNormalizerTests
{
    [Fact]
    public void Normalize_folds_case_and_keeps_unicode()
    {
        Assert.Equal("straße", NameNormalizer.Normalize("Straße"));
        Assert.Equal("abc", NameNormalizer.Normalize("ABC"));
    }

    [Fact]
    public void Extension_skips_leading_dot_names()
    {
        Assert.Equal("mkv", NameNormalizer.Extension("film.mkv"));
        Assert.Null(NameNormalizer.Extension(".gitignore"));
        Assert.Null(NameNormalizer.Extension("Makefile"));
    }
}

public class PathRulesTests
{
    [Fact]
    public void Extended_roundtrip_local_and_unc()
    {
        Assert.Equal(@"\\?\C:\Temp", PathRules.ToExtended(@"C:\Temp"));
        Assert.Equal(@"\\?\UNC\server\share", PathRules.ToExtended(@"\\server\share"));
        Assert.Equal(@"C:\Temp", PathRules.FromExtended(@"\\?\C:\Temp"));
        Assert.Equal(@"\\server\share", PathRules.FromExtended(@"\\?\UNC\server\share"));
    }

    [Fact]
    public void Canonical_unc_lowercases_server()
    {
        Assert.Equal(@"\\media\Movies", PathRules.CanonicalUncRoot(@"\\Media\Movies\Action"));
    }

    [Fact]
    public void Relative_and_parent()
    {
        Assert.Equal(@"Windows\System32", PathRules.MakeRelative(@"C:\", @"C:\Windows\System32"));
        Assert.Equal(@"C:\Windows", PathRules.Parent(@"C:\Windows\System32"));
        Assert.Equal(@"C:\", PathRules.Parent(@"C:\Windows"));
        Assert.True(PathRules.DriveLetterSortKey(@"D:\") < PathRules.DriveLetterSortKey(@"F:\"));
        Assert.True(PathRules.DriveLetterSortKey(@"C:\") < PathRules.DriveLetterSortKey(@"\\media\movies"));
        Assert.Equal(@"pack.zip\docs", PathRules.RelativeParent(@"pack.zip\docs\a.txt"));
        Assert.Equal("pack.zip", PathRules.RelativeParent(@"pack.zip\docs"));
        Assert.Equal("", PathRules.RelativeParent("pack.zip"));
    }

    [Fact]
    public void Join_display_combines_root_and_relative()
    {
        Assert.Equal(@"C:\Users\Docs", PathRules.JoinDisplay(@"C:\Users", "Docs"));
        Assert.Equal(@"C:\", PathRules.JoinDisplay(@"C:\", ""));
        Assert.Equal("Docs", PathRules.JoinDisplay(null, "Docs"));
    }

    [Fact]
    public void Shorten_keeps_root_and_leaf()
    {
        Assert.Equal(@"C:\Temp", PathRules.ShortenDisplay(@"C:\Temp"));
        Assert.Equal(@"C:\Users\…\Documents\Budget", PathRules.ShortenDisplay(@"C:\Users\Dominique\Documents\Budget", 28));
        Assert.Equal(@"\\media\movies\…\Action\Dune", PathRules.ShortenDisplay(@"\\media\movies\New\Action\Dune", 28));
    }
}

public class ArchiveFormatsTests
{
    [Fact]
    public void Detects_common_archive_extensions()
    {
        Assert.True(ArchiveFormats.IsArchive("pack.zip"));
        Assert.True(ArchiveFormats.IsArchive("film.7z"));
        Assert.True(ArchiveFormats.IsArchive("backup.rar"));
        Assert.True(ArchiveFormats.IsArchive("src.tar.gz"));
        Assert.True(ArchiveFormats.IsZipFamily("photos.cbz"));
        Assert.False(ArchiveFormats.IsArchive("notes.txt"));
        Assert.False(ArchiveFormats.IsArchive("report.docx"));
    }

    [Fact]
    public void Rejects_unsafe_archive_entry_paths()
    {
        Assert.True(ArchiveFormats.TryNormalizeEntryPath("docs/a.txt", out var ok));
        Assert.Equal(@"docs\a.txt", ok);
        Assert.False(ArchiveFormats.TryNormalizeEntryPath(@"..\escape.txt", out _));
        Assert.False(ArchiveFormats.TryNormalizeEntryPath(@"C:\abs.txt", out _));
        Assert.False(ArchiveFormats.TryNormalizeEntryPath("/", out _));
    }
}

public class VolumeIdentityTests
{
    [Fact]
    public void Matches_volume_guid_across_drive_letters()
    {
        var known = new List<Source>
        {
            new()
            {
                Id = 1,
                StableKey = "a",
                DisplayName = "SanDisk Ultra 64 GB",
                VolumeGuid = @"\\?\Volume{abc}\",
                LastRootPath = @"E:\",
                Kind = SourceKind.Removable
            }
        };
        var fp = new VolumeFingerprint
        {
            Kind = SourceKind.Removable,
            VolumeGuid = @"\\?\Volume{abc}\",
            RootPath = @"G:\",
            DisplayName = "SanDisk"
        };
        var match = VolumeIdentityMatcher.Match(fp, known);
        Assert.NotNull(match.Source);
        Assert.Equal(1, match.Source!.Id);
        Assert.Equal(VolumeIdentityMatcher.MatchStrength.Guid, match.Strength);
        Assert.False(match.Ambiguous);
    }

    [Fact]
    public void Matches_unc_share()
    {
        var known = new List<Source>
        {
            new()
            {
                Id = 7,
                StableKey = "s",
                DisplayName = @"\\media\movies",
                Kind = SourceKind.Smb,
                LastRootPath = @"\\Media\Movies"
            }
        };
        var fp = new VolumeFingerprint { Kind = SourceKind.Smb, RootPath = @"\\media\movies", DisplayName = "x" };
        Assert.Equal(7, VolumeIdentityMatcher.Match(fp, known).Source?.Id);
    }
}

public class LocationClassifierTests
{
    [Fact]
    public void Classifies_known_protected_locations()
    {
        var svi = LocationClassifier.Classify(
            @"C:\System Volume Information", "System Volume Information",
            AttributeFlags.Directory | AttributeFlags.Hidden | AttributeFlags.System, true);
        Assert.True(svi.IsProtected);
        Assert.True(svi.IsHidden);
        Assert.True(svi.IsSystem);
        Assert.False(svi.IsRecycleBin);

        var recycle = LocationClassifier.Classify(
            @"D:\$RECYCLE.BIN", "$RECYCLE.BIN",
            AttributeFlags.Directory | AttributeFlags.Hidden | AttributeFlags.System, true);
        Assert.True(recycle.IsProtected);
        Assert.True(recycle.IsRecycleBin);

        var pagefile = LocationClassifier.Classify(
            @"C:\pagefile.sys", "pagefile.sys", AttributeFlags.Hidden | AttributeFlags.System, false);
        Assert.True(pagefile.IsProtected);
        Assert.False(pagefile.IsRecycleBin);
    }

    [Fact]
    public void Does_not_treat_normal_hidden_user_files_as_protected()
    {
        var desktopIni = LocationClassifier.Classify(
            @"C:\Users\Ada\Desktop\desktop.ini", "desktop.ini",
            AttributeFlags.Hidden | AttributeFlags.System, false);
        Assert.True(desktopIni.IsHidden);
        Assert.True(desktopIni.IsSystem);
        Assert.False(desktopIni.IsProtected);

        var movies = LocationClassifier.Classify(
            @"C:\Movies", "Movies", AttributeFlags.Directory, true);
        Assert.False(movies.IsProtected);
        Assert.False(movies.IsHidden);
    }

    [Fact]
    public void Access_denied_marks_protected()
    {
        var info = LocationClassifier.Classify(@"C:\locked", "locked", AttributeFlags.Directory, true, accessDenied: true);
        Assert.True(info.AccessDenied);
        Assert.True(info.IsProtected);
    }
}

public class ExcludeEvaluatorTests
{
    [Fact]
    public void Excludes_path_glob_and_extension()
    {
        var ev = new ExcludeEvaluator(
        [
            new() { Kind = ExcludeKind.PathPrefix, Pattern = @"C:\Windows" },
            new() { Kind = ExcludeKind.Glob, Pattern = "node_modules" },
            new() { Kind = ExcludeKind.Extension, Pattern = "tmp" }
        ], skipHidden: false, skipSystem: false);

        Assert.True(ev.ShouldExclude(@"C:\Windows\System32", "System32", true, 0, null));
        Assert.True(ev.ShouldExclude(@"D:\proj\node_modules", "node_modules", true, 0, null));
        Assert.True(ev.ShouldExclude(@"D:\a.tmp", "a.tmp", false, 0, null));
        Assert.False(ev.ShouldExclude(@"D:\a.txt", "a.txt", false, 0, null));
    }

    [Fact]
    public void Hidden_policy()
    {
        var ev = new ExcludeEvaluator([], skipHidden: true, skipSystem: true);
        Assert.True(ev.ShouldExclude(@"C:\x", "x", false, AttributeFlags.Hidden, null));
    }
}

public class ReparsePolicyTests
{
    [Fact]
    public void Does_not_recurse_reparse_directories()
    {
        var item = new FileSystemItem
        {
            FullPath = @"C:\link",
            Name = "link",
            IsDirectory = true,
            Attributes = AttributeFlags.Directory | AttributeFlags.ReparsePoint,
            ReparseTag = ReparsePolicy.IoReparseTagSymlink
        };
        Assert.False(ReparsePolicy.ShouldRecurseIntoDirectory(item));
    }
}

public class DragDropPolicyTests
{
    [Fact]
    public void Modifiers_match_windows_explorer()
    {
        Assert.Equal(DropAction.Move, DragDropPolicy.Resolve(false, false, false, sameVolume: true));
        Assert.Equal(DropAction.Copy, DragDropPolicy.Resolve(false, false, false, sameVolume: false));
        Assert.Equal(DropAction.Copy, DragDropPolicy.Resolve(control: true, shift: false, alt: false, sameVolume: true));
        Assert.Equal(DropAction.Move, DragDropPolicy.Resolve(control: false, shift: true, alt: false, sameVolume: false));
        Assert.Equal(DropAction.Link, DragDropPolicy.Resolve(control: false, shift: false, alt: true, sameVolume: true));
        Assert.Equal(DropAction.Link, DragDropPolicy.Resolve(control: true, shift: true, alt: false, sameVolume: false));
    }

    [Fact]
    public void Rejects_virtual_and_self_targets()
    {
        Assert.True(DragDropPolicy.IsInvalidTarget([@"C:\Docs"], LocationRoots.ThisPc));
        Assert.True(DragDropPolicy.IsInvalidTarget([@"C:\Docs"], @"C:\Docs"));
        Assert.True(DragDropPolicy.IsInvalidTarget([@"C:\Docs"], @"C:\Docs\sub"));
        Assert.False(DragDropPolicy.IsInvalidTarget([@"C:\Docs\file.txt"], @"C:\Docs"));
        Assert.False(DragDropPolicy.IsInvalidTarget([@"C:\Docs"], @"D:\Other"));
    }

    [Fact]
    public void Same_volume_uses_drive_or_unc_share()
    {
        Assert.True(PathRules.IsSameVolume(@"C:\a", @"C:\b"));
        Assert.False(PathRules.IsSameVolume(@"C:\a", @"D:\b"));
        Assert.True(PathRules.IsSameVolume(@"\\media\movies\a", @"\\media\movies\b"));
        Assert.False(PathRules.IsSameVolume(@"\\media\movies\a", @"\\media\tv\b"));
    }
}