public TrackerPeersAdded(TorrentManager manager, int peersAdded, int total, MonoTorrent.Client.Tracker.Tracker tracker)
            :base (manager, peersAdded, total)
        {
            if (tracker == null)
                throw new ArgumentNullException("tracker");

            this.tracker = tracker;
        }

        public TorrentStreamManager(TorrentManager torrentManager, long prepareSize = 10*1024L*1024L)
        {
            TorrentManager = torrentManager;
            _prepareSize = prepareSize;

            TorrentManager.TorrentStateChanged += TorrentManager_TorrentStateChanged;
        }

 /// <summary>
 ///     Initializes a new instance of the <see cref="ChokeUnchokeManager" /> class.
 /// </summary>
 /// <param name="torrentManager">The torrent manager.</param>
 /// <param name="minimumTimeBetweenReviews">The minimum time between reviews.</param>
 /// <param name="percentOfMaxRateToSkipReview">The percent of maximum rate to skip review.</param>
 public ChokeUnchokeManager(TorrentManager torrentManager, int minimumTimeBetweenReviews,
     int percentOfMaxRateToSkipReview)
 {
     _owningTorrent = torrentManager;
     _minimumTimeBetweenReviews = minimumTimeBetweenReviews;
     _percentOfMaxRateToSkipReview = percentOfMaxRateToSkipReview;
 }

 public PieceMessage(TorrentManager manager, int pieceIndex, int startOffset, int blockLength)
 {
     this.manager = manager;
     this.pieceIndex = pieceIndex;
     this.startOffset = startOffset;
     this.requestLength = blockLength;
 }

        public static PeerMessage DecodeMessage(byte[] buffer, int offset, int count, TorrentManager manager)
        {
            PeerMessage message;
            CreateMessage creator;

            if (count < 4)
                throw new ArgumentException("A message must contain a 4 byte length prefix");

            int messageLength = IPAddress.HostToNetworkOrder(BitConverter.ToInt32(buffer, offset));

            if (messageLength > (count - 4))
                throw new ArgumentException("Incomplete message detected");

            if (buffer[offset + 4] == ExtensionMessage.MessageId)
                return ExtensionMessage.DecodeMessage(buffer, offset + 4 + 1, count - 4 - 1, manager);

            if (!messageDict.TryGetValue(buffer[offset + 4], out creator))
                throw new ProtocolException("Unknown message received");

            // The message length is given in the second byte and the message body follows directly after that
            // We decode up to the number of bytes Received. If the message isn't complete, throw an exception
            message = creator(manager);
            message.Decode(buffer, offset + 4 + 1, count - 4 - 1);
            return message;
        }

        public StoppingMode(TorrentManager manager)
            : base(manager)
        {
            CanAcceptConnections = false;
            var engine = manager.Engine;

            var hashingMode = manager.Mode as HashingMode;
            if (hashingMode != null)
                _handle.AddHandle(hashingMode.HashingWaitHandle, "Hashing");

            if (manager.TrackerManager.CurrentTracker != null)
                _handle.AddHandle(manager.TrackerManager.Announce(TorrentEvent.Stopped), "Announcing");

            foreach (var id in manager.Peers.ConnectedPeers.Where(id => id.Connection != null))
                id.Connection.Dispose();

            manager.Peers.ClearAll();

            _handle.AddHandle(engine.DiskManager.CloseFileStreams(manager), "DiskManager");

            manager.Monitor.Reset();
            manager.PieceManager.Reset();
            engine.ConnectionManager.CancelPendingConnects(manager);
            engine.Stop();
        }

        private DateTime timeOfLastReview; //When we last reviewed the choke/unchoke position

        #endregion Fields

        #region Constructors

        /// <summary>
        ///     Creates a new choke/unchoke manager for a torrent manager
        ///     </summeary>
        ///     <param name="TorrentManager">The torrent manager this choke/unchoke manager belongs to</param>
        public ChokeUnchokeManager(TorrentManager TorrentManager, int MinimumTimeBetweenReviews,
			int PercentOfMaxRateToSkipReview)
        {
            owningTorrent = TorrentManager;
            minimumTimeBetweenReviews = MinimumTimeBetweenReviews;
            percentOfMaxRateToSkipReview = PercentOfMaxRateToSkipReview;
        }

        public void AddConnection(TorrentConnection connection, TorrentManager manager)
        {
            string remoteId = String.Empty;

            LoggingService.LogDebug("AddConnection(): Start");

            if (!connection.IsIncoming) {
                // Send my identity.
                // XXX: This absolutely needs to be signed.
                connection.Transport.SendMessage(System.Text.Encoding.ASCII.GetBytes(Core.MyNodeID));

                // Get other end's identity.
                byte[] message = connection.Transport.ReceiveMessage();
                remoteId = System.Text.Encoding.ASCII.GetString(message);

            } else {
                // Get other end's identity.
                byte[] message = connection.Transport.ReceiveMessage();
                remoteId = System.Text.Encoding.ASCII.GetString(message);

                // Send my identity.
                // XXX: This absolutely needs to be signed.
                connection.Transport.SendMessage(System.Text.Encoding.ASCII.GetBytes(Core.MyNodeID));
            }

            LoggingService.LogDebug("Pushing connection to engine: {0} - {1}", connection.IsIncoming ? "Incoming" : "Outgoing",
                              ((Meshwork.Transport.TcpTransport)connection.Transport).RemoteEndPoint.ToString());

            Peer p = new Peer("", new Uri(String.Format("meshwork:{0}", remoteId)), EncryptionTypes.PlainText);
            RaiseConnectionReceived(p, connection, manager);

            LoggingService.LogDebug("AddConnection(): End");
        }

 /// <summary>
 ///     Create new instance of PeerConnectionFailedEventArgs for peer from given torrent.
 /// </summary>
 /// <param name="manager"></param>
 /// <param name="peer"></param>
 /// <param name="direction">Which direction the connection attempt was</param>
 /// <param name="message">Message associated with the failure</param>
 public PeerConnectionFailedEventArgs(TorrentManager manager, Peer peer, Direction direction, String message)
     : base(manager)
 {
     this.peer = peer;
     connectionDirection = direction;
     this.message = message;
 }

        public StoppingMode(TorrentManager manager)
            : base(manager)
        {
            CanAcceptConnections = false;
            var engine = manager.Engine;
            if (manager.Mode is HashingMode)
                handle.AddHandle(((HashingMode) manager.Mode).hashingWaitHandle, "Hashing");

            if (manager.TrackerManager.CurrentTracker != null &&
                manager.TrackerManager.CurrentTracker.Status == TrackerState.Ok)
                handle.AddHandle(manager.TrackerManager.Announce(TorrentEvent.Stopped), "Announcing");

            foreach (var id in manager.Peers.ConnectedPeers)
                if (id.Connection != null)
                    id.Connection.Dispose();

            manager.Peers.ClearAll();

            handle.AddHandle(engine.DiskManager.CloseFileStreams(manager), "DiskManager");

            manager.Monitor.Reset();
            manager.PieceManager.Reset();
            engine.ConnectionManager.CancelPendingConnects(manager);
            engine.Stop();
        }

 public AsyncConnectState(TorrentManager manager, Peer peer, IConnection connection, AsyncConnect callback)
 {
     Manager = manager;
     Peer = peer;
     Connection = connection;
     Callback = callback;
 }

 public void AddTorrent(string path)
 {
     Torrent torrent = Torrent.Load(path);
     TorrentManager manager = new TorrentManager(torrent, downloadsPath, defaultSettings);
     engine.Register(manager);
     managerCollection.Add(manager);
 }

 /// <summary>
 /// Creates a new PeerMessageEventArgs
 /// </summary>
 /// <param name="manager">The manager.</param>
 /// <param name="message">The peer message involved</param>
 /// <param name="direction">The direction of the message</param>
 /// <param name="id">The identifier.</param>
 internal PeerMessageEventArgs(TorrentManager manager, PeerMessage message, Direction direction, PeerId id)
     : base(manager)
 {
     Direction = direction;
     ID = id;
     Message = message;
 }

		public void Start()
		{
			foreach (string file in Directory.GetFiles(downloadsPath, "*.torrent"))
			{
				Torrent torrent = Torrent.Load(file);
				string savePath = Path.Combine(downloadsPath, torrent.Name);
				var manager = new TorrentManager(torrent, savePath, new TorrentSettings());
				manager.TorrentStateChanged +=
					delegate(object sender, TorrentStateChangedEventArgs e)
					{
							if(e.NewState==TorrentState.Seeding)
							{
								ReportSeeding(e.TorrentManager.Torrent.Name);
							}
						 Console.WriteLine("Torrent {0} changed: {1} -> {2}", e.TorrentManager.Torrent.Name, e.OldState, e.NewState);
					};
				manager.PeerConnected +=
					delegate(object sender, PeerConnectionEventArgs e)
					{
						Console.WriteLine("Peer {2} connect to: {0} as {1}", e.TorrentManager.Torrent.Name, e.ConnectionDirection,
						                  e.PeerID.Location);
					};
				engine.Register(manager);
			}
			engine.StartAll();
			WaitForDisposable.WaitOne();
		}

 public TorrentHandler(TorrentManager tm)
 {
     TorrentManager = tm;
     _delete = new List<string>();
     _files = new List<FileInfo>();
     _files.AddRange(Directory.GetFiles(tm.SavePath, "*.*", SearchOption.AllDirectories).Select(o => new FileInfo(o)));
 }

 protected Mode(TorrentManager manager)
 {
     CanAcceptConnections = true;
     this.manager = manager;
     manager.chokeUnchoker = new ChokeUnchokeManager(manager, manager.Settings.MinimumTimeBetweenReviews,
         manager.Settings.PercentOfMaxRateToSkipReview);
 }

 /// <summary>
 ///     Creates a new PeerMessageEventArgs
 /// </summary>
 /// <param name="message">The peer message involved</param>
 /// <param name="direction">The direction of the message</param>
 internal PeerMessageEventArgs(TorrentManager manager, PeerMessage message, Direction direction, PeerId id)
     : base(manager)
 {
     this.direction = direction;
     this.id = id;
     this.message = message;
 }

 public PausedMode(TorrentManager manager)
     : base(manager)
 {
     // When in the Paused mode, a special RateLimiter will
     // activate and disable transfers. PauseMode itself
     // does not need to do anything special.
 }

 public InitialSeedingMode(TorrentManager manager)
     : base(manager)
 {
     unchoker = new InitialSeedUnchoker(manager);
     manager.chokeUnchoker = unchoker;
     zero = new BitField(manager.Bitfield.Length);
 }

 internal PeerConnectionEventArgs(TorrentManager manager, PeerId id, Direction direction, string message)
     : base(manager)
 {
     PeerID = id;
     ConnectionDirection = direction;
     Message = message;
 }