/* ========================================================================
 * Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
 *
 * OPC Foundation MIT License 1.00
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * The complete license agreement can be found here:
 * http://opcfoundation.org/License/MIT/1.00/
 * ======================================================================*/

using System.Collections.Generic;
using System.Xml;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using NUnit.Framework;

namespace Opc.Ua.SourceGeneration.Shared.Tests
{
    /// <summary>
    /// Unit tests for the <see cref="SourceGenerationUtils"/> class.
    /// </summary>
    [TestFixture]
    [Category("SourceGeneration")]
    [SetCulture("en-us")]
    [SetUICulture("en-us")]
    [Parallelizable]
    public class SourceGenerationUtilsTests
    {
        [TestCase("Foo", false, "foo")]
        [TestCase("foo", false, "foo")]
        [TestCase("Class", false, "@class")]
        [TestCase("@class", false, "@class")]
        [TestCase("some-value", false, "some_value")]
        [TestCase("1 Value", false, "_1value")]
        [TestCase("Class", true, "Class")]
        [TestCase("__arglist", false, "@__arglist")]
        [TestCase("__makeref", false, "@__makeref")]
        [TestCase("__reftype", false, "@__reftype")]
        [TestCase("__refvalue", false, "@__refvalue")]
        public void ToCSharpIdentifierCanonicalizesAndEscapes(
            string input,
            bool upperCamelCase,
            string expected)
        {
            Assert.That(
                input.ToCSharpIdentifier(upperCamelCase),
                Is.EqualTo(expected));
        }

        /// <summary>
        /// Regression: the preserve-case overload must sanitize the name into a
        /// legal identifier without touching the casing the model author chose.
        /// Used for constants whose name is part of the generated public API.
        /// </summary>
        [TestCase("Pump 1", "Pump1")]
        [TestCase("pump", "pump")]
        [TestCase("Pump-1", "Pump_1")]
        [TestCase("1Pump", "_1Pump")]
        [TestCase("class", "@class")]
        [TestCase("", "Value")]
        [TestCase(null, "Value")]
        public void ToCSharpIdentifierPreserveCaseKeepsCasing(string? input, string expected)
        {
            Assert.That(input!.ToCSharpIdentifierPreserveCase(), Is.EqualTo(expected));
        }

        /// <summary>
        /// Regression: descriptions taken from a NodeSet go into BSD/XSD schema
        /// documents as character data, so the XML markup characters have to be
        /// escaped or the emitted schema is not well formed.
        /// </summary>
        [TestCase("A&C", "A&amp;C")]
        [TestCase("a < b > c", "a &lt; b &gt; c")]
        [TestCase("plain", "plain")]
        [TestCase("", "")]
        [TestCase(null, "")]
        public void AsXmlTextEscapesMarkupCharacters(string? input, string expected)
        {
            Assert.That(input!.AsXmlText(), Is.EqualTo(expected));
        }

        /// <summary>
        /// Attribute values additionally need the double quote escaped.
        /// </summary>
        [TestCase("a\"b", "a&quot;b")]
        [TestCase("A&C", "A&amp;C")]
        public void AsXmlAttributeValueEscapesQuotes(string input, string expected)
        {
            Assert.That(input.AsXmlAttributeValue(), Is.EqualTo(expected));
        }

        /// <summary>
        /// An element name is not character data, so escaping cannot rescue one
        /// that is not an NCName - "Read&amp;Write" written as "Read&amp;amp;Write"
        /// still decodes to something xs:element/@name does not accept.
        /// </summary>
        [TestCase("Value", true)]
        [TestCase("_value", true)]
        [TestCase("Value1", true)]
        [TestCase("Read&Write", false)]
        [TestCase("Value Id", false)]
        [TestCase("1Value", false)]
        [TestCase("a:b", false)]
        [TestCase("a<b", false)]
        [TestCase("", false)]
        [TestCase(null, false)]
        public void IsValidXmlNameAcceptsOnlyNCNames(string? input, bool expected)
        {
            Assert.That(input!.IsValidXmlName(), Is.EqualTo(expected));
        }

