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

#nullable disable

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

namespace Microsoft.AspNetCore.Razor.Language;

internal static class RazorDiagnosticFactory
{
    private const string DiagnosticPrefix = "RZ";

    #region General Errors

    // General Errors ID Offset = 0

    internal static readonly RazorDiagnosticDescriptor Directive_BlockDirectiveCannotBeImported =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}0000",
            () => Resources.BlockDirectiveCannotBeImported,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateDirective_BlockDirectiveCannotBeImported(string directive)
    {
        return RazorDiagnostic.Create(Directive_BlockDirectiveCannotBeImported, SourceSpan.Undefined, directive);
    }

    #endregion

    #region Language Errors

    // Language Errors ID Offset = 1000

    internal static readonly RazorDiagnosticDescriptor Parsing_UnterminatedStringLiteral =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1000",
            () => Resources.ParseError_Unterminated_String_Literal,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnterminatedStringLiteral(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_UnterminatedStringLiteral, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_BlockCommentNotTerminated =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1001",
            () => Resources.ParseError_BlockComment_Not_Terminated,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_BlockCommentNotTerminated(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_BlockCommentNotTerminated, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_HelperDirectiveNotAvailable =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1002",
            () => Resources.ParseError_HelperDirectiveNotAvailable,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_HelperDirectiveNotAvailable(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_HelperDirectiveNotAvailable, location, SyntaxConstants.CSharp.HelperKeyword);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedWhiteSpaceAtStartOfCodeBlock =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1003",
            () => Resources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedWhiteSpaceAtStartOfCodeBlock(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedWhiteSpaceAtStartOfCodeBlock, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedEndOfFileAtStartOfCodeBlock =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1004",
            () => Resources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedEndOfFileAtStartOfCodeBlock(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedEndOfFileAtStartOfCodeBlock, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedCharacterAtStartOfCodeBlock =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1005",
            () => Resources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedCharacterAtStartOfCodeBlock(SourceSpan location, string content)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedCharacterAtStartOfCodeBlock, location, content);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_ExpectedEndOfBlockBeforeEOF =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1006",
            () => Resources.ParseError_Expected_EndOfBlock_Before_EOF,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_ExpectedEndOfBlockBeforeEOF(SourceSpan location, string blockName, string closeBlock, string openBlock)
    {
        return RazorDiagnostic.Create(Parsing_ExpectedEndOfBlockBeforeEOF, location, blockName, closeBlock, openBlock);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_ReservedWord =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1007",
            () => Resources.ParseError_ReservedWord,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_ReservedWord(SourceSpan location, string content)
    {
        return RazorDiagnostic.Create(Parsing_ReservedWord, location, content);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_SingleLineControlFlowStatementsNotAllowed =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1008",
            () => Resources.ParseError_SingleLine_ControlFlowStatements_CannotContainMarkup,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_SingleLineControlFlowStatementsCannotContainMarkup(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_SingleLineControlFlowStatementsNotAllowed, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_AtInCodeMustBeFollowedByColonParenOrIdentifierStart =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1009",
            () => Resources.ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_AtInCodeMustBeFollowedByColonParenOrIdentifierStart(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_AtInCodeMustBeFollowedByColonParenOrIdentifierStart, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedNestedCodeBlock =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1010",
            () => Resources.ParseError_Unexpected_Nested_CodeBlock,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedNestedCodeBlock(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedNestedCodeBlock, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveTokensMustBeSeparatedByWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1011",
            () => Resources.DirectiveTokensMustBeSeparatedByWhitespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveTokensMustBeSeparatedByWhitespace(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveTokensMustBeSeparatedByWhitespace, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedEOFAfterDirective =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1012",
            () => Resources.UnexpectedEOFAfterDirective,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedEOFAfterDirective(SourceSpan location, string directiveName, string expectedToken)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedEOFAfterDirective, location, directiveName, expectedToken);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsTypeName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1013",
            () => Resources.DirectiveExpectsTypeName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsTypeName(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsTypeName, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsNamespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1014",
            () => Resources.DirectiveExpectsNamespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsNamespace(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsNamespace, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsIdentifier =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1015",
            () => Resources.DirectiveExpectsIdentifier,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsIdentifier(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsIdentifier, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsQuotedStringLiteral =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1016",
            () => Resources.DirectiveExpectsQuotedStringLiteral,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsQuotedStringLiteral(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsQuotedStringLiteral, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedDirectiveLiteral =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1017",
            () => Resources.UnexpectedDirectiveLiteral,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedDirectiveLiteral(SourceSpan location, string directiveName, string expected)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedDirectiveLiteral, location, directiveName, expected);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveMustHaveValue =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1018",
            () => Resources.ParseError_DirectiveMustHaveValue,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveMustHaveValue(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveMustHaveValue, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_IncompleteQuotesAroundDirective =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1019",
            () => Resources.ParseError_IncompleteQuotesAroundDirective,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_IncompleteQuotesAroundDirective(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_IncompleteQuotesAroundDirective, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_InvalidTagHelperPrefixValue =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1020",
            () => Resources.InvalidTagHelperPrefixValue,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_InvalidTagHelperPrefixValue(SourceSpan location, string directiveName, char character, string prefix)
    {
        return RazorDiagnostic.Create(Parsing_InvalidTagHelperPrefixValue, location, directiveName, character, prefix);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_MarkupBlockMustStartWithTag =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1021",
            () => Resources.ParseError_MarkupBlock_Must_Start_With_Tag,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_MarkupBlockMustStartWithTag(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_MarkupBlockMustStartWithTag, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_OuterTagMissingName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1022",
            () => Resources.ParseError_OuterTagMissingName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_OuterTagMissingName(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_OuterTagMissingName, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TextTagCannotContainAttributes =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1023",
            () => Resources.ParseError_TextTagCannotContainAttributes,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TextTagCannotContainAttributes(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_TextTagCannotContainAttributes, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnfinishedTag =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1024",
            () => Resources.ParseError_UnfinishedTag,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnfinishedTag(SourceSpan location, string tagName)
    {
        return RazorDiagnostic.Create(Parsing_UnfinishedTag, location, tagName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_MissingEndTag =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1025",
            () => Resources.ParseError_MissingEndTag,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_MissingEndTag(SourceSpan location, string tagName)
    {
        return RazorDiagnostic.Create(Parsing_MissingEndTag, location, tagName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedEndTag =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1026",
            () => Resources.ParseError_UnexpectedEndTag,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedEndTag(SourceSpan location, string tagName)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedEndTag, location, tagName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_ExpectedCloseBracketBeforeEOF =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1027",
            () => Resources.ParseError_Expected_CloseBracket_Before_EOF,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_ExpectedCloseBracketBeforeEOF(SourceSpan location, string openBrace, string closeBrace)
    {
        return RazorDiagnostic.Create(Parsing_ExpectedCloseBracketBeforeEOF, location, openBrace, closeBrace);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_RazorCommentNotTerminated =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1028",
            () => Resources.ParseError_RazorComment_Not_Terminated,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_RazorCommentNotTerminated(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_RazorCommentNotTerminated, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelperIndexerAttributeNameMustIncludeKey =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1029",
            () => Resources.TagHelperBlockRewriter_IndexerAttributeNameMustIncludeKey,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelperIndexerAttributeNameMustIncludeKey(SourceSpan location, string attributeName, string tagName)
    {
        return RazorDiagnostic.Create(Parsing_TagHelperIndexerAttributeNameMustIncludeKey, location, attributeName, tagName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelperAttributeListMustBeWellFormed =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1030",
            () => Resources.TagHelperBlockRewriter_TagHelperAttributeListMustBeWellFormed,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelperAttributeListMustBeWellFormed(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_TagHelperAttributeListMustBeWellFormed, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelpersCannotHaveCSharpInTagDeclaration =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1031",
            () => Resources.TagHelpers_CannotHaveCSharpInTagDeclaration,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelpersCannotHaveCSharpInTagDeclaration(SourceSpan location, string tagName)
    {
        return RazorDiagnostic.Create(Parsing_TagHelpersCannotHaveCSharpInTagDeclaration, location, tagName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelperAttributesMustHaveAName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1032",
            () => Resources.TagHelpers_AttributesMustHaveAName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelperAttributesMustHaveAName(SourceSpan location, string tagName)
    {
        return RazorDiagnostic.Create(Parsing_TagHelperAttributesMustHaveAName, location, tagName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelperMustNotHaveAnEndTag =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1033",
            () => Resources.TagHelperParseTreeRewriter_EndTagTagHelperMustNotHaveAnEndTag,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelperMustNotHaveAnEndTag(SourceSpan location, string tagName, string displayName, TagStructure tagStructure)
    {
        var diagnostic = RazorDiagnostic.Create(
            Parsing_TagHelperMustNotHaveAnEndTag,
            location,
            tagName,
            displayName,
            tagStructure);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelperFoundMalformedTagHelper =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1034",
            () => Resources.TagHelpersParseTreeRewriter_FoundMalformedTagHelper,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelperFoundMalformedTagHelper(SourceSpan location, string tagName)
    {
        var diagnostic = RazorDiagnostic.Create(
            Parsing_TagHelperFoundMalformedTagHelper,
            location,
            tagName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_TagHelperMissingCloseAngle =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1035",
            () => Resources.TagHelpersParseTreeRewriter_MissingCloseAngle,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_TagHelperMissingCloseAngle(SourceSpan location, string tagName)
    {
        var diagnostic = RazorDiagnostic.Create(
            Parsing_TagHelperMissingCloseAngle,
            location,
            tagName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_InvalidTagHelperLookupText =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1036",
            () => Resources.InvalidTagHelperLookupText,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_InvalidTagHelperLookupText(SourceSpan location, string lookupText)
    {
        return RazorDiagnostic.Create(Parsing_InvalidTagHelperLookupText, location, lookupText);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsCSharpAttribute =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1037",
            () => Resources.DirectiveExpectsCSharpAttribute,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsCSharpAttribute(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsCSharpAttribute, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsBooleanLiteral =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1038",
            () => Resources.DirectiveExpectsBooleanLiteral,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsBooleanLiteral(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsBooleanLiteral, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_GenericTypeParameterIdentifierMismatch =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1039",
            () => Resources.DirectiveGenericTypeParameterIdentifierMismatch,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_GenericTypeParameterIdentifierMismatch(SourceSpan location, string directiveName, string constraintIdentifier, string originalMember)
    {
        return RazorDiagnostic.Create(Parsing_GenericTypeParameterIdentifierMismatch, location, directiveName, constraintIdentifier, originalMember);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_UnexpectedIdentifier =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1040",
            () => Resources.ParseError_Unexpected_Identifier_At_Position,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_UnexpectedIdentifier(SourceSpan location, string content, params string[] options)
    {
        return RazorDiagnostic.Create(Parsing_UnexpectedIdentifier, location, content, string.Join(", ", options));
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveExpectsIdentifierOrExpression =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}1041",
            () => Resources.DirectiveExpectsIdentifierOrExpression,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveExpectsIdentifierOrExpression(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveExpectsIdentifierOrExpression, location, directiveName);
    }

    #endregion

    #region Semantic Errors

    // Semantic Errors ID Offset = 2000

    internal static readonly RazorDiagnosticDescriptor CodeTarget_UnsupportedExtension =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2000",
            () => Resources.Diagnostic_CodeTarget_UnsupportedExtension,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateCodeTarget_UnsupportedExtension(string documentKind, Type extensionType)
    {
        return RazorDiagnostic.Create(CodeTarget_UnsupportedExtension, SourceSpan.Undefined, documentKind, extensionType.Name);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DuplicateDirective =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2001",
            () => Resources.DuplicateDirective,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DuplicateDirective(SourceSpan location, string directive)
    {
        return RazorDiagnostic.Create(Parsing_DuplicateDirective, location, directive);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_SectionsCannotBeNested =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2002",
            () => Resources.ParseError_Sections_Cannot_Be_Nested,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_SectionsCannotBeNested(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_SectionsCannotBeNested, location, Resources.SectionExample);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_InlineMarkupBlocksCannotBeNested =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2003",
            () => Resources.ParseError_InlineMarkup_Blocks_Cannot_Be_Nested,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_InlineMarkupBlocksCannotBeNested(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_InlineMarkupBlocksCannotBeNested, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_NamespaceImportAndTypeAliasCannotExistWithinCodeBlock =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2004",
            () => Resources.ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_NamespaceImportAndTypeAliasCannotExistWithinCodeBlock(SourceSpan location)
    {
        return RazorDiagnostic.Create(Parsing_NamespaceImportAndTypeAliasCannotExistWithinCodeBlock, location);
    }

    internal static readonly RazorDiagnosticDescriptor Parsing_DirectiveMustAppearAtStartOfLine =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2005",
            () => Resources.DirectiveMustAppearAtStartOfLine,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateParsing_DirectiveMustAppearAtStartOfLine(SourceSpan location, string directiveName)
    {
        return RazorDiagnostic.Create(Parsing_DirectiveMustAppearAtStartOfLine, location, directiveName);
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_CodeBlocksNotSupportedInAttributes =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2006",
            () => Resources.TagHelpers_CodeBlocks_NotSupported_InAttributes,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_CodeBlocksNotSupportedInAttributes(SourceSpan location)
    {
        var diagnostic = RazorDiagnostic.Create(TagHelper_CodeBlocksNotSupportedInAttributes, location);
        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InlineMarkupBlocksNotSupportedInAttributes =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2007",
            () => Resources.TagHelpers_InlineMarkupBlocks_NotSupported_InAttributes,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InlineMarkupBlocksNotSupportedInAttributes(SourceSpan location, string expectedTypeName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InlineMarkupBlocksNotSupportedInAttributes,
            location,
            expectedTypeName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_EmptyBoundAttribute =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2008",
            () => Resources.RewriterError_EmptyTagHelperBoundAttribute,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_EmptyBoundAttribute(SourceSpan location, string attributeName, string tagName, string propertyTypeName)
    {
        return RazorDiagnostic.Create(TagHelper_EmptyBoundAttribute, location, attributeName, tagName, propertyTypeName);
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_CannotHaveNonTagContent =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2009",
            () => Resources.TagHelperParseTreeRewriter_CannotHaveNonTagContent,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_CannotHaveNonTagContent(SourceSpan location, string tagName, string allowedChildren)
    {
        return RazorDiagnostic.Create(TagHelper_CannotHaveNonTagContent, location, tagName, allowedChildren);
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidNestedTag =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2010",
            () => Resources.TagHelperParseTreeRewriter_InvalidNestedTag,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidNestedTag(SourceSpan location, string tagName, string parent, string allowedChildren)
    {
        return RazorDiagnostic.Create(TagHelper_InvalidNestedTag, location, tagName, parent, allowedChildren);
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InconsistentTagStructure =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2011",
            () => Resources.TagHelperParseTreeRewriter_InconsistentTagStructure,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InconsistentTagStructure(SourceSpan location, string firstDescriptor, string secondDescriptor, string tagName)
    {
        return RazorDiagnostic.Create(TagHelper_InconsistentTagStructure, location, firstDescriptor, secondDescriptor, tagName, nameof(TagMatchingRuleDescriptor.TagStructure));
    }

    internal static readonly RazorDiagnosticDescriptor Component_EditorRequiredParameterNotSpecified =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}2012",
            () => Resources.Component_EditorRequiredParameterNotSpecified,
            RazorDiagnosticSeverity.Warning);

    public static RazorDiagnostic CreateComponent_EditorRequiredParameterNotSpecified(SourceSpan location, string tagName, string parameterName)
    {
        return RazorDiagnostic.Create(Component_EditorRequiredParameterNotSpecified, location, tagName, parameterName);
    }

    #endregion

    #region TagHelper Errors

    // TagHelper Errors ID Offset = 3000

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidRestrictedChildNullOrWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3000",
            () => Resources.TagHelper_InvalidRestrictedChildNullOrWhitespace,
            RazorDiagnosticSeverity.Error);

    public static RazorDiagnostic CreateTagHelper_InvalidRestrictedChildNullOrWhitespace(string tagHelperDisplayName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidRestrictedChildNullOrWhitespace,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidRestrictedChild =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3001",
            () => Resources.TagHelper_InvalidRestrictedChild,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidRestrictedChild(string tagHelperDisplayName, string restrictedChild, char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidRestrictedChild,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            restrictedChild,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributeNullOrWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3002",
            () => Resources.TagHelper_InvalidBoundAttributeNullOrWhitespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributeNullOrWhitespace(string tagHelperDisplayName, string propertyDisplayName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributeNullOrWhitespace,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributeName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3003",
            () => Resources.TagHelper_InvalidBoundAttributeName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributeName(
        string tagHelperDisplayName,
        string propertyDisplayName,
        string invalidName,
        char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributeName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName,
            invalidName,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributeNameStartsWith =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3004",
            () => Resources.TagHelper_InvalidBoundAttributeNameStartsWith,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributeNameStartsWith(
        string tagHelperDisplayName,
        string propertyDisplayName,
        string invalidName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributeNameStartsWith,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName,
            invalidName,
            "data-");

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributePrefix =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3005",
            () => Resources.TagHelper_InvalidBoundAttributePrefix,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributePrefix(
        string tagHelperDisplayName,
        string propertyDisplayName,
        string invalidName,
        char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributePrefix,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName,
            invalidName,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributePrefixStartsWith =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3006",
            () => Resources.TagHelper_InvalidBoundAttributePrefixStartsWith,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributePrefixStartsWith(
        string tagHelperDisplayName,
        string propertyDisplayName,
        string invalidName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributePrefixStartsWith,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName,
            invalidName,
            "data-");

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidTargetedTagNameNullOrWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3007",
            () => Resources.TagHelper_InvalidTargetedTagNameNullOrWhitespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidTargetedTagNameNullOrWhitespace()
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidTargetedTagNameNullOrWhitespace,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0));

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidTargetedTagName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3008",
            () => Resources.TagHelper_InvalidTargetedTagName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidTargetedTagName(string invalidTagName, char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidTargetedTagName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            invalidTagName,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidTargetedParentTagNameNullOrWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3009",
            () => Resources.TagHelper_InvalidTargetedParentTagNameNullOrWhitespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidTargetedParentTagNameNullOrWhitespace()
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidTargetedParentTagNameNullOrWhitespace,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0));

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidTargetedParentTagName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3010",
            () => Resources.TagHelper_InvalidTargetedParentTagName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidTargetedParentTagName(string invalidTagName, char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidTargetedParentTagName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            invalidTagName,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidTargetedAttributeNameNullOrWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3011",
            () => Resources.TagHelper_InvalidTargetedAttributeNameNullOrWhitespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidTargetedAttributeNameNullOrWhitespace()
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidTargetedAttributeNameNullOrWhitespace,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0));

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidTargetedAttributeName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3012",
            () => Resources.TagHelper_InvalidTargetedAttributeName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidTargetedAttributeName(string invalidAttributeName, char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidTargetedAttributeName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            invalidAttributeName,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributeParameterNullOrWhitespace =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3013",
            () => Resources.TagHelper_InvalidBoundAttributeParameterNullOrWhitespace,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributeParameterNullOrWhitespace(string attributeName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributeParameterNullOrWhitespace,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            attributeName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundAttributeParameterName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3014",
            () => Resources.TagHelper_InvalidBoundAttributeParameterName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundAttributeParameterName(
        string attributeName,
        string invalidName,
        char invalidCharacter)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundAttributeParameterName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            attributeName,
            invalidName,
            invalidCharacter);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundDirectiveAttributeName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3015",
            () => Resources.TagHelper_InvalidBoundDirectiveAttributeName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundDirectiveAttributeName(
        string tagHelperDisplayName,
        string propertyDisplayName,
        string invalidName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundDirectiveAttributeName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName,
            invalidName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidBoundDirectiveAttributePrefix =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3015",
            () => Resources.TagHelper_InvalidBoundDirectiveAttributePrefix,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidBoundDirectiveAttributePrefix(
        string tagHelperDisplayName,
        string propertyDisplayName,
        string invalidName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidBoundDirectiveAttributePrefix,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            tagHelperDisplayName,
            propertyDisplayName,
            invalidName);

        return diagnostic;
    }

    internal static readonly RazorDiagnosticDescriptor TagHelper_InvalidRequiredDirectiveAttributeName =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}3016",
            () => Resources.TagHelper_InvalidRequiredDirectiveAttributeName,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateTagHelper_InvalidRequiredDirectiveAttributeName(
        string propertyDisplayName,
        string invalidName)
    {
        var diagnostic = RazorDiagnostic.Create(
            TagHelper_InvalidRequiredDirectiveAttributeName,
            new SourceSpan(SourceLocation.Undefined, contentLength: 0),
            propertyDisplayName,
            invalidName);

        return diagnostic;
    }

    #endregion

    #region Rewriter Errors

    // Rewriter Errors ID Offset = 4000

    internal static readonly RazorDiagnosticDescriptor Rewriter_InsufficientStack =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}4000",
            () => Resources.Rewriter_InsufficientStack,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateRewriter_InsufficientStack(SourceSpan location)
    {
        return RazorDiagnostic.Create(Rewriter_InsufficientStack, location);
    }

    #endregion

    #region "CSS Rewriter Errors"

    // CSS Rewriter Errors ID Offset = 5000

    internal static readonly RazorDiagnosticDescriptor CssRewriting_ImportNotAllowed =
        new RazorDiagnosticDescriptor(
            $"{DiagnosticPrefix}5000",
            () => Resources.CssRewriter_ImportNotAllowed,
            RazorDiagnosticSeverity.Error);
    public static RazorDiagnostic CreateCssRewriting_ImportNotAllowed(SourceSpan location)
    {
        return RazorDiagnostic.Create(CssRewriting_ImportNotAllowed, location);
    }

    #endregion
}
