// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.Completion;

internal class FileSystemCompletionHelper
{
    private static readonly char[] s_windowsDirectorySeparator = ['\\'];

    private readonly Glyph _folderGlyph;
    private readonly Glyph _fileGlyph;

    // absolute paths
    private readonly ImmutableArray<string> _searchPaths;
    private readonly string? _baseDirectory;

    private readonly ImmutableArray<string> _allowableExtensions;
    private readonly CompletionItemRules _itemRules;

    public FileSystemCompletionHelper(
        Glyph folderGlyph,
        Glyph fileGlyph,
        ImmutableArray<string> searchPaths,
        string? baseDirectory,
        ImmutableArray<string> allowableExtensions,
        CompletionItemRules itemRules)
    {
        Debug.Assert(searchPaths.All(PathUtilities.IsAbsolute));
        Debug.Assert(baseDirectory == null || PathUtilities.IsAbsolute(baseDirectory));

        _searchPaths = searchPaths;
        _baseDirectory = baseDirectory;
        _allowableExtensions = allowableExtensions;
        _folderGlyph = folderGlyph;
        _fileGlyph = fileGlyph;
        _itemRules = itemRules;
    }

    // virtual for testing
    protected virtual string[] GetLogicalDrives()
        => IOUtilities.PerformIO(Directory.GetLogicalDrives, []);

    // virtual for testing
    protected virtual bool DirectoryExists(string fullPath)
    {
        Debug.Assert(PathUtilities.IsAbsolute(fullPath));
        return Directory.Exists(fullPath);
    }

    // virtual for testing
    protected virtual IEnumerable<string> EnumerateDirectories(string fullDirectoryPath)
    {
        Debug.Assert(PathUtilities.IsAbsolute(fullDirectoryPath));
        return IOUtilities.PerformIO(() => Directory.EnumerateDirectories(fullDirectoryPath), []);
    }

    // virtual for testing
    protected virtual IEnumerable<string> EnumerateFiles(string fullDirectoryPath)
    {
        Debug.Assert(PathUtilities.IsAbsolute(fullDirectoryPath));
        return IOUtilities.PerformIO(() => Directory.EnumerateFiles(fullDirectoryPath), []);
    }

    // virtual for testing
    protected virtual bool IsVisibleFileSystemEntry(string fullPath)
    {
        Debug.Assert(PathUtilities.IsAbsolute(fullPath));
        return IOUtilities.PerformIO(() => (File.GetAttributes(fullPath) & (FileAttributes.Hidden | FileAttributes.System)) == 0, false);
    }

    private CompletionItem CreateNetworkRoot()
        => CommonCompletionItem.Create(
            "\\\\",
            displayTextSuffix: "",
            glyph: null,
            description: "\\\\".ToSymbolDisplayParts(),
            rules: _itemRules);

    private CompletionItem CreateUnixRoot()
        => CommonCompletionItem.Create(
            "/",
            displayTextSuffix: "",
            glyph: _folderGlyph,
            description: "/".ToSymbolDisplayParts(),
            rules: _itemRules);

    private CompletionItem CreateFileSystemEntryItem(string fullPath, bool isDirectory)
        => CommonCompletionItem.Create(
            PathUtilities.GetFileName(fullPath),
            displayTextSuffix: "",
            glyph: isDirectory ? _folderGlyph : _fileGlyph,
            description: fullPath.ToSymbolDisplayParts(),
            rules: _itemRules);

    private CompletionItem CreateLogicalDriveItem(string drive)
        => CommonCompletionItem.Create(
            drive,
            displayTextSuffix: "",
            glyph: _folderGlyph,
            description: drive.ToSymbolDisplayParts(),
            rules: _itemRules);

    public Task<ImmutableArray<CompletionItem>> GetItemsAsync(string directoryPath, CancellationToken cancellationToken)
        => Task.Run(() => GetItems(directoryPath, cancellationToken), cancellationToken);

