using System;
using System.Reflection;
using System.Threading;
using Implab.Parallels;
using Implab.Components;
using Implab.Test.Mock;

#if MONO

using NUnit.Framework;
using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
using TestMethodAttribute = NUnit.Framework.TestAttribute;
using AssertFailedException = NUnit.Framework.AssertionException;
#else

using Microsoft.VisualStudio.TestTools.UnitTesting;

#endif

namespace Implab.Test {
    [TestClass]
    public class RunnableComponentTests {

        static void ShouldThrow(Action action) {
            try {
                action();
                Assert.Fail();
            } catch (AssertFailedException) {
                throw;
            } catch {
            }
        }



        [TestMethod]
        public void NormalFlowTest() {
            var comp = new MockRunnableComponent(false);

            Assert.AreEqual(ExecutionState.Created, comp.State);

            comp.Initialize();

            Assert.AreEqual(ExecutionState.Ready, comp.State);

            comp.Start().Join(1000);

            Assert.AreEqual(ExecutionState.Running, comp.State);

            comp.Stop().Join(1000);

            Assert.AreEqual(ExecutionState.Disposed, comp.State);

        }

        [TestMethod]
        public void InitFailTest() {
            var comp = new MockRunnableComponent(false) {
                MockInit = () => {
                    throw new Exception("BAD");
                }
            };

            ShouldThrow(() => comp.Start());
            ShouldThrow(() => comp.Stop());
            Assert.AreEqual(ExecutionState.Created, comp.State);

            ShouldThrow(comp.Initialize);

            Assert.AreEqual(ExecutionState.Failed, comp.State);

            ShouldThrow(() => comp.Start());
            ShouldThrow(() => comp.Stop());
            Assert.AreEqual(ExecutionState.Failed, comp.State);

            comp.Dispose();
            Assert.AreEqual(ExecutionState.Disposed, comp.State);
        }

        [TestMethod]
        public void DisposedTest() {

            var comp = new MockRunnableComponent(false);
            comp.Dispose();

            ShouldThrow(() => comp.Start());
            ShouldThrow(() => comp.Stop());
            ShouldThrow(comp.Initialize);

            Assert.AreEqual(ExecutionState.Disposed, comp.State);
        }

        [TestMethod]
        public void ShouldCallDisposeOnStop() {
            var comp = new MockRunnableComponent(true);

            bool disposed = false;
            comp.MockDispose = (disposing) => {
                disposed = true;
            };

            comp.Start().Join(1000);
            comp.Stop().Join(1000);

            ShouldThrow(() => comp.Start());
            ShouldThrow(() => comp.Stop());
            ShouldThrow(comp.Initialize);

            Assert.AreEqual(ExecutionState.Disposed, comp.State);
            Assert.IsTrue(disposed);
        }

        [TestMethod]
        public void ShouldNotCallDisposeOnStop() {
            var comp = new MockRunnableComponent(true, true);

            bool disposed = false;
            comp.MockDispose = (disposing) => {
                disposed = true;
            };

            comp.Start().Join(1000);
            comp.Stop().Join(1000);

            Assert.AreEqual(ExecutionState.Ready, comp.State);
            Assert.IsFalse(disposed);
        }

        [TestMethod]
        public void SelfDisposeOnStop() {
            var comp = new MockRunnableComponent(true, true);

            bool disposed = false;
            comp.MockDispose = (disposing) => {
                disposed = true;
            };

            comp.Start().Join(1000);
            comp.Stop().Join(1000);

            Assert.AreEqual(ExecutionState.Ready, comp.State);
            Assert.IsFalse(disposed);

            comp.MockStop = () => {
                comp.Dispose();
                return Promise.Success;
            };

            comp.Start().Join(1000);
            comp.Stop().Join(1000);

            Assert.AreEqual(ExecutionState.Disposed, comp.State);
            Assert.IsTrue(disposed);
        }

        [TestMethod]
        public void StartCancelTest() {
            var comp = new MockRunnableComponent(true) {
                MockStart = () => PromiseHelper.Sleep(100000, 0)
            };

            var p = comp.Start();
            Assert.AreEqual(ExecutionState.Starting, comp.State);
            p.Cancel();
            ShouldThrow(() => p.Join(1000));
            Assert.AreEqual(ExecutionState.Failed, comp.State);

            Assert.IsTrue(comp.LastError is OperationCanceledException);

            comp.Dispose();
        }

        [TestMethod]
        public void StartStopTest() {
            var stop = new Signal();
            var comp = new MockRunnableComponent(true) {
                MockStart = () => PromiseHelper.Sleep(100000, 0),
                MockStop = () => AsyncPool.RunThread(stop.Wait)
            };

            var p1 = comp.Start();
            var p2 = comp.Stop();
            // should enter stopping state

            ShouldThrow(p1.Join);
            Assert.IsTrue(p1.IsCancelled);
            Assert.AreEqual(ExecutionState.Stopping, comp.State);

            stop.Set();
            p2.Join(1000);
            Assert.AreEqual(ExecutionState.Disposed, comp.State);
        }

        [TestMethod]
        public void StartStopFailTest() {
            var comp = new MockRunnableComponent(true) {
                MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
            };

            comp.Start();
            var p = comp.Stop();
            // if Start fails to cancel, should fail to stop
            ShouldThrow(() => p.Join(1000));
            Assert.AreEqual(ExecutionState.Failed, comp.State);
            Assert.IsNotNull(comp.LastError);
            Assert.AreEqual("I'm dead", comp.LastError.Message);
        }

        [TestMethod]
        public void StopCancelTest() {
            var comp = new MockRunnableComponent(true) {
                MockStop = () => PromiseHelper.Sleep(100000, 0)
            };

            comp.Start();
            var p = comp.Stop();
            Assert.AreEqual(ExecutionState.Stopping, comp.State);
            p.Cancel();
            ShouldThrow(() => p.Join(1000));
            Assert.AreEqual(ExecutionState.Failed, comp.State);
            Assert.IsTrue(comp.LastError is OperationCanceledException);

            comp.Dispose();
        }

    }
}