        /// <summary>
        /// Regression: NodeIdGenerator interpolated the string identifier into a
        /// C# literal unescaped, so a PLC style id with a backslash produced
        /// source that does not compile.
        /// </summary>
        [Test]
        public void AsStringLiteralEscapesBackslashAndQuote()
        {
            Assert.That(
                "PLC1\\DB10.Tag".AsStringLiteral(),
                Is.EqualTo("\"PLC1\\\\DB10.Tag\""));
            Assert.That(
                "say \"hi\"".AsStringLiteral(),
                Is.EqualTo("\"say \\\"hi\\\"\""));
        }

        [Test]
        public void AsStringLiteralEscapesUnicodeLineSeparators()
        {
            const string value = "Next\u0085Line\u2028Paragraph\u2029End";

            Assert.That(
                value.AsStringLiteral(),
                Is.EqualTo("\"Next\\u0085Line\\u2028Paragraph\\u2029End\""));
        }

        /// <summary>
        /// Regression: Escape() only escaped backslash and quote, so a
        /// [DataTypeField(Name = ...)] or namespace string containing a line
        /// terminator produced an unterminated literal (CS1010). Escape() and
        /// AsStringLiteral() must round-trip any value through a C# literal.
        /// </summary>
        [TestCase("a\nb")]
        [TestCase("a\r\nb")]
        [TestCase("Next\u0085Line\u2028Paragraph\u2029End")]
        [TestCase("tab\there \"quoted\" back\\slash \u0001 \u007f")]
        public void EscapeAndAsStringLiteralRoundTripThroughACSharpLiteral(string value)
        {
            Assert.Multiple(() =>
            {
                AssertParsesAsLiteralOf("\"" + value.Escape() + "\"", value);
                AssertParsesAsLiteralOf(value.AsStringLiteral(), value);
            });
        }

        private static void AssertParsesAsLiteralOf(string code, string expected)
        {
            ExpressionSyntax expression = SyntaxFactory.ParseExpression(code);
            Assert.That(expression.GetDiagnostics(), Is.Empty, code);
            Assert.That(expression, Is.InstanceOf<LiteralExpressionSyntax>(), code);
            Assert.That(((LiteralExpressionSyntax)expression).Token.ValueText, Is.EqualTo(expected), code);
        }
        /// <summary>
        /// Tests that IsNull returns the expected result for various XmlQualifiedName inputs.
        /// </summary>
        /// <param name="qname">The XmlQualifiedName to test.</param>
        /// <param name="expected">The expected result.</param>
        [TestCaseSource(nameof(IsNullTestCases))]
        public void IsNull_VariousInputs_ReturnsExpectedResult(XmlQualifiedName qname, bool expected)
        {
            // Act
            bool result = qname.IsNull();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
        }

