// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Razor.Language.Legacy;

namespace Microsoft.AspNetCore.Razor.Language.Syntax;

internal static partial class SyntaxFactory
{
    public static SyntaxToken Token(SyntaxKind kind, params RazorDiagnostic[] diagnostics)
        => Token(kind, content: string.Empty, parent: null, position: 0, index: 0, diagnostics: diagnostics);

    public static SyntaxToken Token(SyntaxKind kind, string content, params RazorDiagnostic[] diagnostics)
        => Token(kind, content, parent: null, position: 0, index: 0, diagnostics);

    public static SyntaxToken Token(
        SyntaxKind kind, SyntaxNode? parent, int position, params RazorDiagnostic[] diagnostics)
        => Token(kind, string.Empty, parent, position, index: 0, diagnostics);

    public static SyntaxToken Token(
        SyntaxKind kind, string content, SyntaxNode? parent, int position, params RazorDiagnostic[] diagnostics)
        => Token(kind, content, parent, position, index: 0, diagnostics);

    public static SyntaxToken Token(
        SyntaxKind kind, SyntaxNode? parent, int position, int index, params RazorDiagnostic[] diagnostics)
        => Token(kind, string.Empty, parent, position, index, diagnostics);

    public static SyntaxToken Token(
        SyntaxKind kind, string content, SyntaxNode? parent, int position, int index, params RazorDiagnostic[] diagnostics)
        => new(parent, InternalSyntax.SyntaxFactory.Token(kind, content, diagnostics), position, index);

    internal static SyntaxToken MissingToken(SyntaxKind kind, params RazorDiagnostic[] diagnostics)
        => new(parent: null, InternalSyntax.SyntaxFactory.MissingToken(kind, diagnostics), position: 0, index: 0);

    public static SyntaxList<TNode> List<TNode>()
        where TNode : SyntaxNode
        => default;

    public static SyntaxList<TNode> List<TNode>(TNode node)
        where TNode : SyntaxNode
        => new(node);

    public static SyntaxList<TNode> List<TNode>(params ReadOnlySpan<TNode> nodes)
        where TNode : SyntaxNode
        => SyntaxList.Create(nodes);

    public static SyntaxList<TNode> List<TNode>(IEnumerable<TNode> nodes)
        where TNode : SyntaxNode
        => SyntaxList.Create(nodes);

    public static SyntaxTokenList TokenList()
        => default;

    public static SyntaxTokenList TokenList(SyntaxToken token)
        => new(token);

    public static SyntaxTokenList TokenList(params ReadOnlySpan<SyntaxToken> tokens)
        => SyntaxList.Create(tokens);

    public static SyntaxTokenList TokenList(IEnumerable<SyntaxToken> tokens)
        => SyntaxList.Create(tokens);

    public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(
        SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler)
        => CSharpExpressionLiteral(new SyntaxTokenList(token), chunkGenerator, editHandler);

    public static MarkupTextLiteralSyntax MarkupTextLiteral(
        SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler)
        => MarkupTextLiteral(new SyntaxTokenList(token), chunkGenerator, editHandler);

    public static RazorMetaCodeSyntax RazorMetaCode(
        SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler)
        => RazorMetaCode(new SyntaxTokenList(token), chunkGenerator, editHandler);
}