using System;

using System.Collections.Generic;

using System.Linq;

using System.ServiceModel;

using System.ServiceModel.Channels;

using System.Text;

using System.Threading.Tasks;

using System.Transactions;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using Moq;

using RockBus.DataContracts;

using RockBus.Logging.Trace;

using RockBus.Routing.Interfaces;

using RockBus.Routing.MessageConverters;

using RockBus.ServiceModel;

using RockBus.Subscription.Interfaces;

using RockBus.Threading;

using RockBus.Pipeline.Interfaces;

using RockBus.Utilities;

using RockBus.Messages.Interfaces;

using RockBus.Messages;



namespace RockBus.Routing.Tests

{

    public enum TestScenarioEnum

    {

        Success,

        ThrowException,

        SimulateException,

        SimulateFault,

    }



    [TestClass]

    public partial class RouterTests

    {

        private static Exception _testException = new Exception("Purposely thrown for testing.");



        private static Message _fault = Message.CreateMessage(MessageVersion.Default, FaultCode.CreateSenderFaultCode("RockBus", "http://rockbus.codeplex.com/"), "FaultReason", _testException, "http://FaultAction");

        private static IMessage _faultWrapper = new BufferedMessage(_fault, true);



        private static Message _message = RockBusAck.CreateMessage(MessageVersion.Default);

        private static IMessage _messageWrapper = new BufferedMessage(_message, true);



        // Vary/combine the following options:

        // - Publisher ExchangeType: OneWay, TwoWayAck, TwoWayRequestResponse

        // - Subscriber ExchangeType: OneWay, TwoWayAck, TwoWayRequestResponse

        // - Subscription Persistence: true, false

        // - Exceptions: Persistence, Delivery

        // - Responses: GenerateDefault, Advertised, RockBusAck

        // - Transformations: Advertisement/Subscription Request/Response

        // - ResponseManager: 



        // TestMethod Name Format:

        // TestRouter_PublisherExchangeType_SubscriberExchangeType_SubscriberPersistent_TestScenario



        private void ExecuteRouter(ExchangeTypeEnum subscriberExchangeType, ExchangeTypeEnum publisherExchangeType, bool persistent, Guid correlationId, TestScenarioEnum ts, out TaskCompletionSource<Message> tcs, out Task<TaskResultList> task, out TaskStatus sts)

        {

            // Arrange

            var tl = new TraceLogger();

            var mc = new MessageConverter();



            var ai = this.CreateDefaultAdvertisementInfo();

            var ar = this.CreateDefaultAdvertisedResponse();

            var si = this.CreateDefaultSubscriptionInfo(persistent, subscriberExchangeType);



            var mw = this.CreateDefaultMessageWrapper();



            var tx = new CommittableTransaction();

            tcs = new TaskCompletionSource<Message>();



            var rc = this.CreateDefaultRoutingContextMock(

                correlationId,

                ai,

                persistent,

                mw,

                publisherExchangeType,

                tcs,

                tx);



            var rh = new RoutingHeader(correlationId, publisherExchangeType, si.Detail, si.EndpointInfo);



            var taskResult = this.CreateDefaultTaskResult(

                rc.Object,

                rh,

                (subscriberExchangeType == ExchangeTypeEnum.TwoWayRequestResponse) ? _messageWrapper : null);



            Mock<ISendPort> psp, dsp;

            if (persistent)

            {

                psp = this.CreateDefaultSendPortMock(ts, taskResult);

                dsp = this.CreateDefaultSendPortMock(ts);

            }

            else

            {

                psp = this.CreateDefaultSendPortMock(ts);

                dsp = this.CreateDefaultSendPortMock(ts, taskResult);

            }



            var em = this.CreateDefaultEvaluationManagerMock(ai, ar, si);



            var rm = this.CreateDefaultResponseManagerMock();

            var pm = this.CreateDefaultPipelineManagerMock();



            // Act

            Router r = new Router(

                tl,

                mc,

                psp.Object,

                dsp.Object,

                em.Object,

                rm.Object,

                pm.Object);



            task = r.RouteMessageAsync(mw.Message, tx, tcs, publisherExchangeType);

            sts = task.WaitForCompletionStatus();

        }



