// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

using System.Collections.Generic;
using System.Linq;
using System.Management.Automation;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.PowerShell.EditorServices.Services;
using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
using Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility;
using Microsoft.PowerShell.EditorServices.Services.Symbols;
using Microsoft.PowerShell.EditorServices.Services.TextDocument;
using Microsoft.PowerShell.EditorServices.Test;
using Microsoft.PowerShell.EditorServices.Test.Shared;
using Microsoft.PowerShell.EditorServices.Test.Shared.Definition;
using Microsoft.PowerShell.EditorServices.Test.Shared.Occurrences;
using Microsoft.PowerShell.EditorServices.Test.Shared.ParameterHint;
using Microsoft.PowerShell.EditorServices.Test.Shared.References;
using Microsoft.PowerShell.EditorServices.Test.Shared.SymbolDetails;
using Microsoft.PowerShell.EditorServices.Test.Shared.Symbols;
using OmniSharp.Extensions.LanguageServer.Protocol;
using OmniSharp.Extensions.LanguageServer.Protocol.Models;
using Xunit;

namespace PowerShellEditorServices.Test.Language
{
    [Trait("Category", "Symbols")]
    public class SymbolsServiceTests : IAsyncLifetime
    {
        private PsesInternalHost psesHost;
        private WorkspaceService workspace;
        private SymbolsService symbolsService;
        private static readonly bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);

        public async Task InitializeAsync()
        {
            psesHost = await PsesHostFactory.Create(NullLoggerFactory.Instance);
            workspace = new WorkspaceService(NullLoggerFactory.Instance);
            workspace.WorkspaceFolders.Add(new WorkspaceFolder
            {
                Uri = DocumentUri.FromFileSystemPath(TestUtilities.GetSharedPath("References"))
            });
            symbolsService = new SymbolsService(
                NullLoggerFactory.Instance,
                psesHost,
                psesHost,
                workspace,
                new ConfigurationService());
        }

        public async Task DisposeAsync()
        {
            psesHost.StopAsync();
            CommandHelpers.s_cmdletToAliasCache.Clear();
            CommandHelpers.s_aliasToCmdletCache.Clear();
        }

        private static void AssertIsRegion(
            ScriptRegion region,
            int startLineNumber,
            int startColumnNumber,
            int endLineNumber,
            int endColumnNumber)
        {
            Assert.Equal(startLineNumber, region.StartLineNumber);
            Assert.Equal(startColumnNumber, region.StartColumnNumber);
            Assert.Equal(endLineNumber, region.EndLineNumber);
            Assert.Equal(endColumnNumber, region.EndColumnNumber);
        }

        private ScriptFile GetScriptFile(ScriptRegion scriptRegion) => workspace.GetFile(TestUtilities.GetSharedPath(scriptRegion.File));

        private Task<ParameterSetSignatures> GetParamSetSignatures(ScriptRegion scriptRegion)
        {
            return symbolsService.FindParameterSetsInFileAsync(
                GetScriptFile(scriptRegion),
                scriptRegion.StartLineNumber,
                scriptRegion.StartColumnNumber);
        }

        private async Task<IEnumerable<SymbolReference>> GetDefinitions(ScriptRegion scriptRegion)
        {
            ScriptFile scriptFile = GetScriptFile(scriptRegion);

            // TODO: We should just use the name to find it.
            SymbolReference symbol = SymbolsService.FindSymbolAtLocation(
                scriptFile,
                scriptRegion.StartLineNumber,
                scriptRegion.StartColumnNumber);

            Assert.NotNull(symbol);

            IEnumerable<SymbolReference> symbols =
                await symbolsService.GetDefinitionOfSymbolAsync(scriptFile, symbol);

            return symbols.OrderBy((i) => i.ScriptRegion.ToRange().Start);
        }

        private async Task<SymbolReference> GetDefinition(ScriptRegion scriptRegion)
        {
            IEnumerable<SymbolReference> definitions = await GetDefinitions(scriptRegion);
            return definitions.FirstOrDefault();
        }

        private async Task<IEnumerable<SymbolReference>> GetReferences(ScriptRegion scriptRegion)
        {
            ScriptFile scriptFile = GetScriptFile(scriptRegion);

            SymbolReference symbol = SymbolsService.FindSymbolAtLocation(
                scriptFile,
                scriptRegion.StartLineNumber,
                scriptRegion.StartColumnNumber);

            Assert.NotNull(symbol);

            IEnumerable<SymbolReference> symbols =
                await symbolsService.ScanForReferencesOfSymbolAsync(symbol);

            return symbols.OrderBy((i) => i.ScriptRegion.ToRange().Start);
        }

