using System;
using NUnit.Framework;
using Lexer;

namespace TestLexer
{
    [TestFixture]
    public class TestIntLexer
    {
        [Test]
        public void TestIntParse()
        {
            Lexer.Lexer l = new IntLexer("154216");
            Assert.IsTrue(l.Parse(), "Не разбирает 154216");

            l = new IntLexer("1");
            Assert.IsTrue(l.Parse(), "Не разбирает 1");

            l = new IntLexer("0");
            Assert.IsTrue(l.Parse(), "Не разбирает 0");

            l = new IntLexer("-0");
            Assert.IsTrue(l.Parse(), "Не разбирает -0");

            l = new IntLexer("+0");
            Assert.IsTrue(l.Parse(), "Не разбирает +0");

            l = new IntLexer("+11");
            Assert.IsTrue(l.Parse(), "Не разбирает +11");

            l = new IntLexer("-12");
            Assert.IsTrue(l.Parse(), "Не разбирает -12");
        }

        [Test]
        public void TestIntFailDot()
        {
            Lexer.Lexer l = new IntLexer("1.54216");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1.54216");
        }

        [Test]
        public void TestIntFailSymbol()
        {
            Lexer.Lexer l = new IntLexer("а1");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a1");
            l = new IntLexer("1a");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1а");
        }

        [Test]
        public void TestIntFailEpty()
        {
            Lexer.Lexer l = new IntLexer("");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
        }

        [Test]
        public void TestIntCollectNumber()
        {
            IntLexer lInt = new IntLexer("12");
            Assert.IsTrue(lInt.Parse());
            Assert.AreEqual(lInt.parseResult, 12, "Не собирает число 12");

            lInt = new IntLexer("-12");
            Assert.IsTrue(lInt.Parse());
            Assert.AreEqual(lInt.parseResult, -12, "Не собирает число -12");

            lInt = new IntLexer("+12");
            Assert.IsTrue(lInt.Parse());
            Assert.AreEqual(lInt.parseResult, 12, "Не собирает число +12");

            lInt = new IntLexer("+0");
            Assert.IsTrue(lInt.Parse());
            Assert.AreEqual(lInt.parseResult, 0, "Не собирает число +0");
        }
    }

    [TestFixture]
    public class TestIdLexer
    {
        [Test]
        public void TestIdParse()
        {
            IdentLexer l = new IdentLexer("abc22");
            Assert.IsTrue(l.Parse(), "Не разбирает аbc22");

            l = new IdentLexer("a");
            Assert.IsTrue(l.Parse(), "Не разбирает а");
        }

        [Test]
        public void TestIdEmpty()
        {
            IdentLexer l = new IdentLexer("");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
        }

        [Test]
        public void TestIdCaps()
        {
            IdentLexer l = new IdentLexer("AAAAA");
            Assert.IsTrue(l.Parse(), "Не разбирает заглавные буквы");
        }

        [Test]
        public void TestIdNumbers()
        {
            IdentLexer l = new IdentLexer("a12345");
            Assert.IsTrue(l.Parse(), "Не разбирает цифры в конце");
        }

        [Test]
        public void TestIdUnderscore()
        {
            IdentLexer l = new IdentLexer("a12_5");
            Assert.IsTrue(l.Parse(), "Не разбирает _");
        }

        [Test]
        public void TestIdDot()
        {
            IdentLexer l = new IdentLexer("f67.3");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает точку");
        }

        [Test]
        public void TestIdDollar()
        {
            IdentLexer l = new IdentLexer("f67$3");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает $");
        }
    }

    [TestFixture]
    public class TestIntNotZeroLexer
    {
        [Test]
        public void TestIntNotZeroParse()
        {
            IntNoZeroLexer l = new IntNoZeroLexer("1234");
            Assert.IsTrue(l.Parse(), "Не разбирает 1234");
        }

        [Test]
        public void TestIntNotZeroFail()
        {
            IntNoZeroLexer l = new IntNoZeroLexer("01234");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 0");

            l = new IntNoZeroLexer("+01234");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает +0");

            l = new IntNoZeroLexer("-01234");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает -0");

            l = new IntNoZeroLexer("0");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 0");
        }

        [Test]
        public void TestIntNotZeroPass()
        {
            IntNoZeroLexer l = new IntNoZeroLexer("12034");
            Assert.IsTrue(l.Parse(), "Не разбирает 12034");

            l = new IntNoZeroLexer("+12034");
            Assert.IsTrue(l.Parse(), "Не разбирает +12034");

            l = new IntNoZeroLexer("12034");
            Assert.IsTrue(l.Parse(), "Не разбирает 12034");

            l = new IntNoZeroLexer("-12034");
            Assert.IsTrue(l.Parse(), "Не разбирает -12034");
        }

    }

    [TestFixture]
    public class TestLetterDigitLexer
    {

