using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using NUnit.Framework;

using CodeMadeSimple.Common.Tests;

using CodeMadeSimple.BOPE.Core;

using Moq;

using Microsoft.SqlServer.Server;

using System.Data;



namespace CodeMadeSimple.BOPE.SQLRepository.Tests

{

    [TestFixture]

    public class BuildActionExecutionTableTests

    {

        [Test]

        public void Constructor_NullListArg_ThrowsException()

        {

            ExceptionAssert.AssertNullArgumentException("list", () => new BuildActionExecutionTable(null));

        }



        [Test]

        public void Constructor_NonNullListArg_SetsList()

        {

            Mock<IEnumerable<BuildProcessExecution>> list = new Mock<IEnumerable<BuildProcessExecution>>(MockBehavior.Strict);



            Assert.AreSame(list.Object, new BuildActionExecutionTable(list.Object).InnerList);

        }



        [Test]

        public void GetEnumerator_EmptyList_ReturnsEmptyEnumerator()

        {

            List<BuildProcessExecution> list = new List<BuildProcessExecution>();



            IEnumerator<SqlDataRecord> records = new BuildActionExecutionTable(list).GetEnumerator();



            Assert.IsFalse(records.MoveNext());

        }



        [TestCase(1)]

        [TestCase(3)]

        public void GetEnumerator_NonEmptyListButNullActions_ReturnsEmptyEnumerator(int count)

        {

            List<BuildProcessExecution> list = new List<BuildProcessExecution>();



            for (int i = 0; i < count; i++)

            {

                Mock<BuildProcessExecution> exec = new Mock<BuildProcessExecution>();



                exec.Setup(x => x.Actions).Returns((IEnumerable<BuildActionExecution>)null);



                list.Add(exec.Object);

            }



            IEnumerator<SqlDataRecord> records = new BuildActionExecutionTable(list).GetEnumerator();



            Assert.IsFalse(records.MoveNext());

        }



        [TestCase(1)]

        [TestCase(3)]

        public void GetEnumerator_NonEmptyListButNoActions_ReturnsEmptyEnumerator(int count)

        {

            List<BuildProcessExecution> list = new List<BuildProcessExecution>();



            for (int i = 0; i < count; i++)

            {

                Mock<BuildProcessExecution> exec = new Mock<BuildProcessExecution>();



                exec.Setup(x => x.Actions).Returns(new List<BuildActionExecution>());



                list.Add(exec.Object);

            }



            IEnumerator<SqlDataRecord> records = new BuildActionExecutionTable(list).GetEnumerator();



            Assert.IsFalse(records.MoveNext());

        }



        [TestCase(1, 2, 3, 1)]

        [TestCase(4, 3, 2, 5)]

        public void GetEnumerator_NonEmptyListWithActionsAndSubActions_ReturnsExpectedIterator(int procCount, int actCount, int childActCount, int depthCount)

        {

            List<BuildActionExecution> allActs = new List<BuildActionExecution>();

            List<BuildProcessExecution> procs = new List<BuildProcessExecution>();



            for (int i = 0; i < procCount; i++)

            {

                Mock<BuildProcessExecution> proc = new Mock<BuildProcessExecution>();

                proc.Setup(x => x.Id).Returns(Guid.NewGuid());



                List<BuildActionExecution> acts = new List<BuildActionExecution>();



                for (int j = 0; j < actCount; j++)

                {

                    Mock<BuildActionExecution> act = CreateAct(proc.Object, allActs);



                    act.Setup(x => x.ParentStep).Returns((BuildActionExecution)null);



                    allActs.Add(act.Object);

                    acts.Add(act.Object);



                    int currentDepth = 0;



                    SetChildActions(proc.Object, childActCount, allActs, act, depthCount, ref currentDepth);

                }



                proc.Setup(x => x.Actions).Returns(acts);



                procs.Add(proc.Object);

            }



            BuildActionExecutionTable table = new BuildActionExecutionTable(procs);



            int procCounter = 0;

            int actFromSameProcCounter = 0;

            int allActsCounter = 0;

            int expectedActsPerProc = ((childActCount * depthCount) + 1) * actCount;



            foreach (SqlDataRecord dr in table)

            {

                BuildProcessExecution proc = procs[procCounter];



                BuildActionExecution act = allActs[allActsCounter];



                Assert.AreEqual(allActsCounter.ToString(), act.Name);



                Assert.AreEqual(act.Id, dr.GetGuid(0));

                Assert.AreEqual(proc.Id, dr.GetGuid(1));

                Assert.AreEqual(act.Name, dr.GetString(2));



                if (act.ParentStep != null)

                {

                    Assert.AreEqual(act.ParentStep.Id, dr.GetGuid(6));

                    Assert.AreEqual(new List<BuildActionExecution>(act.ParentStep.GetSubActions()).IndexOf(act), dr.GetInt32(3));

                }

                else

                {

                    Assert.IsTrue(dr.IsDBNull(6));

                    Assert.AreEqual(new List<BuildActionExecution>(proc.Actions).IndexOf(act), dr.GetInt32(3));

                }



                if (act.StartTime != null)

                    Assert.AreEqual(act.StartTime, dr.GetDateTime(4));

                else

                    Assert.IsTrue(dr.IsDBNull(4));



                if (act.EndTime != null)

                    Assert.AreEqual(act.EndTime, dr.GetDateTime(5));

                else

                    Assert.IsTrue(dr.IsDBNull(5));

                

                actFromSameProcCounter++;



                if (actFromSameProcCounter >= expectedActsPerProc)

                {

                    // If all the acts from same process were asserted, go to next process

                    procCounter++;

                    actFromSameProcCounter = 0;

                }



                allActsCounter++;

            }



            Assert.AreEqual(allActs.Count, allActsCounter);

        }



