// $Id$
// 
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
// 
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
// 
using System;
using System.Threading;
using NUnit.Framework;

namespace Org.Apache.Etch.Bindings.Csharp.Util
{
    [TestFixture]
    public class TestAlarmManager
    {
        private const int Q1 = 50;

        private const int Q2 = 100;

        private const int Q3 = 150;

        private readonly Object s1 = new Object();

        private readonly Object s2 = new Object();

        [Test]
        public void start1()
        {
            AlarmManager am = new AlarmManager();
            Assert.IsFalse(am.IsStarted());
            am.Start();
            Assert.IsTrue(am.IsStarted());
        }

        [Test]
        [ExpectedException(typeof(Exception))]
        public void start2()
        {
            // already started
            AlarmManager am = new AlarmManager();
            Assert.IsFalse(am.IsStarted());
            am.Start();
            Assert.IsTrue(am.IsStarted());
            am.Start();
        }

        [Test]
        [ExpectedException(typeof(Exception))]
        public void stop1()
        {
            // is not started
            AlarmManager am = new AlarmManager();
            Assert.IsFalse(am.IsStarted());
            am.Stop();
        }

        [Test]
        public void stop2()
        {
            AlarmManager am = new AlarmManager();
            Assert.IsFalse(am.IsStarted());
            am.Start();
            Assert.IsTrue(am.IsStarted());
            am.Stop();
            Assert.IsFalse(am.IsStarted());
        }

        [Test]
        public void static1()
        {
            AlarmManager.shutdown();

            Assert.IsNull(AlarmManager.GetAlarmManager(false));
            Assert.IsNull(AlarmManager.GetAlarmManager(false));

            AlarmManager am1 = AlarmManager.GetAlarmManager(true);
            Assert.IsNotNull(am1);
            Assert.IsTrue(am1.IsStarted());

            AlarmManager am2 = AlarmManager.GetAlarmManager(true);
            Assert.AreSame(am2, am1);
            Assert.IsTrue(am1.IsStarted());

            AlarmManager.shutdown();
            Assert.IsFalse(am1.IsStarted());
            Assert.IsNull(AlarmManager.GetAlarmManager(false));

            AlarmManager.shutdown();
        }

        [Test]
        public void listener1()
        {
            MyAlarmListener listener = new MyAlarmListener(0);

            Assert.AreEqual(0, listener.delay);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            listener.Wakeup(null, null, 12345);
            Assert.AreEqual(0, listener.delay);
            Assert.IsTrue(listener.wake.Get());
            Assert.IsNull(listener.state);

            listener.Wakeup(null, s1, 23456);
            Assert.AreEqual(0, listener.delay);
            Assert.IsTrue(listener.wake.Get());
            Assert.AreSame(s1, listener.state);

            MyAlarmListener listener1 = new MyAlarmListener(1);
            Assert.AreEqual(1, listener1.delay);
        }

        [Test]
        [ExpectedException(typeof(Exception))]
        public void add1()
        {
            // is not started
            AlarmManager am = new AlarmManager();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Add(listener, null, Q1);
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void add2()
        {
            // listener == null
            AlarmManager am = new AlarmManager();
            am.Start();

            am.Add(null, null, Q1);
        }

        [Test]
        [ExpectedException(typeof(ArgumentException))]
        public void add3()
        {
            // delay <= 0
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Add(listener, null, -1);
        }

        [Test]
        public void add4()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            //Log("Adding");
            am.Add(listener, null, Q1);
            //Log("Added");
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            Thread.Sleep(Q2);
            Assert.IsTrue(listener.wake.Get());
            Assert.IsNull(listener.state);
        }

        [Test]
        public void add5()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Add(listener, s1, Q1);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            Thread.Sleep(Q2);
            Assert.IsTrue(listener.wake.Get());
            Assert.AreSame(s1, listener.state);
        }