        private IEnumerable<SymbolReference> GetOccurrences(ScriptRegion scriptRegion)
        {
            return SymbolsService
                .FindOccurrencesInFile(
                    GetScriptFile(scriptRegion),
                    scriptRegion.StartLineNumber,
                    scriptRegion.StartColumnNumber)
                .OrderBy(symbol => symbol.ScriptRegion.ToRange().Start)
                .ToArray();
        }

        private IEnumerable<SymbolReference> FindSymbolsInFile(ScriptRegion scriptRegion)
        {
            return symbolsService
                .FindSymbolsInFile(GetScriptFile(scriptRegion))
                .OrderBy(symbol => symbol.ScriptRegion.ToRange().Start);
        }

        [Fact]
        public async Task FindsParameterHintsOnCommand()
        {
            // TODO: Fix signatures to use parameters, not sets.
            ParameterSetSignatures signatures = await GetParamSetSignatures(FindsParameterSetsOnCommandData.SourceDetails);
            Assert.NotNull(signatures);
            Assert.Equal("Get-Process", signatures.CommandName);
            Assert.Equal(6, signatures.Signatures.Length);
        }

        [Fact]
        public async Task FindsCommandForParamHintsWithSpaces()
        {
            ParameterSetSignatures signatures = await GetParamSetSignatures(FindsParameterSetsOnCommandWithSpacesData.SourceDetails);
            Assert.NotNull(signatures);
            Assert.Equal("Write-Host", signatures.CommandName);
            Assert.Single(signatures.Signatures);
        }

