// 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.Threading;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
using Microsoft.CodeAnalysis.CSharp.Syntax;
 
namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders;
 
internal class UsingKeywordRecommender : AbstractSyntacticSingleKeywordRecommender
{
    public UsingKeywordRecommender()
        : base(SyntaxKind.UsingKeyword)
    {
    }
 
    protected override bool IsValidContext(int position, CSharpSyntaxContext context, CancellationToken cancellationToken)
    {
        // cases:
        //  using (goo) { }
        //  using Goo;
        //  using Goo = Bar;
        //  await using (goo) { }
        return
            context.IsStatementContext ||
            context.IsGlobalStatementContext ||
            IsUsingDirectiveContext(context, forGlobalKeyword: false, cancellationToken) ||
            context.IsAwaitStatementContext(position, cancellationToken);
    }
 
    internal static bool IsUsingDirectiveContext(CSharpSyntaxContext context, bool forGlobalKeyword, CancellationToken cancellationToken)
    {
        // cases:
        // root: |
 
        // root: u|
 
        // extern alias a;
        // |
 
        // extern alias a;
        // u|
 
        // using Goo;
        // |
 
        // using Goo;
        // u|
 
        // using Goo = Bar;
        // |
 
        // using Goo = Bar;
        // u|
 
        // t valid:
        // namespace N {}
        // |
 
        // namespace N {}
        // u|
 
        // class C {}
        // |
 
        // class C {}
        // u|
 
        // |
        // extern alias a;
 
        // u|
        // extern alias a;
 
        var originalToken = context.LeftToken;
        var token = context.TargetToken;
 
        // root: u|
 
        // namespace N { u|
 
        // namespace N; u|
 
        // extern alias a;
        // u|
 
        // using Goo;
        // u|
 
        // using Goo = Bar;
        // u|
 
        // root: |
        if (token.Kind() == SyntaxKind.None)
        {
            // root namespace
 
            return IsValidContextAtTheRoot(context, originalToken, cancellationToken);
        }
 
        if ((token.Kind() == SyntaxKind.OpenBraceToken && token.Parent.IsKind(SyntaxKind.NamespaceDeclaration))
            || (token.Kind() == SyntaxKind.SemicolonToken && token.Parent.IsKind(SyntaxKind.FileScopedNamespaceDeclaration)))
        {
            // a child using can't come before externs
            var nextToken = originalToken.GetNextToken(includeSkipped: true);
            if (nextToken.Kind() == SyntaxKind.ExternKeyword)
            {
                return false;
            }
 
            return true;
        }
 
        // extern alias a;
        // |
 
        // using Goo;
        // |
        if (token.Kind() == SyntaxKind.SemicolonToken)
        {
            if (token.Parent is (kind: SyntaxKind.ExternAliasDirective or SyntaxKind.UsingDirective))
            {
                return true;
            }
        }
 
        // extern alias a;
        // global |
 
        // global using Goo;
        // global |
 
        // global |
        if (!forGlobalKeyword)
        {
            var previousToken = token.GetPreviousToken(includeSkipped: true);
            if (previousToken.Kind() == SyntaxKind.None)
            {
                // root namespace
                if (token.Kind() == SyntaxKind.GlobalKeyword)
                {
                    return true;
                }
                else if (token.Kind() == SyntaxKind.IdentifierToken && SyntaxFacts.GetContextualKeywordKind((string)token.Value!) == SyntaxKind.GlobalKeyword)
                {
                    return IsValidContextAtTheRoot(context, originalToken, cancellationToken);
                }
            }
            else if (previousToken.Kind() == SyntaxKind.SemicolonToken &&
                previousToken.Parent is (kind: SyntaxKind.ExternAliasDirective or SyntaxKind.UsingDirective))
            {
                if (token.Kind() == SyntaxKind.GlobalKeyword)
                {
                    return true;
                }
                else if (token.Kind() == SyntaxKind.IdentifierToken && SyntaxFacts.GetContextualKeywordKind((string)token.Value!) == SyntaxKind.GlobalKeyword)
                {
                    return true;
                }
            }
        }
 
        return false;
 
        static bool IsValidContextAtTheRoot(CSharpSyntaxContext context, SyntaxToken originalToken, CancellationToken cancellationToken)
        {
            // a using can't come before externs
            var nextToken = originalToken.GetNextToken(includeSkipped: true);
            if (nextToken.Kind() == SyntaxKind.ExternKeyword ||
                ((CompilationUnitSyntax)context.SyntaxTree.GetRoot(cancellationToken)).Externs.Count > 0)
            {
                return false;
            }
 
            return true;
        }
    }
}