        private static void SetChildActions(BuildProcessExecution proc, int childActCount, List<BuildActionExecution> allActs, Mock<BuildActionExecution> act, int depthCount, ref int currentDepth)

        {

            if (currentDepth < depthCount)

            {

                currentDepth++;



                List<BuildActionExecution> subActs = new List<BuildActionExecution>();



                for (int k = 0; k < childActCount; k++)

                {

                    Mock<BuildActionExecution> subAct = CreateAct(proc, allActs);



                    subAct.Setup(x => x.ParentStep).Returns(act.Object);



                    allActs.Add(subAct.Object);

                    subActs.Add(subAct.Object);



                    SetChildActions(proc, childActCount, allActs, subAct, depthCount, ref currentDepth);

                }



                act.Setup(x => x.GetSubActions()).Returns(subActs.ToArray());

            }

            else

            {

                act.Setup(x => x.GetSubActions()).Returns((BuildActionExecution[])null);

            }

        }



        private static Mock<BuildActionExecution> CreateAct(BuildProcessExecution proc, List<BuildActionExecution> allActs)

        {

            Random random = new Random();



            Mock<BuildActionExecution> act = new Mock<BuildActionExecution>(MockBehavior.Strict);



            act.Setup(x => x.BuildProcess).Returns(proc);

            act.Setup(x => x.Name).Returns(allActs.Count.ToString());

            act.Setup(x => x.Id).Returns(Guid.NewGuid());



            if (Convert.ToBoolean(random.Next(0, 1)))

                act.Setup(x => x.StartTime).Returns(new DateTime(allActs.Count));

            else

                act.Setup(x => x.StartTime).Returns((DateTime?)null);



            if (Convert.ToBoolean(random.Next(0, 1)))

                act.Setup(x => x.EndTime).Returns(new DateTime(allActs.Count + 1));

            else

                act.Setup(x => x.EndTime).Returns((DateTime?)null);



            return act;

        }



        [Test]

        public void CreateDataRecord_ReturnsExpectedDataRecord()

        {

            BuildActionExecutionTable table = new BuildActionExecutionTable(new Mock<IEnumerable<BuildProcessExecution>>().Object);



            SqlDataRecord rec = table.CreateDataRecord();



            Assert.NotNull(rec);



            Assert.AreEqual(7, rec.FieldCount);



            Helper.AssertMetadata(rec.GetSqlMetaData(0), "Id", SqlDbType.UniqueIdentifier);

            Helper.AssertMetadata(rec.GetSqlMetaData(1), "BuildProcessId", SqlDbType.UniqueIdentifier);

            Helper.AssertMetadata(rec.GetSqlMetaData(2), "BuildActionName", SqlDbType.VarChar);

            Helper.AssertMetadata(rec.GetSqlMetaData(3), "ExecutionOrder", SqlDbType.Int);

            Helper.AssertMetadata(rec.GetSqlMetaData(4), "StartTime", SqlDbType.DateTime2);

            Helper.AssertMetadata(rec.GetSqlMetaData(5), "EndTime", SqlDbType.DateTime2);

            Helper.AssertMetadata(rec.GetSqlMetaData(6), "ParentId", SqlDbType.UniqueIdentifier);

        }

    }

}