        [Test]
        public void add6()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Add(listener, s1, Q3);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            am.Add(listener, s2, Q1);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            Thread.Sleep(Q2);
            Assert.IsTrue(listener.wake.Get());
            Assert.AreSame(s2, listener.state);
        }

        [Test]
        public void add7()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            listener.excp = true;
            am.Add(listener, s1, Q1);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            Thread.Sleep(Q2);
            Assert.IsTrue(listener.wake.Get());
            Assert.AreSame(s1, listener.state);
        }

        [Test]
        [ExpectedException(typeof(Exception))]
        public void remove1()
        {
            // is not started
            AlarmManager am = new AlarmManager();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Remove(listener);
        }

        [Test]
        public void remove2()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Remove(listener);
        }

        [Test]
        public void remove3()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            am.Add(listener, null, Q1);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            am.Remove(listener);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);

            Thread.Sleep(Q2);
            Assert.IsFalse(listener.wake.Get());
            Assert.IsNull(listener.state);
        }

        [Test]
        public void repeat1()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            listener.delay = Q2;
            am.Add(listener, null, Q2);

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due0 = {0}", listener.due);
            long t0 = listener.due;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due1 = {0}", listener.due);
            long d1 = listener.due - t0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due2 = {0}", listener.due);
            long d2 = listener.due - t0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due3 = {0}", listener.due);
            long d3 = listener.due - t0;

            Thread.Sleep(Q1);
            listener.delay = 0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due4 = {0}", listener.due);
            long d4 = listener.due - t0;

            long m1 = (long) Math.Round(d1 / (double)d1);
            long m2 = (long) Math.Round(d2 / (double)d1);
            long m3 = (long) Math.Round(d3 / (double)d1);
            long m4 = (long) Math.Round(d4 / (double)d1);

            Console.WriteLine("times {0} {1} {2} {3} {4}", t0, d1, d2, d3, d4);

            Assert.AreEqual(1, m1);
            Assert.AreEqual(2, m2);
            Assert.AreEqual(3, m3);
            Assert.AreEqual(4, m4);
        }

        [Test]
        public void repeat2()
        {
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            listener.delay = -Q2;
            am.Add(listener, null, Q2);

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due0 = {0}", listener.due);
            long t0 = listener.due;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due1 = {0}", listener.due);
            long d1 = listener.due - t0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due2 = {0}", listener.due);
            long d2 = listener.due - t0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due3 = {0}", listener.due);
            long d3 = listener.due - t0;

            Thread.Sleep(Q1);
            listener.delay = 0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            Console.WriteLine("due4 = {0}", listener.due);
            long d4 = listener.due - t0;

            long m1 = (long) Math.Round(d1 / (double)d1);
            long m2 = (long) Math.Round(d2 / (double)d1);
            long m3 = (long) Math.Round(d3 / (double)d1);
            long m4 = (long) Math.Round(d4 / (double)d1);

            Console.WriteLine("times {0} {1} {2} {3} {4}", t0, d1, d2, d3, d4);

            Assert.AreEqual(1, m1);
            Assert.AreEqual(2, m2);
            Assert.AreEqual(3, m3);
            Assert.AreEqual(4, m4);
        }

        [Test]
        [ExpectedException(typeof(ThreadInterruptedException))]
        public void repeat3()
        {
            // timeout
            AlarmManager am = new AlarmManager();
            am.Start();

            MyAlarmListener listener = new MyAlarmListener(0);

            listener.delay = Q2;
            am.Add(listener, null, Q2);

            listener.wake.WaitUntilEqAndSet(true, Q3, false);

            listener.wake.WaitUntilEqAndSet(true, Q3, false);

            listener.wake.WaitUntilEqAndSet(true, Q3, false);

            Thread.Sleep(Q1);
            listener.delay = 0;

            listener.wake.WaitUntilEqAndSet(true, Q3, false);
            // alarm is now canceled

            // this should timeout...
            listener.wake.WaitUntilEqAndSet(true, Q3, false);
        }
    }

    class MyAlarmListener : AlarmListener
    {
        public MyAlarmListener(int delay)
        {
            this.delay = delay;
        }

        public int delay;

        public bool excp;

        public Monitor<bool> wake = new Monitor<bool>("wake", false);

        public object state;

        public long due;

        public int Wakeup(AlarmManager manager, object state, long due)
        {
            this.state = state;
            this.due = due;
            wake.Set(true);

            if (excp)
                throw new Exception();

            return delay;
        }
    }
}