using System;
using UnitTestSharp;

namespace Ariadne.Generator.UnitTests
{
    public class CodeWriterTests : TestFixture
    {
        public class CtorTests : TestFixture
        {
            public void Depth_StartsTheIndentationThere()
            {
                var code = new CodeWriter(depth: 2);

                code.AddLine("x");

                CheckEqual("        x\r\n", code.ToString());
            }

            public void NegativeDepth_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new CodeWriter(depth: -1);
            }
        }

        public class DepthTests : TestFixture
        {
            public void StartsAtTheCtorsDepthAndFollowsIndentAndDedent()
            {
                var code = new CodeWriter(depth: 1);

                code.Indent();
                code.Indent();
                code.Dedent();

                CheckEqual(2, code.Depth);
            }
        }

        public class LengthTests : TestFixture
        {
            public void CountsEverythingWritten()
            {
                var code = new CodeWriter();

                code.AddLine("ab");

                CheckEqual(4, code.Length);
            }
        }

        public class NewLineTests : TestFixture
        {
            public void WritesABlankLineEvenWhenIndented()
            {
                var code = new CodeWriter();
                code.Indent();

                code.NewLine();

                CheckEqual("\r\n", code.ToString());
            }
        }

        public class AddLineAtTests : TestFixture
        {
            public void StartsAtTheColumnWhateverTheIndentation()
            {
                var code = new CodeWriter();
                code.Indent();

                code.AddLineAt(column: 2, content: "x");

                CheckEqual("  x\r\n", code.ToString());
            }

            public void ColumnZero_HasNoIndentation()
            {
                var code = new CodeWriter();

                code.AddLineAt(column: 0, content: "x");

                CheckEqual("x\r\n", code.ToString());
            }

            public void EmptyContent_WritesABlankLine()
            {
                var code = new CodeWriter();

                code.AddLineAt(column: 6, content: "");

                CheckEqual("\r\n", code.ToString());
            }

            public void LineFeeds_BecomeCarriageReturnLineFeeds()
            {
                var code = new CodeWriter();

                code.AddLineAt(column: 0, content: "a\nb\n");

                CheckEqual("a\r\nb\r\n\r\n", code.ToString());
            }

            public void CarriageReturnLineFeeds_AreKept()
            {
                var code = new CodeWriter();

                code.AddLineAt(column: 0, content: "a\r\nb\r\n");

                CheckEqual("a\r\nb\r\n\r\n", code.ToString());
            }

            public void LoneCarriageReturns_AreKept()
            {
                var code = new CodeWriter();

                code.AddLineAt(column: 0, content: "a\rb");

                CheckEqual("a\rb\r\n", code.ToString());
            }

            public void MixedLineEndings_AllBecomeCarriageReturnLineFeeds()
            {
                var code = new CodeWriter();

                code.AddLineAt(column: 0, content: "a\nb\r\nc");

                CheckEqual("a\r\nb\r\nc\r\n", code.ToString());
            }
        }

        public class AddLineTests : TestFixture
        {
            public void WritesTheContentWithACarriageReturnLineFeed()
            {
                var code = new CodeWriter();

                code.AddLine("int x;");

                CheckEqual("int x;\r\n", code.ToString());
            }

            public void EmptyContent_WritesABlankLineEvenWhenIndented()
            {
                var code = new CodeWriter();
                code.Indent();

                code.AddLine("");

                CheckEqual("\r\n", code.ToString());
            }

            public void Indented_PrefixesFourSpacesPerLevel()
            {
                var code = new CodeWriter();
                code.Indent();
                code.Indent();

                code.AddLine("int x;");

                CheckEqual("        int x;\r\n", code.ToString());
            }
        }

        public class AddDirectiveTests : TestFixture
        {
            public void IgnoresTheIndentation()
            {
                var code = new CodeWriter();
                code.Indent();

                code.AddDirective("#line hidden");

                CheckEqual("#line hidden\r\n", code.ToString());
            }
        }

        public class IndentTests : TestFixture
        {
            public void AffectsOnlyTheLinesAfterIt()
            {
                var code = new CodeWriter();
                code.AddLine("before");

                code.Indent();
                code.AddLine("after");

                CheckEqual("before\r\n    after\r\n", code.ToString());
            }
        }