        [Test]
        public void TestLetterDigitParse()
        {
            LetterDigitLexer l = new LetterDigitLexer("a2f5j3");
            Assert.IsTrue(l.Parse(), "Не разбирает a2f5j3");

            l = new LetterDigitLexer("a");
            Assert.IsTrue(l.Parse(), "Не разбирает a");

            l = new LetterDigitLexer("a2");
            Assert.IsTrue(l.Parse(), "Не разбирает a2");

            l = new LetterDigitLexer("a2B");
            Assert.IsTrue(l.Parse(), "Не разбирает a2B");

        }

        [Test]
        public void TestLetterDigitFail()
        {
            LetterDigitLexer l = new LetterDigitLexer("a25j3");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a25j3");

            l = new LetterDigitLexer("a2jb3");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a2jb3");

            l = new LetterDigitLexer("2a3b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 2a3b");

            l = new LetterDigitLexer("a2f 3b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a2f 3b");
        }
    }


    [TestFixture]
    public class TestLetterListLexer
    {
        [Test]
        public void TestLetterListParse()
        {
            LetterListLexer l = new LetterListLexer("a,b,c");
            Assert.IsTrue(l.Parse(), "Не пропускает a,b,c");
            Assert.AreEqual(l.ParseResult.Count, 3, "неправильно собран список-результат");
            Assert.Contains('a', l.ParseResult);
            Assert.Contains('b', l.ParseResult);
            Assert.Contains('c', l.ParseResult);

            l = new LetterListLexer("a");
            Assert.IsTrue(l.Parse(), "Не пропускает a");
            Assert.AreEqual(l.ParseResult.Count, 1, "неправильно собран список-результат");
            Assert.Contains('a', l.ParseResult);

            l = new LetterListLexer("a,B");
            Assert.IsTrue(l.Parse(), "Не пропускает a,B");
            Assert.AreEqual(l.ParseResult.Count, 2, "неправильно собран список-результат");
            Assert.Contains('a', l.ParseResult);
            Assert.Contains('B', l.ParseResult);

            l = new LetterListLexer("a;B");
            Assert.IsTrue(l.Parse(), "Не пропускает a;B");

            l = new LetterListLexer("a,B;c");
            Assert.IsTrue(l.Parse(), "Не пропускает a,B;c");

            l = new LetterListLexer("a;b,c;d");
            Assert.IsTrue(l.Parse(), "Не пропускает a;b,c;d");

        }

        [Test]
        public void TestLetterListFail()
        {
            LetterListLexer l = new LetterListLexer("a,b,");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a,b,");

            l = new LetterListLexer(",b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ,b");

            l = new LetterListLexer(";b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ;b");

            l = new LetterListLexer("B;");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает B;");

            l = new LetterListLexer("a,,b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a,,b");

            l = new LetterListLexer("a;;b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a;;b");

            l = new LetterListLexer("a;1");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает цифры");
        }

    }

    [TestFixture]
    public class TestDigitListLexer
    {
        [Test]
        public void TestDigitListParse()
        {
            DigitListLexer l = new DigitListLexer("1 2");
            Assert.IsTrue(l.Parse(), "Не пропускает 1 2");
            Assert.AreEqual(l.ParseResult.Count, 2, "неправильно собран список-результат");
            Assert.Contains(1, l.ParseResult);
            Assert.Contains(2, l.ParseResult);

            l = new DigitListLexer("1");
            Assert.IsTrue(l.Parse(), "Не пропускает 1");
            Assert.AreEqual(l.ParseResult.Count, 1, "неправильно собран список-результат");
            Assert.Contains(1, l.ParseResult);

            l = new DigitListLexer("5    6");
            Assert.IsTrue(l.Parse(), "Не пропускает 5    6");
            Assert.AreEqual(l.ParseResult.Count, 2, "неправильно собран список-результат");
            Assert.Contains(5, l.ParseResult);
            Assert.Contains(6, l.ParseResult);
        }

        [Test]
        public void TestDigitListFail()
        {
            DigitListLexer l = new DigitListLexer("12");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 12");

            l = new DigitListLexer(" 1");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пробелы в начале");

            l = new DigitListLexer("1  ");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пробелы в конце");

            l = new DigitListLexer("1, 2");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ,");

            l = new DigitListLexer("1;2");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ;");

            l = new DigitListLexer("1a2");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1a2");
        }

    }

    [TestFixture]
    public class TestLetterDigitGroupLexer
    {
        [Test]
        public void TestLetterDigitGroupParse()
        {
            LetterDigitGroupLexer l = new LetterDigitGroupLexer("aa12ab23");
            Assert.IsTrue(l.Parse(), "Не пропускает aa12ab23");
            Assert.AreEqual(l.ParseResult, "aa12ab23", "неправильно собран aa12ab23");

            l = new LetterDigitGroupLexer("a1b2");
            Assert.IsTrue(l.Parse(), "Не пропускает a1b2");
            Assert.AreEqual(l.ParseResult, "a1b2", "неправильно собран a1b2");

            l = new LetterDigitGroupLexer("aa");
            Assert.IsTrue(l.Parse(), "Не пропускает aa");
            Assert.AreEqual(l.ParseResult, "aa", "неправильно собран aa");

            l = new LetterDigitGroupLexer("A11");
            Assert.IsTrue(l.Parse(), "Не пропускает A11");
            Assert.AreEqual(l.ParseResult, "A11", "неправильно собран A11");

            l = new LetterDigitGroupLexer("ab33cd58e3n5ss32");
            Assert.IsTrue(l.Parse(), "Не пропускает ab33cd58e3n5ss32");
            Assert.AreEqual(l.ParseResult, "ab33cd58e3n5ss32", "неправильно собран ab33cd58e3n5ss32");
        }