        [Fact]
        public async Task FindsFunctionDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsFunctionDefinitionData.SourceDetails);
            Assert.Equal("fn My-Function", symbol.Id);
            Assert.Equal("function My-Function ($myInput)", symbol.Name);
            Assert.Equal(SymbolType.Function, symbol.Type);
            AssertIsRegion(symbol.NameRegion, 1, 10, 1, 21);
            AssertIsRegion(symbol.ScriptRegion, 1, 1, 4, 2);
            Assert.True(symbol.IsDeclaration);
        }

        [Fact]
        public async Task FindsFunctionDefinitionForAlias()
        {
            // TODO: Eventually we should get the aliases through the AST instead of relying on them
            // being defined in the runspace.
            await psesHost.ExecutePSCommandAsync(
                new PSCommand().AddScript("Set-Alias -Name My-Alias -Value My-Function"),
                CancellationToken.None);

            SymbolReference symbol = await GetDefinition(FindsFunctionDefinitionOfAliasData.SourceDetails);
            Assert.Equal("function My-Function ($myInput)", symbol.Name);
            Assert.Equal(SymbolType.Function, symbol.Type);
            AssertIsRegion(symbol.NameRegion, 1, 10, 1, 21);
            AssertIsRegion(symbol.ScriptRegion, 1, 1, 4, 2);
            Assert.True(symbol.IsDeclaration);
        }

        [Fact]
        public async Task FindsReferencesOnFunction()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnFunctionData.SourceDetails);
            Assert.Collection(symbols,
            (i) =>
            {
                Assert.Equal("fn My-Function", i.Id);
                Assert.Equal("function My-Function ($myInput)", i.Name);
                Assert.Equal(SymbolType.Function, i.Type);
                Assert.True(i.IsDeclaration);
            },
            (i) =>
            {
                Assert.Equal("fn My-Function", i.Id);
                Assert.Equal("My-Function", i.Name);
                Assert.Equal(SymbolType.Function, i.Type);
                Assert.EndsWith(FindsFunctionDefinitionInWorkspaceData.SourceDetails.File, i.FilePath);
                Assert.False(i.IsDeclaration);
            },
            (i) =>
            {
                Assert.Equal("fn My-Function", i.Id);
                Assert.Equal("My-Function", i.Name);
                Assert.Equal(SymbolType.Function, i.Type);
                Assert.False(i.IsDeclaration);
            },
            (i) =>
            {
                Assert.Equal("fn My-Function", i.Id);
                Assert.Equal("My-Function", i.Name);
                Assert.Equal(SymbolType.Function, i.Type);
                Assert.False(i.IsDeclaration);
            },
            (i) =>
            {
                Assert.Equal("fn My-Function", i.Id);
                Assert.Equal("$Function:My-Function", i.Name);
                Assert.Equal(SymbolType.Function, i.Type);
                Assert.False(i.IsDeclaration);
            });
        }

        [Fact]
        public async Task FindsReferenceAcrossMultiRootWorkspace()
        {
            workspace.WorkspaceFolders = new[] { "Debugging", "ParameterHints", "SymbolDetails" }
                .Select(i => new WorkspaceFolder
                {
                    Uri = DocumentUri.FromFileSystemPath(TestUtilities.GetSharedPath(i))
                }).ToList();

            SymbolReference symbol = new("fn Get-Process", SymbolType.Function);
            IEnumerable<SymbolReference> symbols = await symbolsService.ScanForReferencesOfSymbolAsync(symbol);
            Assert.Collection(symbols.OrderBy(i => i.FilePath),
                i => Assert.EndsWith("VariableTest.ps1", i.FilePath),
                i => Assert.EndsWith("ParamHints.ps1", i.FilePath),
                i => Assert.EndsWith("SymbolDetails.ps1", i.FilePath));
        }

        [Fact]
        public async Task FindsReferencesOnFunctionIncludingAliases()
        {
            // TODO: Same as in FindsFunctionDefinitionForAlias.
            await psesHost.ExecutePSCommandAsync(
                new PSCommand().AddScript("Set-Alias -Name My-Alias -Value My-Function"),
                CancellationToken.None);

            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnFunctionData.SourceDetails);

            Assert.Collection(symbols,
                (i) => AssertIsRegion(i.NameRegion, 1, 10, 1, 21),
                (i) => AssertIsRegion(i.NameRegion, 3, 1, 3, 12),
                (i) => AssertIsRegion(i.NameRegion, 3, 5, 3, 16),
                (i) => AssertIsRegion(i.NameRegion, 10, 1, 10, 12),
                // The alias.
                (i) =>
                {
                    AssertIsRegion(i.NameRegion, 20, 1, 20, 9);
                    Assert.Equal("fn My-Alias", i.Id);
                },
                (i) => AssertIsRegion(i.NameRegion, 22, 29, 22, 52));
        }

        [Fact]
        public async Task FindsFunctionDefinitionInWorkspace()
        {
            IEnumerable<SymbolReference> symbols = await GetDefinitions(FindsFunctionDefinitionInWorkspaceData.SourceDetails);
            SymbolReference symbol = Assert.Single(symbols);
            Assert.Equal("fn My-Function", symbol.Id);
            Assert.Equal("function My-Function ($myInput)", symbol.Name);
            Assert.True(symbol.IsDeclaration);
            Assert.EndsWith(FindsFunctionDefinitionData.SourceDetails.File, symbol.FilePath);
        }

        [Fact]
        public async Task FindsVariableDefinition()
        {
            IEnumerable<SymbolReference> definitions = await GetDefinitions(FindsVariableDefinitionData.SourceDetails);
            SymbolReference symbol = Assert.Single(definitions); // Even though it's re-assigned
            Assert.Equal("var things", symbol.Id);
            Assert.Equal("$things", symbol.Name);
            Assert.Equal(SymbolType.Variable, symbol.Type);
            Assert.True(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 6, 1, 6, 8);
        }

        [Fact]
        public async Task FindsTypedVariableDefinition()
        {
            IEnumerable<SymbolReference> definitions = await GetDefinitions(FindsTypedVariableDefinitionData.SourceDetails);
            SymbolReference symbol = Assert.Single(definitions);
            Assert.Equal("var hello", symbol.Id);
            Assert.Equal("$hello", symbol.Name);
            Assert.Equal(SymbolType.Variable, symbol.Type);
            Assert.True(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 24, 9, 24, 15);
        }

        [Fact]
        public async Task FindsReferencesOnVariable()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnVariableData.SourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("var things", i.Id);
                    Assert.Equal("$things", i.Name);
                    Assert.Equal(SymbolType.Variable, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("var things", i.Id);
                    Assert.Equal("$things", i.Name);
                    Assert.Equal(SymbolType.Variable, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("var things", i.Id);
                    Assert.Equal("$things", i.Name);
                    Assert.Equal(SymbolType.Variable, i.Type);
                    Assert.False(i.IsDeclaration);
                });

            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnVariableData.SourceDetails));
        }

        [Fact]
        public void FindsOccurrencesOnFunction()
        {
            IEnumerable<SymbolReference> symbols = GetOccurrences(FindsOccurrencesOnFunctionData.SourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("fn My-Function", i.Id);
                    Assert.Equal(SymbolType.Function, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("fn My-Function", i.Id);
                    Assert.Equal(SymbolType.Function, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("fn My-Function", i.Id);
                    Assert.Equal(SymbolType.Function, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("fn My-Function", i.Id);
                    Assert.Equal("$Function:My-Function", i.Name);
                    Assert.Equal(SymbolType.Function, i.Type);
                    Assert.False(i.IsDeclaration);
                });
        }

        [Fact]
        public void FindsOccurrencesOnParameter()
        {
            IEnumerable<SymbolReference> symbols = GetOccurrences(FindOccurrencesOnParameterData.SourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("var myInput", i.Id);
                    // TODO: Parameter names need work.
                    Assert.Equal("(parameter) [System.Object]$myInput", i.Name);
                    Assert.Equal(SymbolType.Parameter, i.Type);
                    AssertIsRegion(i.NameRegion, 1, 23, 1, 31);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("var myInput", i.Id);
                    Assert.Equal("$myInput", i.Name);
                    Assert.Equal(SymbolType.Variable, i.Type);
                    AssertIsRegion(i.NameRegion, 3, 17, 3, 25);
                    Assert.False(i.IsDeclaration);
                });
        }

        [Fact]
        public async Task FindsReferencesOnCommandWithAlias()
        {
            // NOTE: This doesn't use GetOccurrences as it's testing for aliases.
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnBuiltInCommandWithAliasData.SourceDetails);
            Assert.Collection(symbols.Where(
                (i) => i.FilePath
                        .EndsWith(FindsReferencesOnBuiltInCommandWithAliasData.SourceDetails.File)),
                (i) => Assert.Equal("fn Get-ChildItem", i.Id),
                (i) => Assert.Equal("fn gci", i.Id),
                (i) => Assert.Equal("fn dir", i.Id),
                (i) => Assert.Equal("fn Get-ChildItem", i.Id));
        }

        [Fact]
        public async Task FindsClassDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsTypeSymbolsDefinitionData.ClassSourceDetails);
            Assert.Equal("type SuperClass", symbol.Id);
            Assert.Equal("class SuperClass { }", symbol.Name);
            Assert.Equal(SymbolType.Class, symbol.Type);
            Assert.True(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 8, 7, 8, 17);
        }

        [Fact]
        public async Task FindsReferencesOnClass()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.ClassSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("type SuperClass", i.Id);
                    Assert.Equal("class SuperClass { }", i.Name);
                    Assert.Equal(SymbolType.Class, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type SuperClass", i.Id);
                    Assert.Equal("(type) SuperClass", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                });

            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnTypeSymbolsData.ClassSourceDetails));
        }

        [Fact]
        public async Task FindsEnumDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsTypeSymbolsDefinitionData.EnumSourceDetails);
            Assert.Equal("type MyEnum", symbol.Id);
            Assert.Equal("enum MyEnum { }", symbol.Name);
            Assert.Equal(SymbolType.Enum, symbol.Type);
            Assert.True(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 39, 6, 39, 12);
        }

        [Fact]
        public async Task FindsReferencesOnEnum()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.EnumSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("(type) MyEnum", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("enum MyEnum { }", i.Name);
                    Assert.Equal(SymbolType.Enum, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("(type) MyEnum", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("(type) MyEnum", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                });

            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnTypeSymbolsData.EnumSourceDetails));
        }

        [Fact]
        public async Task FindsTypeExpressionDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsTypeSymbolsDefinitionData.TypeExpressionSourceDetails);
            AssertIsRegion(symbol.NameRegion, 39, 6, 39, 12);
            Assert.Equal("type MyEnum", symbol.Id);
            Assert.Equal("enum MyEnum { }", symbol.Name);
            Assert.True(symbol.IsDeclaration);
        }

        [Fact]
        public async Task FindsReferencesOnTypeExpression()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.TypeExpressionSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("type SuperClass", i.Id);
                    Assert.Equal("class SuperClass { }", i.Name);
                    Assert.Equal(SymbolType.Class, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type SuperClass", i.Id);
                    Assert.Equal("(type) SuperClass", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                });

            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnTypeSymbolsData.TypeExpressionSourceDetails));
        }

        [Fact]
        public async Task FindsTypeConstraintDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsTypeSymbolsDefinitionData.TypeConstraintSourceDetails);
            AssertIsRegion(symbol.NameRegion, 39, 6, 39, 12);
            Assert.Equal("type MyEnum", symbol.Id);
            Assert.Equal("enum MyEnum { }", symbol.Name);
            Assert.True(symbol.IsDeclaration);
        }

        [Fact]
        public async Task FindsReferencesOnTypeConstraint()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.TypeConstraintSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("(type) MyEnum", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("enum MyEnum { }", i.Name);
                    Assert.Equal(SymbolType.Enum, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("(type) MyEnum", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type MyEnum", i.Id);
                    Assert.Equal("(type) MyEnum", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                });
        }

        [Fact]
        public void FindsOccurrencesOnTypeConstraint()
        {
            IEnumerable<SymbolReference> symbols = GetOccurrences(FindsOccurrencesOnTypeSymbolsData.TypeConstraintSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("type BaseClass", i.Id);
                    Assert.Equal("class BaseClass { }", i.Name);
                    Assert.Equal(SymbolType.Class, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("type BaseClass", i.Id);
                    Assert.Equal("(type) BaseClass", i.Name);
                    Assert.Equal(SymbolType.Type, i.Type);
                    Assert.False(i.IsDeclaration);
                });
        }

        [Fact]
        public async Task FindsConstructorDefinition()
        {
            IEnumerable<SymbolReference> symbols = await GetDefinitions(FindsTypeSymbolsDefinitionData.ConstructorSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("mtd SuperClass", i.Id);
                    Assert.Equal("SuperClass([string]$name)", i.Name);
                    Assert.Equal(SymbolType.Constructor, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("mtd SuperClass", i.Id);
                    Assert.Equal("SuperClass()", i.Name);
                    Assert.Equal(SymbolType.Constructor, i.Type);
                    Assert.True(i.IsDeclaration);
                });

            Assert.Equal(symbols, await GetReferences(FindsReferencesOnTypeSymbolsData.ConstructorSourceDetails));
            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnTypeSymbolsData.ConstructorSourceDetails));
        }

        [Fact]
        public async Task FindsMethodDefinition()
        {
            IEnumerable<SymbolReference> symbols = await GetDefinitions(FindsTypeSymbolsDefinitionData.MethodSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("mtd MyClassMethod", i.Id);
                    Assert.Equal("string MyClassMethod([string]$param1, $param2, [int]$param3)", i.Name);
                    Assert.Equal(SymbolType.Method, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("mtd MyClassMethod", i.Id);
                    Assert.Equal("string MyClassMethod([MyEnum]$param1)", i.Name);
                    Assert.Equal(SymbolType.Method, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("mtd MyClassMethod", i.Id);
                    Assert.Equal("string MyClassMethod()", i.Name);
                    Assert.Equal(SymbolType.Method, i.Type);
                    Assert.True(i.IsDeclaration);
                });
        }

        [Fact]
        public async Task FindsReferencesOnMethod()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.MethodSourceDetails);
            Assert.Collection(symbols,
                (i) => Assert.Equal("string MyClassMethod([string]$param1, $param2, [int]$param3)", i.Name),
                (i) => Assert.Equal("string MyClassMethod([MyEnum]$param1)", i.Name),
                (i) => Assert.Equal("string MyClassMethod()", i.Name),
                (i) => // The invocation!
                {
                    Assert.Equal("mtd MyClassMethod", i.Id);
                    Assert.Equal("(method) MyClassMethod", i.Name);
                    Assert.Equal("$o.MyClassMethod()", i.SourceLine);
                    Assert.Equal(SymbolType.Method, i.Type);
                    Assert.False(i.IsDeclaration);
                });

            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnTypeSymbolsData.MethodSourceDetails));
        }

        [Fact]
        public async Task FindsPropertyDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsTypeSymbolsDefinitionData.PropertySourceDetails);
            Assert.Equal("prop SomePropWithDefault", symbol.Id);
            Assert.Equal("[string] $SomePropWithDefault", symbol.Name);
            Assert.Equal(SymbolType.Property, symbol.Type);
            Assert.True(symbol.IsDeclaration);
        }

        [Fact]
        public async Task FindsReferencesOnProperty()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.PropertySourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("prop SomeProp", i.Id);
                    Assert.Equal("[int] $SomeProp", i.Name);
                    Assert.Equal(SymbolType.Property, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("prop SomeProp", i.Id);
                    Assert.Equal("(property) SomeProp", i.Name);
                    Assert.Equal(SymbolType.Property, i.Type);
                    Assert.False(i.IsDeclaration);
                });
        }

        [Fact]
        public void FindsOccurrencesOnProperty()
        {
            IEnumerable<SymbolReference> symbols = GetOccurrences(FindsOccurrencesOnTypeSymbolsData.PropertySourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("prop SomePropWithDefault", i.Id);
                    Assert.Equal("[string] $SomePropWithDefault", i.Name);
                    Assert.Equal(SymbolType.Property, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("prop SomePropWithDefault", i.Id);
                    Assert.Equal("(property) SomePropWithDefault", i.Name);
                    Assert.Equal(SymbolType.Property, i.Type);
                    Assert.False(i.IsDeclaration);
                });
        }

        [Fact]
        public async Task FindsEnumMemberDefinition()
        {
            SymbolReference symbol = await GetDefinition(FindsTypeSymbolsDefinitionData.EnumMemberSourceDetails);
            Assert.Equal("prop Second", symbol.Id);
            // Doesn't include [MyEnum]:: because that'd be redundant in the outline.
            Assert.Equal("Second", symbol.Name);
            Assert.Equal(SymbolType.EnumMember, symbol.Type);
            Assert.True(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 41, 5, 41, 11);

            symbol = await GetDefinition(FindsReferencesOnTypeSymbolsData.EnumMemberSourceDetails);
            Assert.Equal("prop First", symbol.Id);
            Assert.Equal("First", symbol.Name);
            Assert.Equal(SymbolType.EnumMember, symbol.Type);
            Assert.True(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 40, 5, 40, 10);
        }

        [Fact]
        public async Task FindsReferencesOnEnumMember()
        {
            IEnumerable<SymbolReference> symbols = await GetReferences(FindsReferencesOnTypeSymbolsData.EnumMemberSourceDetails);
            Assert.Collection(symbols,
                (i) =>
                {
                    Assert.Equal("prop First", i.Id);
                    Assert.Equal("First", i.Name);
                    Assert.Equal(SymbolType.EnumMember, i.Type);
                    Assert.True(i.IsDeclaration);
                },
                (i) =>
                {
                    Assert.Equal("prop First", i.Id);
                    // The reference is just a member invocation, and so indistinguishable from a property.
                    Assert.Equal("(property) First", i.Name);
                    Assert.Equal(SymbolType.Property, i.Type);
                    Assert.False(i.IsDeclaration);
                });

            Assert.Equal(symbols, GetOccurrences(FindsOccurrencesOnTypeSymbolsData.EnumMemberSourceDetails));
        }

        [Fact]
        public async Task FindsDetailsForBuiltInCommand()
        {
            SymbolDetails symbolDetails = await symbolsService.FindSymbolDetailsAtLocationAsync(
                GetScriptFile(FindsDetailsForBuiltInCommandData.SourceDetails),
                FindsDetailsForBuiltInCommandData.SourceDetails.StartLineNumber,
                FindsDetailsForBuiltInCommandData.SourceDetails.StartColumnNumber,
                CancellationToken.None);

            Assert.Equal("Extracts files from a specified archive (zipped) file.", symbolDetails.Documentation);
        }

        [Fact]
        public void FindsSymbolsInFile()
        {
            IEnumerable<SymbolReference> symbols = FindSymbolsInFile(FindSymbolsInMultiSymbolFile.SourceDetails);

            Assert.Equal(7, symbols.Count(i => i.Type == SymbolType.Function));
            Assert.Equal(8, symbols.Count(i => i.Type == SymbolType.Variable));
            Assert.Equal(4, symbols.Count(i => i.Type == SymbolType.Parameter));
            Assert.Equal(12, symbols.Count(i => i.Id.StartsWith("var ")));
            Assert.Equal(2, symbols.Count(i => i.Id.StartsWith("prop ")));

            SymbolReference symbol = symbols.First(i => i.Type == SymbolType.Function);
            Assert.Equal("fn AFunction", symbol.Id);
            Assert.Equal("function script:AFunction ()", symbol.Name);
            Assert.True(symbol.IsDeclaration);
            Assert.Equal(2, GetOccurrences(symbol.NameRegion).Count());

            symbol = symbols.First(i => i.Id == "fn AFilter");
            Assert.Equal("filter AFilter ()", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = symbols.Last(i => i.Type == SymbolType.Variable);
            Assert.Equal("var nestedVar", symbol.Id);
            Assert.Equal("$nestedVar", symbol.Name);
            Assert.False(symbol.IsDeclaration);
            AssertIsRegion(symbol.NameRegion, 16, 29, 16, 39);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Workflow);
            Assert.Equal("fn AWorkflow", symbol.Id);
            Assert.Equal("workflow AWorkflow ()", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Class);
            Assert.Equal("type AClass", symbol.Id);
            Assert.Equal("class AClass { }", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Property);
            Assert.Equal("prop AProperty", symbol.Id);
            Assert.Equal("[string] $AProperty", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Constructor);
            Assert.Equal("mtd AClass", symbol.Id);
            Assert.Equal("AClass([string]$AParameter)", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Method);
            Assert.Equal("mtd AMethod", symbol.Id);
            Assert.Equal("void AMethod([string]$param1, [int]$param2, $param3)", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Enum);
            Assert.Equal("type AEnum", symbol.Id);
            Assert.Equal("enum AEnum { }", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.EnumMember);
            Assert.Equal("prop AValue", symbol.Id);
            Assert.Equal("AValue", symbol.Name);
            Assert.True(symbol.IsDeclaration);

            // There should be no region symbols unless the provider has been registered.
            Assert.DoesNotContain(symbols, i => i.Type == SymbolType.Region);
        }

        [Fact]
        public void FindsRegionsInFile()
        {
            symbolsService.TryRegisterDocumentSymbolProvider(new RegionDocumentSymbolProvider());
            IEnumerable<SymbolReference> symbols = FindSymbolsInFile(FindSymbolsInMultiSymbolFile.SourceDetails);
            Assert.Collection(symbols.Where(i => i.Type == SymbolType.Region),
                 (i) =>
                 {
                     Assert.Equal("region find me outer", i.Id);
                     Assert.Equal("#region find me outer", i.Name);
                     Assert.Equal(SymbolType.Region, i.Type);
                     Assert.True(i.IsDeclaration);
                     AssertIsRegion(i.NameRegion, 51, 1, 51, 22);
                     AssertIsRegion(i.ScriptRegion, 51, 1, 55, 11);
                 },
                 (i) =>
                 {
                     Assert.Equal("region find me inner", i.Id);
                     Assert.Equal("#region find me inner", i.Name);
                     Assert.Equal(SymbolType.Region, i.Type);
                     Assert.True(i.IsDeclaration);
                     AssertIsRegion(i.NameRegion, 52, 1, 52, 22);
                     AssertIsRegion(i.ScriptRegion, 52, 1, 54, 11);
                 });
        }

        [Fact]
        public void FindsSymbolsWithNewLineInFile()
        {
            IEnumerable<SymbolReference> symbols = FindSymbolsInFile(FindSymbolsInNewLineSymbolFile.SourceDetails);

            SymbolReference symbol = Assert.Single(symbols, i => i.Type == SymbolType.Function);
            Assert.Equal("fn returnTrue", symbol.Id);
            AssertIsRegion(symbol.NameRegion, 2, 1, 2, 11);
            AssertIsRegion(symbol.ScriptRegion, 1, 1, 4, 2);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Class);
            Assert.Equal("type NewLineClass", symbol.Id);
            AssertIsRegion(symbol.NameRegion, 7, 1, 7, 13);
            AssertIsRegion(symbol.ScriptRegion, 6, 1, 23, 2);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Constructor);
            Assert.Equal("mtd NewLineClass", symbol.Id);
            AssertIsRegion(symbol.NameRegion, 8, 5, 8, 17);
            AssertIsRegion(symbol.ScriptRegion, 8, 5, 10, 6);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Property);
            Assert.Equal("prop SomePropWithDefault", symbol.Id);
            AssertIsRegion(symbol.NameRegion, 15, 5, 15, 25);
            AssertIsRegion(symbol.ScriptRegion, 12, 5, 15, 40);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Method);
            Assert.Equal("mtd MyClassMethod", symbol.Id);
            Assert.Equal("string MyClassMethod([MyNewLineEnum]$param1)", symbol.Name);
            AssertIsRegion(symbol.NameRegion, 20, 5, 20, 18);
            AssertIsRegion(symbol.ScriptRegion, 17, 5, 22, 6);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.Enum);
            Assert.Equal("type MyNewLineEnum", symbol.Id);
            AssertIsRegion(symbol.NameRegion, 26, 1, 26, 14);
            AssertIsRegion(symbol.ScriptRegion, 25, 1, 28, 2);

            symbol = Assert.Single(symbols, i => i.Type == SymbolType.EnumMember);
            Assert.Equal("prop First", symbol.Id);
            AssertIsRegion(symbol.NameRegion, 27, 5, 27, 10);
            AssertIsRegion(symbol.ScriptRegion, 27, 5, 27, 10);
        }

        [SkippableFact]
        public void FindsSymbolsInDSCFile()
        {
            Skip.If(!isWindows, "DSC only works properly on Windows.");

            IEnumerable<SymbolReference> symbols = FindSymbolsInFile(FindSymbolsInDSCFile.SourceDetails);
            SymbolReference symbol = Assert.Single(symbols, i => i.Type == SymbolType.Configuration);
            // The prefix "dsc" is added for sorting reasons.
            Assert.Equal("dsc AConfiguration", symbol.Id);
            Assert.Equal(2, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(1, symbol.ScriptRegion.StartColumnNumber);
        }

        [Fact]
        public void FindsSymbolsInPesterFile()
        {
            IEnumerable<PesterSymbolReference> symbols = FindSymbolsInFile(FindSymbolsInPesterFile.SourceDetails).OfType<PesterSymbolReference>();
            Assert.Equal(12, symbols.Count(i => i.Type == SymbolType.Function));

            SymbolReference symbol = Assert.Single(symbols, i => i.Command == PesterCommandType.Describe);
            Assert.Equal("Describe \"Testing Pester symbols\"", symbol.Id);
            Assert.Equal(9, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(1, symbol.ScriptRegion.StartColumnNumber);

            symbol = Assert.Single(symbols, i => i.Command == PesterCommandType.Context);
            Assert.Equal("Context \"When a Pester file is given\"", symbol.Id);
            Assert.Equal(10, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(5, symbol.ScriptRegion.StartColumnNumber);

            Assert.Equal(4, symbols.Count(i => i.Command == PesterCommandType.It));
            symbol = symbols.Last(i => i.Command == PesterCommandType.It);
            Assert.Equal("It \"Should return setup and teardown symbols\"", symbol.Id);
            Assert.Equal(31, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(9, symbol.ScriptRegion.StartColumnNumber);

            symbol = Assert.Single(symbols, i => i.Command == PesterCommandType.BeforeDiscovery);
            Assert.Equal("BeforeDiscovery", symbol.Id);
            Assert.Equal(1, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(1, symbol.ScriptRegion.StartColumnNumber);

            Assert.Equal(2, symbols.Count(i => i.Command == PesterCommandType.BeforeAll));
            symbol = symbols.Last(i => i.Command == PesterCommandType.BeforeAll);
            Assert.Equal("BeforeAll", symbol.Id);
            Assert.Equal(11, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(9, symbol.ScriptRegion.StartColumnNumber);

            symbol = Assert.Single(symbols, i => i.Command == PesterCommandType.BeforeEach);
            Assert.Equal("BeforeEach", symbol.Id);
            Assert.Equal(15, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(9, symbol.ScriptRegion.StartColumnNumber);

            symbol = Assert.Single(symbols, i => i.Command == PesterCommandType.AfterEach);
            Assert.Equal("AfterEach", symbol.Id);
            Assert.Equal(35, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(9, symbol.ScriptRegion.StartColumnNumber);

            symbol = Assert.Single(symbols, i => i.Command == PesterCommandType.AfterAll);
            Assert.Equal("AfterAll", symbol.Id);
            Assert.Equal(40, symbol.ScriptRegion.StartLineNumber);
            Assert.Equal(5, symbol.ScriptRegion.StartColumnNumber);
        }

        [Fact]
        public void FindsSymbolsInPSKoansFile()
        {
            IEnumerable<PesterSymbolReference> symbols = FindSymbolsInFile(FindSymbolsInPSKoansFile.SourceDetails).OfType<PesterSymbolReference>();

            // Pester symbols are properly tested in FindsSymbolsInPesterFile so only counting to make sure they appear
            Assert.Equal(7, symbols.Count(i => i.Type == SymbolType.Function));
        }

        [Fact]
        public void FindsSymbolsInPSDFile()
        {
            IEnumerable<SymbolReference> symbols = FindSymbolsInFile(FindSymbolsInPSDFile.SourceDetails);
            Assert.All(symbols, i => Assert.Equal(SymbolType.HashtableKey, i.Type));
            Assert.Collection(symbols,
                i => Assert.Equal("property1", i.Id),
                i => Assert.Equal("property2", i.Id),
                i => Assert.Equal("property3", i.Id));
        }

        [Fact]
        public void FindsSymbolsInNoSymbolsFile()
        {
            IEnumerable<SymbolReference> symbolsResult = FindSymbolsInFile(FindSymbolsInNoSymbolsFile.SourceDetails);
            Assert.Empty(symbolsResult);
        }
    }
}