?namespace Imps.Client.Pc
{
    using Imps.Client.Core;
    using Imps.Utils;
    using System;
    using System.Net.NetworkInformation;
    using System.Runtime.CompilerServices;

    public class AutoReconnect
    {
        private volatile int _maxTryTime = 3;
        private volatile int _nextInterval;
        private Random _rand = new Random(Environment.TickCount);
        private volatile bool _timerStarted;
        public volatile int _tryCounter;

        public event EventHandler<TickEventArgs> OnTick;

        public event EventHandler TimeUp;

        internal AutoReconnect(int maxTryTime)
        {
            this._maxTryTime = maxTryTime;
            IMPSNetworkChange.Instance.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(this.Instance_NetworkAvailabilityChanged);
            IMPSNetworkChange.Instance.NetworkRestored += new EventHandler(this.Instance_NetworkRestored);
        }

        private void AdjustInterval(object sender, EventArgs e)
        {
            if (--this._nextInterval >= 0)
            {
                if (this._nextInterval != 0)
                {
                    if (this.OnTick != null)
                    {
                        FuncDispatcher.InvokeEventHandlerInUiThread<TickEventArgs>(null, this.OnTick, new TickEventArgs(this._nextInterval));
                    }
                }
                else if (this.TimeUp != null)
                {
                    FuncDispatcher.InvokeEventHandlerInUiThread(null, this.TimeUp, EventArgs.Empty);
                }
            }
            else
            {
                this.StopTimer();
            }
        }

        public void ConnectNow()
        {
            this._nextInterval = 1;
        }

        private bool HasAvaildAbleNetwork()
        {
            return NetworkInterface.GetIsNetworkAvailable();
        }

        private void Instance_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
        {
            if (e.IsAvailable)
            {
                this.Instance_NetworkRestored(this, EventArgs.Empty);
            }
        }

        private void Instance_NetworkRestored(object sender, EventArgs e)
        {
            this.StopTimer(true);
            FuncDispatcher.InvokeEventHandlerInUiThread(this, this.TimeUp, EventArgs.Empty);
        }

        public void StartTimer()
        {
            if (!this._timerStarted && (this._tryCounter < this._maxTryTime))
            {
                this._timerStarted = true;
                this._nextInterval = this.NextInterval;
                this._tryCounter++;
                GlobalTimer.Register(new EventHandler(this.AdjustInterval), 10);
            }
        }

        public void StopTimer()
        {
            this.StopTimer(false);
        }

        public void StopTimer(bool reset)
        {
            GlobalTimer.Unregister(new EventHandler(this.AdjustInterval));
            this._timerStarted = false;
            if (reset)
            {
                this._tryCounter = 0;
            }
        }

        public int NextInterval
        {
            get
            {
                int num;
                int num2;
                switch (this._tryCounter)
                {
                    case 0:
                        num = 15;
                        num2 = 0x2d;
                        break;

                    case 1:
                        num = 0x2d;
                        num2 = 0x4b;
                        break;

                    case 2:
                        num = 90;
                        num2 = 150;
                        break;

                    default:
                        num = 180;
                        num2 = 300;
                        break;
                }
                return this._rand.Next(num, num2);
            }
        }
    }
}