using System;
using System.Linq;
using UnitTestSharp;

namespace TestsForUnitTestSharp
{
    public class BuildMessages_Tests : TestFixture
    {
        const string sampleFileName = "c:/Program File/some directory/AFile.cs";
        const int sampleLineNumber = 666;
        const string sampleMessage = "A problem gone done occurred!";
        const string samplePedigree = "NamespaceA.NamespaceB::ClassA.ClassB::Method";
        StackFrame sampleStackFrame = new StackFrame(sampleFileName, sampleLineNumber, samplePedigree);

        #region MSBuildMessage
        public void MSBuildMessage_Works_Error()
        {
            string output = BuildMessages.MSBuildMessage(
                sampleMessage, samplePedigree, true, sampleFileName, sampleLineNumber);

            CheckEqual(
                sampleFileName + "(" + sampleLineNumber + "): error: \"" + sampleMessage + "\" in \"" + samplePedigree + "\"", output);
        }

        public void MSBuildMessage_Works_Warning()
        {
            string output = BuildMessages.MSBuildMessage(
                sampleMessage, samplePedigree, false, sampleFileName, sampleLineNumber);

            CheckEqual(
                sampleFileName + "(" + sampleLineNumber + "): warning: \"" + sampleMessage + "\" in \"" + samplePedigree + "\"", output);
        }

        public void MSBuildMessage_MessageNull()
        {
            string output = BuildMessages.MSBuildMessage(
                null, samplePedigree, true, sampleFileName, sampleLineNumber);

            CheckEqual(
                sampleFileName + "(" + sampleLineNumber + "): error: \"unspecified problem\" in \"" + samplePedigree + "\"", output);
        }

        public void MSBuildMessage_PedigreeNull()
        {
            string output = BuildMessages.MSBuildMessage(
                sampleMessage, null, true, sampleFileName, sampleLineNumber);

            CheckEqual(                
                sampleFileName + "(" + sampleLineNumber + "): error: \"" + sampleMessage + "\"", output);
        }

        public void MSBuildMessage_PedigreeEmpty()
        {
            string output = BuildMessages.MSBuildMessage(
                sampleMessage, "", true, sampleFileName, sampleLineNumber);

            CheckEqual(
                sampleFileName + "(" + sampleLineNumber + "): error: \"" + sampleMessage + "\"", output);
        }

        public void MSBuildMessage_FileNameNull()
        {
            string output = BuildMessages.MSBuildMessage(
                sampleMessage, samplePedigree, true, null, sampleLineNumber);

            CheckEqual("UnitTestSharp: error: \"" + sampleMessage + "\" in \"" + samplePedigree + "\"", output);
        }

        public void MSBuildMessage_LineNumberNull()
        {
            string output = BuildMessages.MSBuildMessage(
                sampleMessage, samplePedigree, true, sampleFileName, null);

            CheckEqual(sampleFileName + ": error: \"" + sampleMessage + "\" in \"" + samplePedigree + "\"", output);
        }

        public void MSBuildMessage_MinimalInformation()
        {
            string output = BuildMessages.MSBuildMessage(
                null, null, true, null, null);

            CheckEqual("UnitTestSharp: error: \"unspecified problem\"", output);
        }

        public void MSBuildMessage_Multiline()
        {
            string message = "This is a multi line\n text.";
            
            string output = BuildMessages.MSBuildMessage(message, samplePedigree, false, sampleFileName, sampleLineNumber);
            
            string expected = sampleFileName + "(" + sampleLineNumber + "): " + "warning:" + " in \"" + samplePedigree + "\"" + "\n" + "This is a multi line\n text.";

            CheckEqual(expected, output);
        }
        #endregion

        #region StackFrameMessage
        public void StackFrameMessage_Works()
        {
            string expected = BuildMessages.MSBuildMessage(
                sampleMessage, samplePedigree, true, sampleFileName, sampleLineNumber);
            
            string actual = BuildMessages.StackFrameMessage(
                sampleMessage, true, sampleStackFrame);
            
            CheckEqual(expected, actual);
        }
        
        public void StackFrameMessage_StackFrameNull()
        {
            CheckThrow(typeof(System.Exception));
            string message = BuildMessages.StackFrameMessage(sampleMessage, true, null);
        }
        #endregion

        #region StackTraceMessage
        public class StackTraceMessage : TestFixture
        {
            StackTrace st = null;
            const string file1 = "File1.cs";
            const string file2 = "File2.cs";
            const string file3 = "File3.cs";

            public override void FixtureSetup()
            {
                var sfs = new StackFrame[] {
                    new StackFrame(file1, 1, samplePedigree),
                    new StackFrame(file2, 1, samplePedigree),
                    new StackFrame(file3, 1, samplePedigree)
                };

                st = new StackTrace(sfs, false);
            }

            public void StackTraceMessage_Works()
            {
                string actual = BuildMessages.StackTraceMessage(
                    sampleMessage, samplePedigree, true, st);

                string expected = BuildMessages.StackFrameMessage(sampleMessage, true, st.TopFrame) + "\n" +
                    BuildMessages.StackFrameMessage("Moving down stack trace...", false, st.ExtraStackFrames[0]) + "\n" +
                    BuildMessages.StackFrameMessage("Moving down stack trace...", false, st.ExtraStackFrames[1]);

                CheckEqual(expected, actual);
            }