        private static IEnumerable<TestCaseData> IsNullTestCases()
        {
            yield return new TestCaseData(null, true);
            yield return new TestCaseData(new XmlQualifiedName(null), true);
            yield return new TestCaseData(new XmlQualifiedName(string.Empty), true);
            yield return new TestCaseData(new XmlQualifiedName("ValidName"), false);
            yield return new TestCaseData(new XmlQualifiedName("ValidName", "http://namespace.com"), false);
            yield return new TestCaseData(new XmlQualifiedName("   "), false);
            yield return new TestCaseData(new XmlQualifiedName(" \t\n\r "), false);
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with a null input.
        /// Verifies that a null input returns null.
        /// </summary>
        [Test]
        public void ToLowerCamelCase_NullInput_ReturnsNull()
        {
            // Arrange
            const string? input = null;

            // Act
            string result = input!.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.Null);
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with an empty string.
        /// Verifies that an empty string returns an empty string.
        /// </summary>
        [Test]
        public void ToLowerCamelCase_EmptyString_ReturnsEmptyString()
        {
            // Arrange
            string input = string.Empty;

            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(string.Empty));
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with various string inputs.
        /// Verifies that the first character is converted to lowercase when needed,
        /// and returns the input unchanged when the first character is already lowercase
        /// or is not an alphabetic character.
        /// </summary>
        /// <param name="input">The input string to test.</param>
        /// <param name="expected">The expected output string.</param>
        [TestCase("a", "a", Description = "Single lowercase character")]
        [TestCase("A", "a", Description = "Single uppercase character")]
        [TestCase("helloWorld", "helloWorld", Description = "Already lowercase first character")]
        [TestCase("HelloWorld", "helloWorld", Description = "Uppercase first character")]
        [TestCase("HELLO", "hELLO", Description = "All uppercase string")]
        [TestCase("Ab", "ab", Description = "Two characters, uppercase first")]
        [TestCase("ab", "ab", Description = "Two characters, lowercase first")]
        [TestCase("X", "x", Description = "Single uppercase letter X")]
        [TestCase("z", "z", Description = "Single lowercase letter z")]
        [TestCase("MyProperty", "myProperty", Description = "Typical property name")]
        [TestCase("thisIsAlreadyLowerCamel", "thisIsAlreadyLowerCamel", Description = "Already in lower camel case")]
        [TestCase("URL", "uRL", Description = "Acronym")]
        public void ToLowerCamelCase_AlphabeticStrings_ConvertsFirstCharacterCorrectly(string input, string expected)
        {
            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with strings starting with non-alphabetic characters.
        /// Verifies that strings starting with digits, symbols, or whitespace are returned unchanged.
        /// </summary>
        /// <param name="input">The input string to test.</param>
        /// <param name="expected">The expected output string.</param>
        [TestCase("123Test", "123Test", Description = "String starting with digit")]
        [TestCase("0Value", "0Value", Description = "String starting with zero")]
        [TestCase("_test", "_test", Description = "String starting with underscore")]
        [TestCase("$value", "$value", Description = "String starting with dollar sign")]
        [TestCase(" Test", " Test", Description = "String starting with space")]
        [TestCase("\tTest", "\tTest", Description = "String starting with tab")]
        [TestCase("@Property", "@Property", Description = "String starting with at symbol")]
        [TestCase("-negative", "-negative", Description = "String starting with hyphen")]
        public void ToLowerCamelCase_NonAlphabeticStart_ReturnsUnchanged(string input, string expected)
        {
            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with Unicode characters.
        /// Verifies that Unicode uppercase characters are correctly converted to lowercase,
        /// and lowercase Unicode characters remain unchanged.
        /// </summary>
        /// <param name="input">The input string to test.</param>
        /// <param name="expected">The expected output string.</param>
        [TestCase("Über", "über", Description = "German umlaut uppercase")]
        [TestCase("über", "über", Description = "German umlaut lowercase")]
        [TestCase("École", "école", Description = "French accented character uppercase")]
        [TestCase("école", "école", Description = "French accented character lowercase")]
        [TestCase("Ñame", "ñame", Description = "Spanish ñ uppercase")]
        [TestCase("ñame", "ñame", Description = "Spanish ñ lowercase")]
        public void ToLowerCamelCase_UnicodeCharacters_HandlesCorrectly(string input, string expected)
        {
            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with a very long string.
        /// Verifies that the method handles long strings correctly without performance issues.
        /// </summary>
        [Test]
        public void ToLowerCamelCase_VeryLongString_ConvertsCorrectly()
        {
            // Arrange
            string input = "A" + new string('x', 10000);
            string expected = "a" + new string('x', 10000);

            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
            Assert.That(result, Has.Length.EqualTo(10001));
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with whitespace-only strings.
        /// Verifies that strings containing only whitespace characters are handled correctly.
        /// </summary>
        /// <param name="input">The input string to test.</param>
        /// <param name="expected">The expected output string.</param>
        [TestCase("   ", "   ", Description = "Multiple spaces")]
        [TestCase("\t\t", "\t\t", Description = "Multiple tabs")]
        [TestCase("\n", "\n", Description = "Newline character")]
        [TestCase("\r\n", "\r\n", Description = "Carriage return and newline")]
        public void ToLowerCamelCase_WhitespaceOnly_ReturnsUnchanged(string input, string expected)
        {
            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
        }

        /// <summary>
        /// Tests the ToLowerCamelCase method with special character strings.
        /// Verifies that strings consisting entirely of special characters are handled correctly.
        /// </summary>
        /// <param name="input">The input string to test.</param>
        /// <param name="expected">The expected output string.</param>
        [TestCase("_", "_", Description = "Single underscore")]
        [TestCase("$", "$", Description = "Single dollar sign")]
        [TestCase("@#$%", "@#$%", Description = "Multiple special characters")]
        [TestCase("123", "123", Description = "Only digits")]
        public void ToLowerCamelCase_SpecialCharactersOnly_ReturnsUnchanged(string input, string expected)
        {
            // Act
            string result = input.ToLowerCamelCase();

            // Assert
            Assert.That(result, Is.EqualTo(expected));
        }
    }
}