        [Test]
        public void TestLetterDigitGroupFail()
        {
            LetterDigitGroupLexer l = new LetterDigitGroupLexer("1a");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1a");

            l = new LetterDigitGroupLexer("a111b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a111b");

            l = new LetterDigitGroupLexer("A_34b");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает A_34b");

            l = new LetterDigitGroupLexer("");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");

            l = new LetterDigitGroupLexer("11");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 11");

            l = new LetterDigitGroupLexer("_A34");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает _A34");
        }
    }

    [TestFixture]
    public class TestDoubleLexer
    {
        [Test]
        public void TestDoubleParse()
        {

            DoubleLexer l = new DoubleLexer("123.4");
            Assert.IsTrue(l.Parse(), "Не понимает 123.4");
            Assert.AreEqual(l.ParseResult, 123.4, 0.01, "Неправильно прочитал 123.4");

            l = new DoubleLexer("123");
            Assert.IsTrue(l.Parse(), "Не понимает 123");
            Assert.AreEqual(l.ParseResult, 123, 0.01, "Неправильно прочитал 123");

            l = new DoubleLexer("0.4");
            Assert.IsTrue(l.Parse(), "Не понимает 0.4");
            Assert.AreEqual(l.ParseResult, 0.4, 0.01, "Неправильно прочитал 0.4");

            l = new DoubleLexer("0.4");
            Assert.IsTrue(l.Parse(), "Не понимает 0.4");
            Assert.AreEqual(l.ParseResult, 0.4, 0.01, "Неправильно прочитал 0.4");
        }

        [Test]
        public void TestDoubleFail()
        {
            DoubleLexer l = new DoubleLexer(".4");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает .4");

            l = new DoubleLexer("4.");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 4.");

            l = new DoubleLexer(".");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает .");

            l = new DoubleLexer("");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
        }

    }

    [TestFixture]
    public class TestQuotedStringLexer
    {

        [Test]
        public void TestQuotedStringParse()
        {
            StringLexer l = new StringLexer("''");
            Assert.IsTrue(l.Parse(), "Не пропускает ''");

            l = new StringLexer("'aa#2N3@_3-x//45'");
            Assert.IsTrue(l.Parse(), "Не пропускает 'aa#2N3@_3-x//45'");

            l = new StringLexer("'23 3 a'");
            Assert.IsTrue(l.Parse(), "Не пропускает '23 3 a'");
        }

        [Test]
        public void TestQuotedStringFail()
        {
            StringLexer l = new StringLexer("'");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает '");

            l = new StringLexer("aa'");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает aa'");

            l = new StringLexer("b 'add'");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает b 'add'");

            l = new StringLexer("'add' d");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 'add' d");
        }

    }

    [TestFixture]
    public class TestCommentLexer
    {

        [Test]
        public void TestCommentParse()
        {
            CommentLexer l = new CommentLexer("/**/");
            Assert.IsTrue(l.Parse(), "Не пропускает /**/");

            l = new CommentLexer("/*as3 @4&*_ -dd %~f*/");
            Assert.IsTrue(l.Parse(), "Не пропускает /*as3 @4&*_ -dd %~f*/");

            l = new CommentLexer("/*asda \n */");
            Assert.IsTrue(l.Parse(), "Не пропускает перенос строки");
        }

        [Test]
        public void TestCommentFail()
        {
            CommentLexer l = new CommentLexer("*/");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает */'");

            l = new CommentLexer("/*");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает /*'");

            l = new CommentLexer("/* \n");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает */ \n'");

            l = new CommentLexer("/**/*/");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает /**/*/'");
        }

    }
    
    [TestFixture]
    public class TestIdChainLexer
    {
        [Test]
        public void TestIdChainParse()
        {
            IdentChainLexer l = new IdentChainLexer("Id1");
            Assert.IsTrue(l.Parse(), "Не пропускает Id1");
            
            l = new IdentChainLexer("Id1.Id2");
            Assert.IsTrue(l.Parse(), "Не пропускает Id1.Id2");
            
            l = new IdentChainLexer("uUd.k_22.sa3");
            Assert.IsTrue(l.Parse(), "Не пропускает uUd.k_22.sa3");
        }
        
        [Test]
        public void TestIdChainFail()
        {
            IdentChainLexer l = new IdentChainLexer("3Id1");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 3Id1");
            
            l = new IdentChainLexer(".Id2");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает .Id2");
            
            l = new IdentChainLexer("uUd.");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd.");
            
            l = new IdentChainLexer("uUd.3sa");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd.3sa");
            
            l = new IdentChainLexer("uUd. _sa");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd. _sa");
            
            l = new IdentChainLexer("uUd,sa");
            Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd,sa");
            
        }
    }
}