    private ImmutableArray<CompletionItem> GetItems(string directoryPath, CancellationToken cancellationToken)
    {
        if (!PathUtilities.IsUnixLikePlatform && directoryPath == "\\")
        {
            // The user has typed only "\".  In this case, we want to add "\\" to the list.  
            return [CreateNetworkRoot()];
        }

        var result = ArrayBuilder<CompletionItem>.GetInstance();

        var pathKind = PathUtilities.GetPathKind(directoryPath);
        switch (pathKind)
        {
            case PathKind.Empty:
                // base directory
                if (_baseDirectory != null)
                {
                    result.AddRange(GetItemsInDirectory(_baseDirectory, cancellationToken));
                }

                // roots
                if (PathUtilities.IsUnixLikePlatform)
                {
                    result.AddRange(CreateUnixRoot());
                }
                else
                {
                    foreach (var drive in GetLogicalDrives())
                    {
                        result.Add(CreateLogicalDriveItem(drive.TrimEnd(s_windowsDirectorySeparator)));
                    }

                    result.Add(CreateNetworkRoot());
                }

                // entries on search paths
                foreach (var searchPath in _searchPaths)
                {
                    result.AddRange(GetItemsInDirectory(searchPath, cancellationToken));
                }

                break;

            case PathKind.Absolute:
            case PathKind.RelativeToCurrentDirectory:
            case PathKind.RelativeToCurrentParent:
            case PathKind.RelativeToCurrentRoot:
                var fullDirectoryPath = FileUtilities.ResolveRelativePath(directoryPath, basePath: null, baseDirectory: _baseDirectory);
                if (fullDirectoryPath != null)
                {
                    result.AddRange(GetItemsInDirectory(fullDirectoryPath, cancellationToken));
                }
                else
                {
                    // invalid path
                    result.Clear();
                }

                break;

            case PathKind.Relative:

                // base directory:
                if (_baseDirectory != null)
                {
                    result.AddRange(GetItemsInDirectory(PathUtilities.CombineAbsoluteAndRelativePaths(_baseDirectory, directoryPath)!, cancellationToken));
                }

                // search paths:
                foreach (var searchPath in _searchPaths)
                {
                    result.AddRange(GetItemsInDirectory(PathUtilities.CombineAbsoluteAndRelativePaths(searchPath, directoryPath)!, cancellationToken));
                }

                break;

            case PathKind.RelativeToDriveDirectory:
                // Paths "C:dir" are not supported, but when the path doesn't include any directory, i.e. "C:",
                // we return the drive itself.
                if (directoryPath.Length == 2)
                {
                    result.Add(CreateLogicalDriveItem(directoryPath));
                }

                break;

            default:
                throw ExceptionUtilities.UnexpectedValue(pathKind);
        }

        return result.ToImmutableAndFree();
    }

    private IEnumerable<CompletionItem> GetItemsInDirectory(string fullDirectoryPath, CancellationToken cancellationToken)
    {
        Debug.Assert(PathUtilities.IsAbsolute(fullDirectoryPath));

        cancellationToken.ThrowIfCancellationRequested();

        if (!DirectoryExists(fullDirectoryPath))
        {
            yield break;
        }

        cancellationToken.ThrowIfCancellationRequested();

        foreach (var directory in EnumerateDirectories(fullDirectoryPath))
        {
            if (IsVisibleFileSystemEntry(directory))
            {
                yield return CreateFileSystemEntryItem(directory, isDirectory: true);
            }
        }

        cancellationToken.ThrowIfCancellationRequested();

        foreach (var file in EnumerateFiles(fullDirectoryPath))
        {
            if (_allowableExtensions.Length != 0 &&
                !_allowableExtensions.Contains(
                    PathUtilities.GetExtension(file),
                    PathUtilities.IsUnixLikePlatform ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase))
            {
                continue;
            }

            cancellationToken.ThrowIfCancellationRequested();

            if (IsVisibleFileSystemEntry(file))
            {
                yield return CreateFileSystemEntryItem(file, isDirectory: false);
            }
        }
    }

    internal TestAccessor GetTestAccessor()
        => new(this);

    internal readonly struct TestAccessor(FileSystemCompletionHelper fileSystemCompletionHelper)
    {
        private readonly FileSystemCompletionHelper _fileSystemCompletionHelper = fileSystemCompletionHelper;

        internal ImmutableArray<CompletionItem> GetItems(string directoryPath, CancellationToken cancellationToken)
            => _fileSystemCompletionHelper.GetItems(directoryPath, cancellationToken);
    }
}