using System;
using System.Collections.Generic;
using Developpez.Dotnet.Diagnostics;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests.Diagnostics
{
    [TestFixture]
    public class MethodCallMonitorTests
    {
        #region Test class

        class Dummy : MarshalByRefObject
        {
            public string LastCalledMethodName { get; private set; }

            public void Foo() { LastCalledMethodName = "Foo"; }

            public void Bar() { LastCalledMethodName = "Bar"; }

            public void Baz() { LastCalledMethodName = "Baz"; }

            public int TestRefOutParams(int x, ref int y, out int z)
            {
                y = y * 2;
                z = 42;
                return x + y + z;
            }
        }

        #endregion

        [Test]
        public void Test_MethodCallMonitor_EventsAreRaised()
        {
            var dummy = new Dummy();
            MethodCallMonitor<Dummy> monitor;
            var proxy = dummy.WrapForCallMonitor(out monitor);
            
            
            var raisedBeforeEvents = new List<string>();
            var raisedAfterEvents = new List<string>();
            monitor.BeforeMethodCall += (s, e) => raisedBeforeEvents.Add(e.MethodName);
            monitor.AfterMethodCall += (s, e) => raisedAfterEvents.Add(e.MethodName);
            
            proxy.Foo();
            proxy.Bar();
            proxy.Baz();

            var expected = new[] { "Foo", "Bar", "Baz" };
            CollectionAssert.AreEqual(expected, raisedBeforeEvents);
            CollectionAssert.AreEqual(expected, raisedAfterEvents);
        }

        [Test]
        public void Test_CallIsCancelled()
        {
            var dummy = new Dummy();
            MethodCallMonitor<Dummy> monitor;
            var proxy = dummy.WrapForCallMonitor(out monitor);

            monitor.BeforeMethodCall += (s, e) => e.Cancel = true;
            monitor.AfterMethodCall += (s, e) => Assert.IsTrue(e.Cancelled);

            proxy.Foo();
            proxy.Bar();
            proxy.Baz();

            Assert.IsNull(proxy.LastCalledMethodName);
        }

        [Test]
        public void Test_IgnoreNonMonitoredMethods()
        {
            var dummy = new Dummy();
            MethodCallMonitor<Dummy> monitor;
            var proxy = dummy.WrapForCallMonitor(out monitor);

            monitor.MonitoredMethods = new[] { "Foo" };

            var raisedBeforeEvents = new List<string>();
            var raisedAfterEvents = new List<string>();
            monitor.BeforeMethodCall += (s, e) => raisedBeforeEvents.Add(e.MethodName);
            monitor.AfterMethodCall += (s, e) => raisedAfterEvents.Add(e.MethodName);

            proxy.Foo();
            proxy.Bar();
            proxy.Baz();

            var expected = new[] { "Foo" };
            CollectionAssert.AreEqual(expected, raisedBeforeEvents);
            CollectionAssert.AreEqual(expected, raisedAfterEvents);
        }

        [Test]
        public void Test_RefOutParams()
        {
            var dummy = new Dummy();
            MethodCallMonitor<Dummy> monitor;
            var proxy = dummy.WrapForCallMonitor(out monitor);

            int x = 7;
            int y = 3;
            int z;
            int r = proxy.TestRefOutParams(x, ref y, out z);

            Assert.AreEqual(55, r);
            Assert.AreEqual(6, y);
            Assert.AreEqual(42, z);

            x = 7;
            y = 3;
            z = 0;
            r = 0;

            monitor.BeforeMethodCall += (s, e) => e.Cancel = true;

            r = proxy.TestRefOutParams(x, ref y, out z);
            Assert.AreEqual(0, r);
            Assert.AreEqual(3, y);
            Assert.AreEqual(0, z);
        }
    }
}