using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests
{
    [TestFixture]
    public class StringExtensionsTests
    {
        [Test(Description = "Vérifie le bon fonctionnement de la méthode IsNullOrEmpty(String)")]
        public void Check_IsNullOrEmpty_String()
        {
            string nullString = null;
            string emptyString = string.Empty;
            string whiteSpaceString = " \f\n\r\t\v";
            string notNullOrEmptyString = "foo";

            Assert.IsTrue(nullString.IsNullOrEmpty());
            Assert.IsTrue(emptyString.IsNullOrEmpty());
            Assert.IsFalse(whiteSpaceString.IsNullOrEmpty());
            Assert.IsFalse(notNullOrEmptyString.IsNullOrEmpty());
        }

        public void Check_IsNullOrWhiteSpace_String()
        {
            string nullString = null;
            string emptyString = string.Empty;
            string whiteSpaceString = " \f\n\r\t\v";
            string notNullOrEmptyString = "foo";

            Assert.IsTrue(nullString.IsNullOrWhiteSpace());
            Assert.IsTrue(emptyString.IsNullOrWhiteSpace());
            Assert.IsTrue(whiteSpaceString.IsNullOrWhiteSpace());
            Assert.IsFalse(notNullOrEmptyString.IsNullOrWhiteSpace());
        }

        [Test]
        public void Check_GetMD5Digest()
        {
            string text = "Hello world !";
            string expected = "67c18d060479c5d867c9b91c80edeb4c";
            string actual = text.GetMD5Digest();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_GetSHA1Digest()
        {
            string text = "Hello world !";
            string expected = "7c0a529d2e9e40f54944674b0de7e806fba33262";
            string actual = text.GetSHA1Digest();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_FormatWith_StandardCall() {
            string expected = "Hello World !";
            string actual = "Hello {0} !".FormatWith("World"); ;
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_FormatWith_WhenNowildcard() {
            string expected = "Hello";
            string actual = "Hello".FormatWith("bug"); ;
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Reverse()
        {
            string input = "Hello World !";
            string expected = "! dlroW olleH";
            string actual = input.Reverse();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Reverse_WithDiacriticsFormD()
        {
            string input = "Les Misérables".Normalize(NormalizationForm.FormD);
            string expected = "selbarésiM seL";
            string actual = input.Reverse().Normalize(NormalizationForm.FormC);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Join()
        {
            var list = new List<string>
            {
                "Hello",
                "World",
                "!"
            };
            string expected = "Hello World !";
            string actual = list.Join(" ");
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Join_Chars()
        {
            char[] chars = new[] { 'h', 'e', 'l', 'l', 'o' };
            string expected = new string(chars);
            string actual = chars.Join();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_ReadLines()
        {
            string input = @"Les sanglots longs
Des violons
  De l'automne
Blessent mon cœur
D'une langueur
   Monotone.";

            var expected = new string[]
            {
                "Les sanglots longs",
                "Des violons",
                "  De l'automne",
                "Blessent mon cœur",
                "D'une langueur",
                "   Monotone."
            };

            var actual = input.ReadLines();

            CollectionAssert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_RemoveDiacritics()
        {
            string input = "àâäçéèêñõ";
            string expected = "aaaceeeno";
            string actual = input.RemoveDiacritics();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Left()
        {
            string input = "Hello world !";
            
            string expected = "Hell";
            string actual = input.Left(4);
            Assert.AreEqual(expected, actual);

            expected = string.Empty;
            actual = input.Left(0);
            Assert.AreEqual(expected, actual);

#pragma warning disable 1720
            Assert.Throws<ArgumentNullException>(
                () => actual = default(string).Left(5));
#pragma warning restore 1720

            Assert.Throws<ArgumentOutOfRangeException>(
                () => actual = input.Left(-1));

            Assert.Throws<ArgumentOutOfRangeException>(
                () => actual = input.Left(50));

        }

        [Test]
        public void Test_Right()
        {
            string input = "Hello world !";

            string expected = "ld !";
            string actual = input.Right(4);
            Assert.AreEqual(expected, actual);

            expected = string.Empty;
            actual = input.Right(0);
            Assert.AreEqual(expected, actual);

#pragma warning disable 1720
            Assert.Throws<ArgumentNullException>(
                () => actual = default(string).Right(5));
#pragma warning restore 1720

            Assert.Throws<ArgumentOutOfRangeException>(
                () => actual = input.Right(-1));

            Assert.Throws<ArgumentOutOfRangeException>(
                () => actual = input.Right(50));
        }

        [Test]
        public void Test_Truncate()
        {
            string input = "Hello world !";

            string expected = "Hell";
            string actual = input.Truncate(4);
            Assert.AreEqual(expected, actual);

            expected = string.Empty;
            actual = input.Truncate(0);
            Assert.AreEqual(expected, actual);

            expected = input;
            actual = input.Truncate(50);
            Assert.AreEqual(expected, actual);

#pragma warning disable 1720
            Assert.Throws<ArgumentNullException>(
                () => actual = default(string).Truncate(5));
#pragma warning restore 1720

            Assert.Throws<ArgumentOutOfRangeException>(
                () => actual = input.Truncate(-1));
        }

        [Test]
        public void Test_GetCharFrequencies()
        {
            string input = "Hello world !";
            var expected = new Dictionary<char, int>
            {
                { 'H', 1 },
                { 'e', 1 },
                { 'l', 3 },
                { 'o', 2 },
                { ' ', 2 },
                { 'w', 1 },
                { 'r', 1 },
                { 'd', 1 },
                { '!', 1 }
            };
            var actual = input.GetCharFrequencies();
            CollectionAssert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_From_Index()
        {
            string input = "Hello world !";
            string expected = "world !";
            string actual = input.From(6);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_From_To_Index()
        {
            string input = "Hello world !";
            string expected = "lo wo";
            string actual = input.From(3).To(7);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_From_String()
        {
            string input = "Hello world !";
            string expected = "rld !";
            string actual = input.From("wo");
            Assert.AreEqual(expected, actual);

            expected = "world !";
            actual = input.From("wo", true);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_From_To_String()
        {
            string input = "Hello <b>world</b> !";
            string expected = "world";
            string actual = input.From("<b>").To("</b>");
            Assert.AreEqual(expected, actual);

            expected = "<b>world</b>";
            actual = input.From("<b>", true).To("</b>", true);
            Assert.AreEqual(expected, actual);

            expected = "<b>world";
            actual = input.From("<b>", true).To("</b>", false);
            Assert.AreEqual(expected, actual);

            expected = "world</b>";
            actual = input.From("<b>", false).To("</b>", true);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_From_Take_String()
        {
            string input = "Hello <b>world</b> !";
            string expected = "world";
            string actual = input.From("<b>").Take(5);
            Assert.AreEqual(expected, actual);

            expected = "<b>world</b>";
            actual = input.From("<b>", true).Take(12);
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_ToTitleCase()
        {
            string input = "hello world";
            string expected = "Hello World";
            string actual = input.ToTitleCase();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Capitalize()
        {
            string input = "hello world";
            string expected = "Hello world";
            string actual = input.Capitalize();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_Ellipsis_DefaultEllipsisString()
        {
            string input = "Hello world !";

            string expected = input;
            string actual = input.Ellipsis(20);
            Assert.AreEqual(expected, actual);

            expected = input;
            actual = input.Ellipsis(input.Length);
            Assert.AreEqual(expected, actual);

            expected = "Hello wor...";
            actual = input.Ellipsis(12);
            Assert.AreEqual(expected, actual);

            expected = "Hello w...";
            actual = input.Ellipsis(10);
            Assert.AreEqual(expected, actual);

            expected = "...";
            actual = input.Ellipsis(3);
            Assert.AreEqual(expected, actual);

            Assert.Throws<ArgumentException>(() => input.Ellipsis(2));
        }

        [Test]
        public void Test_Ellipsis_CustomEllipsisString()
        {
            string input = "Hello world !";
            string ellipsis = "+++++";

            string expected = input;
            string actual = input.Ellipsis(20, ellipsis);
            Assert.AreEqual(expected, actual);

            expected = input;
            actual = input.Ellipsis(input.Length, ellipsis);
            Assert.AreEqual(expected, actual);

            expected = "Hello w+++++";
            actual = input.Ellipsis(12, ellipsis);
            Assert.AreEqual(expected, actual);

            expected = "Hello+++++";
            actual = input.Ellipsis(10, ellipsis);
            Assert.AreEqual(expected, actual);

            expected = ellipsis;
            actual = input.Ellipsis(ellipsis.Length, ellipsis);
            Assert.AreEqual(expected, actual);

            Assert.Throws<ArgumentNullException>(() => input.Ellipsis(10, null));
            Assert.Throws<ArgumentException>(() => input.Ellipsis(2, ellipsis));
        }

        [Test]
        public void Test_EnsureEndsWith()
        {
            string original = @"C:\foo";
            string expected = @"C:\foo\";
            const string suffix = @"\";
            string actual = original.EnsureEndsWith(suffix);
            Assert.AreEqual(expected, actual);

            original = @"C:\foo\";
            expected = original;
            actual = original.EnsureEndsWith(suffix);
            Assert.AreEqual(expected, actual);
            // Should return the same instance
            Assert.AreSame(expected, actual);
        }

        [Test]
        public void Test_EnsureStartsWith()
        {
            string original = @"blabla";
            string expected = @"> blabla";
            const string prefix = @"> ";
            string actual = original.EnsureStartsWith(prefix);
            Assert.AreEqual(expected, actual);

            original = @"> blabla";
            expected = original;
            actual = original.EnsureStartsWith(prefix);
            Assert.AreEqual(expected, actual);
            // Should return the same instance
            Assert.AreSame(expected, actual);
        }

        [Test]
        public void Test_IsValidEmail()
        {
            var validEmails = new[]
            {
                "l3tt3rsAndNumb3rs@domain.com",
                "has-dash@domain.com",
                "hasApostrophe.o'leary@domain.org",
                "uncommonTLD@domain.museum",
                "uncommonTLD@domain.travel",
                "uncommonTLD@domain.mobi",
                "countryCodeTLD@domain.uk",
                "countryCodeTLD@domain.rw",
                "lettersInDomain@911.com",
                "underscore_inLocal@domain.net",
                "IPInsteadOfDomain@127.0.0.1",
                "IPAndPort@127.0.0.1:25",
                "subdomain@sub.domain.com",
                "local@dash-inDomain.com",
                "dot.inLocal@foo.com",
                "a@singleLetterLocal.org",
                "singleLetterDomain@x.org",
                "&*=?^+{}'~@validCharsInLocal.net",
                "foor@bar.newTLD",
            };

            var invalidEmails = new[]
            {
                "missingDomain@.com",
                "@missingLocal.org",
                "missingatSign.net",
                "missingDot@com",
                "two@@signs.com",
                "colonButNoPort@127.0.0.1:",
                "",
                "someone-else@127.0.0.1.26",
                ".localStartsWithDot@domain.com",
                "localEndsWithDot.@domain.com",
                "two..consecutiveDots@domain.com",
                "domainStartsWithDash@-domain.com",
                "domainEndsWithDash@domain-.com",
                "numbersInTLD@domain.c0m",
                "missingTLD@domain.",
                "! \"#$%(),/;<>[]`|@invalidCharsInLocal.org",
                "invalidCharsInDomain@! \"#$%(),/;<>_[]`|.org",
                "local@SecondLevelDomainNamesAreInvalidIfTheyAreLongerThan64Charactersss.org",
            };

            foreach (var email in validEmails)
            {
                Assert.IsTrue(email.IsValidEmail(), "Expected '{0}' to be valid, but is invalid", email);
            }

            foreach (var email in invalidEmails)
            {
                Assert.IsFalse(email.IsValidEmail(), "Expected '{0}' to be invalid, but is valid", email);
            }
        }

        [Test]
        public void Test_EqualsWithNullAsEmpty()
        {
            string nullString = null;
            string EmptyString = string.Empty;
            string notEmptyString = "foo";
            string capitalNotEmptyString = "FOO";

            Assert.IsTrue(nullString.EqualsWithNullAsEmpty(EmptyString));
            Assert.IsTrue(EmptyString.EqualsWithNullAsEmpty(nullString));
            Assert.IsFalse(EmptyString.EqualsWithNullAsEmpty(notEmptyString));
            Assert.IsFalse(nullString.EqualsWithNullAsEmpty(notEmptyString));
            Assert.IsFalse(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString)); //False : casse
            Assert.IsFalse(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString, StringComparison.InvariantCulture));
            Assert.IsFalse(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString, StringComparison.CurrentCulture));
            Assert.IsFalse(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString, StringComparison.Ordinal));
            Assert.IsTrue(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString, StringComparison.InvariantCultureIgnoreCase));
            Assert.IsTrue(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString, StringComparison.CurrentCultureIgnoreCase));
            Assert.IsTrue(notEmptyString.EqualsWithNullAsEmpty(capitalNotEmptyString, StringComparison.OrdinalIgnoreCase));
        }

        [Test]
        public void Test_ReplaceAt()
        {
            string original = "hella world";
            string expected = "hello world";
            string actual = original.ReplaceAt(4, 'o');
            Assert.AreEqual(expected, actual);
        }

        [Test, ExpectedException(typeof(ArgumentNullException))]
        public void Test_ReplaceAt_NullString()
        {
            string s = null;
            s.ReplaceAt(0, 'a');
        }

        [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
        public void Test_ReplaceAt_IndexTooSmall()
        {
            string s = "hello";
            s.ReplaceAt(-1, 'a');
        }

        [Test, ExpectedException(typeof(ArgumentOutOfRangeException))]
        public void Test_ReplaceAt_IndexTooBig()
        {
            string s = "hello";
            s.ReplaceAt(5, 'a');
        }
    }
}