?namespace ElementIT.PowUpload
{
    using System;
    using System.Threading;

    internal class BandwidthControl
    {
        private long _bytesReadFromLastTime;
        private long _chunkSize;
        private string _id;
        private double _intervalNeededTicks;
        private bool _IsLimit;
        private DateTime _prevTime;
        private long _speedlimit;
        private long _ticksFromLastTime;
        private const double SleepStep = 0.2;

        internal BandwidthControl()
        {
            this._bytesReadFromLastTime = 0;
            this._chunkSize = 0;
            this._speedlimit = -1;
            this._intervalNeededTicks = 0;
            this._IsLimit = false;
            this._ticksFromLastTime = 0;
        }

        internal BandwidthControl(string id, int chunkSize, int speedLimit)
        {
            this._bytesReadFromLastTime = 0;
            this._chunkSize = 0;
            this._speedlimit = -1;
            this._intervalNeededTicks = 0;
            this._IsLimit = false;
            this._ticksFromLastTime = 0;
            this._id = id;
            UploadModule.AddDebugInfo("BandwidthControl.Constructor()", this._id);
            this._chunkSize = chunkSize;
            this._speedlimit = speedLimit;
            this.Reset();
        }

        internal void Limit(long bytesRead)
        {
            long num = 0;
            long ticks = DateTime.Now.Subtract(this._prevTime).Ticks;
            this._bytesReadFromLastTime += bytesRead;
            if (ticks > 0)
            {
                this._ticksFromLastTime += ticks;
                double num3 = (this._bytesReadFromLastTime * 0x2710) / this._ticksFromLastTime;
                double num4 = this._speedlimit / ((long) 0x3e8);
                if (num3 > num4)
                {
                    double num5 = num3 / num4;
                    if (num5 > 1.2)
                    {
                        num = (long) (this._intervalNeededTicks * 1.2);
                    }
                    else
                    {
                        num = (long) (this._intervalNeededTicks * num5);
                    }
                }
                else if (num4 > num3)
                {
                    double num6 = num4 / num3;
                    if (num6 > 1.2)
                    {
                        num = (long) (this._intervalNeededTicks * 0.8);
                    }
                    else
                    {
                        num = (long) (this._intervalNeededTicks * (2 - num6));
                    }
                }
                else
                {
                    num = (long) this._intervalNeededTicks;
                }
                this._ticksFromLastTime = 0;
                this._bytesReadFromLastTime = 0;
            }
            else
            {
                num = (long) this._intervalNeededTicks;
            }
            this._prevTime = DateTime.Now;
            if (num > 0)
            {
                Thread.Sleep((int) (num / ((long) 0x2710)));
            }
        }

        private void Reset()
        {
            if (this._speedlimit > 0)
            {
                this._IsLimit = true;
                this._intervalNeededTicks = (0x989680 * this._chunkSize) / this._speedlimit;
            }
            else
            {
                this._IsLimit = false;
                this._intervalNeededTicks = 0;
            }
            this._bytesReadFromLastTime = 0;
            this._ticksFromLastTime = 0;
            this._prevTime = DateTime.Now;
        }

        internal bool IsLimit
        {
            get
            {
                return this._IsLimit;
            }
        }

        internal long SpeedLimit
        {
            get
            {
                return this._speedlimit;
            }
            set
            {
                this._speedlimit = value;
                this.Reset();
            }
        }
    }
}