        #region IRoutingContext



        private IMessage CreateDefaultMessageWrapper()

        {

            return _messageWrapper;

        }



        private Mock<IRoutingContext> CreateDefaultRoutingContextMock(Guid correlationId, AdvertisementInfo ai, bool persistent, IMessage messageWrapper, ExchangeTypeEnum publisherExchangeType, TaskCompletionSource<Message> tcs, Transaction transaction)

        {

            var mock = new Mock<IRoutingContext>();



            mock.Setup(x => x.AdvertisementInfo).Returns(ai);

            mock.Setup(x => x.ContainsPersistentSubscriptions).Returns(persistent);

            mock.Setup(x => x.CorrelationId).Returns(correlationId);

            mock.Setup(x => x.MessageWrapper).Returns(messageWrapper);

            mock.Setup(x => x.PublisherExchangeType).Returns(publisherExchangeType);

            mock.Setup(x => x.RequestMessageVersion).Returns(messageWrapper.Version);

            mock.Setup(x => x.Task).Returns(tcs.Task);

            mock.Setup(x => x.Transaction).Returns(transaction);



            return mock;

        }



        #endregion



        #region ISendPort



        private TaskResult CreateDefaultTaskResult(IRoutingContext routingContext, RoutingHeader routingHeader, IMessage response = null)

        {

            return new TaskResult(routingContext, routingHeader, response);

        }



        private Mock<ISendPort> CreateDefaultSendPortMock(TestScenarioEnum ts, params TaskResult[] taskResults)

        {

            return CreateDefaultSendPortMock(ts, (IEnumerable<TaskResult>)taskResults);

        }



        private Mock<ISendPort> CreateDefaultSendPortMock(TestScenarioEnum ts, IEnumerable<TaskResult> taskResults)

        {

            var mock = new Mock<ISendPort>();



            mock.Setup(x => x.RouteMessageAsync(It.IsAny<IRoutingContext>(), It.IsAny<RoutingHeader[]>()))

                .Returns<IRoutingContext, RoutingHeader[]>((rc, rhs) =>

                {

                    return this.ReturnDefaultTaskResultList(ts, taskResults);

                });

            mock.Setup(x => x.RouteMessageAsync(It.IsAny<IRoutingContext>(), It.IsAny<IEnumerable<RoutingHeader>>()))

                .Returns<IRoutingContext, IEnumerable<RoutingHeader>>((rc, rhs) =>

                {

                    return this.ReturnDefaultTaskResultList(ts, taskResults);

                });



            return mock;

        }



        private Task<TaskResultList> ReturnDefaultTaskResultList(TestScenarioEnum ts, IEnumerable<TaskResult> taskResults)

        {

            TaskCompletionSource<TaskResultList> tcs = new TaskCompletionSource<TaskResultList>();

            var trl = new TaskResultList();



            switch (ts)

            {

                case TestScenarioEnum.Success:

                    if (!taskResults.IsNullOrEmpty())

                    {

                        trl.AddRange(taskResults);

                    }

                    break;

                case TestScenarioEnum.ThrowException:

                    throw _testException;

                case TestScenarioEnum.SimulateException:

                    foreach (var tr in taskResults)

                    {

                        var mrr = new MapReduceResult<IRoutingContext, RoutingHeader, IMessage>(tr.RequestContext, tr.RoutingHeader, _testException);

                        var exTr = new TaskResult(mrr);

                        trl.Add(exTr);

                    }

                    break;

                case TestScenarioEnum.SimulateFault:

                    foreach (var tr in taskResults)

                    {

                        tr.Response = _faultWrapper;

                        trl.Add(tr);

                    }

                    break;

                default:

                    break;

            }



            tcs.SetResult(trl);

            return tcs.Task;

        }



        #endregion



        #region ITransformationManager



        private Mock<IPipelineManager> CreateDefaultPipelineManagerMock()

