Print_server/Inspectron.Epson.Templates.Tests/Language/CommentTests.cs

using Inspectron.Epson.Templates.Language;

namespace Inspectron.Epson.Templates.Tests.Language;

public class CommentTests
{
    #region Single-line comments

    [Fact]
    public void Tokenize_SingleLineComment_ProducesNoTextTokens()
    {
        var lexer = new Lexer("@* This is a comment");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
    }

    [Fact]
    public void Tokenize_InlineSingleLineComment_ProducesNoTextTokens()
    {
        var lexer = new Lexer("@* This is a comment *@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
    }

    [Fact]
    public void Tokenize_IndentedSingleLineComment_IsRecognizedAsComment()
    {
        var lexer = new Lexer("    @* indented comment");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
    }

    [Fact]
    public void Tokenize_TextBeforeAndAfterCommentLine_IsPreserved()
    {
        var lexer = new Lexer("Before\n@* comment\nAfter");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Before");
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
    }

    [Fact]
    public void Tokenize_InlineCommentWithContentAfter_PreservesContentAfter()
    {
        var lexer = new Lexer("@* comment *@After");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
    }

    #endregion

    #region Multi-line comments

    [Fact]
    public void Tokenize_MultiLineComment_ProducesNoTextTokens()
    {
        var lexer = new Lexer("@*\nThis is multi-line\ncomment text\n*@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
    }

    [Fact]
    public void Tokenize_MultiLineComment_ContentBeforeAndAfterPreserved()
    {
        var lexer = new Lexer("Before\n@*\ncomment\n*@\nAfter");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Before");
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
    }

    [Fact]
    public void Tokenize_UnclosedMultiLineComment_ProducesError()
    {
        var lexer = new Lexer("@*\nThis comment is never closed");
        var result = lexer.Tokenize();

        Assert.True(result.HasErrors);
        Assert.Contains(result.Errors, e => e.Message.Contains("Unclosed multi-line comment"));
    }

    [Fact]
    public void Tokenize_MultiLineCommentWithContentAfterCloser_PreservesContent()
    {
        var lexer = new Lexer("@*\ncomment\n*@After");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "After");
    }

    #endregion

    #region Edge cases

    [Fact]
    public void Tokenize_StarSeparator_StillWorksNotConfusedWithComment()
    {
        var lexer = new Lexer("***");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.StarSeparator);
    }

    [Fact]
    public void Tokenize_DirectivesInsideComment_AreIgnored()
    {
        var lexer = new Lexer("@*\n@if condition\n@foreach item in items\n*@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.If);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Foreach);
    }

    [Fact]
    public void Tokenize_BindingsInsideComment_AreIgnored()
    {
        var lexer = new Lexer("@* {PropertyName} *@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Binding);
    }

    [Fact]
    public void Tokenize_CommentWithMultipleStars_HandledCorrectly()
    {
        var lexer = new Lexer("@*** This has extra stars ***@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("stars"));
    }

    [Fact]
    public void Tokenize_EmptyMultiLineComment_HandledCorrectly()
    {
        var lexer = new Lexer("@*\n*@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text);
    }

    [Fact]
    public void Tokenize_CommentInComplexTemplate_WorksCorrectly()
    {
        var template = @"#bold,center# Title #
@* This is a header comment *@
---
@if HasItems
@* Loop through items *@
@foreach item in Items
{item.Name}
@end
@end";
        var lexer = new Lexer(template);
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.StyleStart);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.DashSeparator);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.If);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Foreach);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("comment"));
    }

    [Fact]
    public void Tokenize_MultipleCommentsInTemplate_AllStripped()
    {
        var template = @"Line 1
@* Comment 1 *@
Line 2
@* Comment 2
still comment
*@
Line 3";
        var lexer = new Lexer(template);
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Line 1");
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Line 2");
        Assert.Contains(result.Tokens, t => t.Type == TokenType.Text && t.Value == "Line 3");
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.Text && t.Value.Contains("Comment"));
    }

    [Fact]
    public void Tokenize_SeparatorInsideMultiLineComment_IsIgnored()
    {
        var lexer = new Lexer("@*\n---\n===\n***\n*@");
        var result = lexer.Tokenize();

        Assert.False(result.HasErrors);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.DashSeparator);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.EqualsSeparator);
        Assert.DoesNotContain(result.Tokens, t => t.Type == TokenType.StarSeparator);
    }

    #endregion
}