            public void StackTraceMessage_StackTraceNull()
            {
                string actual = BuildMessages.StackTraceMessage(sampleMessage, samplePedigree, true, null);
                string expected = BuildMessages.MSBuildMessage(sampleMessage, samplePedigree, true, null, null);

                CheckEqual(expected, actual);
            }

			class NonsenseFrames : TestFixture
			{
				StackTrace stIgnored;
				StackTrace stNonsense;
				string ignoredExpected;
				string nonsenseExpected;
				StackFrame nonsenseFrame = new StackFrame(null, null, null);
                StackFrame origin = new StackFrame(file1, 1, samplePedigree);
                StackFrame oneDeep = new StackFrame(file2, 2, samplePedigree);
                StackFrame twoDeep = new StackFrame(file3, 3, samplePedigree);

				public override void FixtureSetup()
				{
					var sfs = new StackFrame[] {
                        nonsenseFrame,
						twoDeep,
                        nonsenseFrame,
						oneDeep,
                        nonsenseFrame,
						origin,
                        nonsenseFrame,
					};

                    stIgnored = new StackTrace(sfs, true);
                    stNonsense = new StackTrace(sfs, false);

                    const string movingDown = "Moving down stack trace...";

                    ignoredExpected = BuildMessages.StackFrameMessage(sampleMessage, true, origin) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, oneDeep) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, twoDeep);

                    nonsenseExpected = BuildMessages.StackFrameMessage(
                            sampleMessage, true, nonsenseFrame, samplePedigree) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, origin) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, nonsenseFrame) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, oneDeep) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, nonsenseFrame) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, twoDeep) + "\n" +
                        BuildMessages.StackFrameMessage(movingDown, false, nonsenseFrame);
				}

				public void Ignored()
				{
					string actual = BuildMessages.StackTraceMessage(sampleMessage, samplePedigree, true, stIgnored);

					CheckEqual(ignoredExpected, actual);
				}

				public void Nonsense()
				{
					string actual = BuildMessages.StackTraceMessage(sampleMessage, samplePedigree, true, stNonsense);

					CheckEqual(nonsenseExpected, actual);
				}

				public void AllNonsense()
				{
					StackFrame[] trace = {
                        nonsenseFrame,
                        nonsenseFrame
                    };

                    StackTrace st = new StackTrace(trace, true);

					string expected = BuildMessages.MSBuildMessage(sampleMessage, samplePedigree, true, null, null);
                    string actual = BuildMessages.StackTraceMessage(sampleMessage, samplePedigree, true, st);

					CheckEqual(expected, actual);
				}
			}
        }
        #endregion

        #region AutobuildTestError
        public void AutobuildTestError_Works()
        {
            // commented out because I can't figure out a good way to compare 
            // the two strings since they have to be different line numbers

            //string actual = BuildMessages.AutobuildTestError(sampleMessage);
            //StackFrame sf = new StackFrame(new System.Diagnostics.StackFrame(true));
            //string expected = BuildMessages.BuildTestErrorFromStackFrame(sampleMessage, sf);

            ////ignore the first bits involving file names and line numbers
            //actual = actual.Substring(actual.IndexOf(':'));
            //expected = expected.Substring(expected.IndexOf(':'));
            //CheckEqual(expected, actual);
        }

        public void AutobuildTestError_MessageNull()
        {
            // commented out because I can't figure out a good way to compare 
            // the two strings since they have to be different line numbers

            //string actual = BuildMessages.AutobuildTestError(null);
            //StackFrame sf = new StackFrame(new System.Diagnostics.StackFrame(true));
            //string expected = BuildMessages.BuildTestErrorFromStackFrame(sampleMessage, sf);

            ////[A-Za-z]:[\ or /] = drive
            //actual.Compa
            ////ignore the first bits involving file names and line numbers
            //actual = actual.Substring(actual.IndexOf(':'));
            //expected = expected.Substring(expected.IndexOf(':'));
            //CheckEqual(expected, actual);
        }
        #endregion

        #region UnexpectedExceptionMessage
        public void UnexpectedExceptionMessage_Works()
        {
            var exc = new System.Exception("bad thing");
            var sf = new StackFrame(new System.Diagnostics.StackFrame(true));
            string fullMessage = sampleMessage + ": \"Exception\" thrown: \"bad thing\"";

            string expected = BuildMessages.StackTraceMessage(fullMessage, samplePedigree, true, null);
            string actual = BuildMessages.UnexpectedExceptionMessage(sampleMessage, samplePedigree, exc);            

            CheckEqual(expected, actual);
        }

        public void UnexpectedExceptionMessage_ExcNull()
        {
            CheckThrow(typeof(System.ArgumentNullException));
            string actual = BuildMessages.UnexpectedExceptionMessage(sampleMessage, samplePedigree, null);
        }

        public void UnexpectedExceptionMessage_InnerException()
        {
            Exception exc;
            try
            {
                throw new Exception("Bottom");
            }
            catch(Exception bottomException)
            {
                try
                {
                    throw new Exception("Top", bottomException);
                }
                catch(Exception topException)
                {
                    exc = topException;
                }
            }

            var message = BuildMessages.UnexpectedExceptionMessage("message", "pedigree", exc);
            Check(message.Contains("Bottom"));
            Check(message.Contains("Top"));
            CheckEqual(2, message.Count(c => c.Equals('\n')) + 1);
        }
        #endregion
	}
}