        public class DedentTests : TestFixture
        {
            public void UndoesOneIndent()
            {
                var code = new CodeWriter();
                code.Indent();
                code.Indent();

                code.Dedent();
                code.AddLine("x");

                CheckEqual("    x\r\n", code.ToString());
            }

            public void WithoutAnIndent_Throws()
            {
                var code = new CodeWriter();

                CheckThrow(typeof(InvalidOperationException));
                code.Dedent();
            }
        }

        public class OpenNewBlockTests : TestFixture
        {
            public void WithoutAHeader_WritesABraceAndIndents()
            {
                var code = new CodeWriter();

                code.OpenNewBlock();
                code.AddLine("x");

                CheckEqual("{\r\n    x\r\n", code.ToString());
            }

            public void WithAHeader_WritesItAboveTheBrace()
            {
                var code = new CodeWriter();

                code.OpenNewBlock("class A");
                code.AddLine("x");

                CheckEqual("class A\r\n{\r\n    x\r\n", code.ToString());
            }

            public void Nested_IndentsEachLevel()
            {
                var code = new CodeWriter();

                code.OpenNewBlock("class A");
                code.OpenNewBlock("void B()");
                code.AddLine("x");

                CheckEqual("class A\r\n{\r\n    void B()\r\n    {\r\n        x\r\n", code.ToString());
            }
        }

        public class CloseBlockTests : TestFixture
        {
            public void DedentsThenWritesTheClosingBrace()
            {
                var code = new CodeWriter();
                code.OpenNewBlock("class A");

                code.CloseBlock();
                code.AddLine("after");

                CheckEqual("class A\r\n{\r\n}\r\nafter\r\n", code.ToString());
            }

            public void Nested_ClosesInnermostFirst()
            {
                var code = new CodeWriter();
                code.OpenNewBlock("class A");
                code.OpenNewBlock("void B()");

                code.CloseBlock();
                code.CloseBlock();

                CheckEqual("class A\r\n{\r\n    void B()\r\n    {\r\n    }\r\n}\r\n", code.ToString());
            }

            public void WithoutAnOpenBlock_Throws()
            {
                var code = new CodeWriter();

                CheckThrow(typeof(InvalidOperationException));
                code.CloseBlock();
            }
        }

        public class AddTextTests : TestFixture
        {
            public void WritesTheTextAsItIsWhateverTheIndentation()
            {
                var code = new CodeWriter(depth: 2);

                code.AddText("  first\r\n    second\r\n");

                CheckEqual("  first\r\n    second\r\n", code.ToString());
            }

            public void LineEndingsOfAnotherKind_BecomeTheWritersOwn()
            {
                var code = new CodeWriter();

                code.AddText("first\nsecond\n");

                CheckEqual("first\r\nsecond\r\n", code.ToString());
            }
        }

        public class AddLinesTests : TestFixture
        {
            public void WritesTheOtherWritersLinesAsTheyWere()
            {
                var cases = new CodeWriter(depth: 2);
                cases.AddLine("case 1:");
                var code = new CodeWriter();
                code.AddLine("switch");

                code.AddLines(cases);

                CheckEqual("switch\r\n        case 1:\r\n", code.ToString());
            }

            public void EmptyWriter_AddsNothing()
            {
                var code = new CodeWriter();
                code.AddLine("x");

                code.AddLines(new CodeWriter());

                CheckEqual("x\r\n", code.ToString());
            }
        }

        public class InsertLinesTests : TestFixture
        {
            public void PutsTheLinesAtThePositionAndKeepsWhatFollowed()
            {
                var code = new CodeWriter();
                code.AddLine("first");
                int position = code.Length;
                code.AddLine("last");
                var inserted = new CodeWriter();
                inserted.AddLine("middle");

                code.InsertLines(position, inserted);

                CheckEqual("first\r\nmiddle\r\nlast\r\n", code.ToString());
            }

            public void AtTheEnd_AppendsTheLines()
            {
                var code = new CodeWriter();
                code.AddLine("first");
                var inserted = new CodeWriter();
                inserted.AddLine("last");

                code.InsertLines(code.Length, inserted);

                CheckEqual("first\r\nlast\r\n", code.ToString());
            }
        }

        public class ToStringTests : TestFixture
        {
            public void NothingWritten_IsEmpty()
            {
                CheckEqual("", new CodeWriter().ToString());
            }
        }
    }
}