        {

            var mock = new Mock<IPipelineManager>();



            mock.Setup(x => x.ExecuteInboundRequestPipeline(It.IsAny<IRoutingContext>(), It.IsAny<AdvertisementDetail>()))

                .Returns<IRoutingContext, AdvertisementDetail>((rc, ad) =>

                {

                    return rc;

                });

            mock.Setup(x => x.ExecuteOutboundRequestPipeline(It.IsAny<IRoutingContext>(), It.IsAny<SubscriptionDetail>()))

                .Returns<IRoutingContext, SubscriptionDetail>((rc, sd) =>

                {

                    return rc;

                });

            mock.Setup(x => x.ExecuteInboundResponsePipeline(It.IsAny<IMessage>(), It.IsAny<IRoutingContext>(), It.IsAny<SubscriptionDetail>()))

                .Returns<IMessage, IRoutingContext, SubscriptionDetail>((mw, rc, sd) =>

                {

                    return mw;

                });

            mock.Setup(x => x.ExecuteOutboundResponsePipeline(It.IsAny<IMessage>(), It.IsAny<IRoutingContext>(), It.IsAny<AdvertisementDetail>()))

                .Returns<IMessage, IRoutingContext, AdvertisementDetail>((mw, rc, ad) =>

                {

                    return mw;

                });



            return mock;

        }



        #endregion



        #region IResponseManager



        private Mock<IResponseManager> CreateDefaultResponseManagerMock()

        {

            var mock = new Mock<IResponseManager>();



            mock.Setup(x => x.CreateResponseHandler(It.IsAny<IRoutingContext>(), It.IsAny<AdvertisementInfo>()))

                .Callback<IRoutingContext, AdvertisementInfo>((rc, ai) =>

                {

                })

                .Returns(true);

            mock.Setup(x => x.HandleResult(It.IsAny<IRoutingContext>()))

                .Callback<IRoutingContext>((rc) =>

                {

                });



            return mock;

        }



        #endregion



        #region IEvaluationManager



        private Mock<IEvaluationManager> CreateDefaultEvaluationManagerMock(AdvertisementInfo ai, Message ar, SubscriptionInfo si)

        {

            var mock = new Mock<IEvaluationManager>();



            mock.Setup(x => x.EvaluateAdvertisements(It.IsAny<IMessage>(), It.IsAny<EvaluationResult>()))

                .Callback<IMessage, EvaluationResult>((mw, er) =>

                {

                    er.AddAdvertisement(ai);

                    er.AdvertisedResponse = ar;

                });

            mock.Setup(x => x.EvaluateSubscriptions(It.IsAny<IMessage>(), It.IsAny<EvaluationResult>()))

                .Callback<IMessage, EvaluationResult>((mw, er) =>

                {

                    er.AddSubscription(si);

                });



            return mock;

        }



        private AdvertisementInfo CreateDefaultAdvertisementInfo()

        {

            var pi = new PublisherInfo("DefaultPublisher");

            var ad = new AdvertisementDetail(pi.Id, "DefaultAdvertisement");

            var ai = new AdvertisementInfo(pi, ad);

            ai.GenerateDefaultResponse = true;



            return ai;

        }



        private Message CreateDefaultAdvertisedResponse()

        {

            Message ar = RockBusAck.CreateMessage(MessageVersion.Default);



            return ar;

        }



        private SubscriptionInfo CreateDefaultSubscriptionInfo(bool persistent, ExchangeTypeEnum exchangeType)

        {

            var nis = new List<NamespaceInfo>();



            var fis = new List<FilterInfo>();



            var eis = new List<EndpointInfo>()

                {

                    new EndpointInfo("Endpoint1", "http://FakeAddress", EndpointNameEnum.BasicHttpEndpoint, exchangeType)

                };



            var pis = new List<PipelineInfo>();



            var si = new SubscriberInfo("DefaultSubscriber", nis, fis, eis, pis, null, DateTime.Now);



            var sd = new SubscriptionDetail(si.Id, "DefaultSubscription", persistent);

            var spi = new SubscriptionInfo(si, sd, eis.First(), fis);



            return spi;

        }



        #endregion EvaluationManager

    }

}