// Triggered when an gnet.Connection terminates. Disconnect events are not
// pushed to a separate channel, because disconnects are already processed
// by a queue in the daemon.Run() select{}.
func (self *Daemon) onGnetDisconnect(c *gnet.Connection,
	reason gnet.DisconnectReason) {

	a := c.Addr()
	logger.Info("%s disconnected because: %v", a, reason)
	duration, exists := BlacklistOffenses[reason]
	if exists {
		self.Peers.Peers.AddBlacklistEntry(a, duration)
	}
	delete(self.OutgoingConnections, a)
	delete(self.ExpectingIntroductions, a)
}

func (self *PoolOwner) OnDisconnect(c *gnet.Connection, reason gnet.DisconnectReason) {

	if false {
		for channel, pDispatcher := range self.pDispatcherManager.Dispatchers {
			// (BTW, pDispatcher.ReceivingObject is '&PoolOwner')

			// Each channel (or subscription subject) might require
			// specific action to be taken on disconnect, such as
			// reconnect, clean up etc.
			_ = channel
			_ = pDispatcher
		}
	}

	delete(self.isConnSolicited, c.Addr())
}

func (self *PoolOwner) OnConnect(c *gnet.Connection, is_solicited bool) {
	self.isConnSolicited[c.Addr()] = is_solicited

	if false {
		for channel, pDispatcher := range self.pDispatcherManager.Dispatchers {
			// (BTW, pDispatcher.ReceivingObject is '&PoolOwner')

			// Each channel (or subscription subject) might require
			// specific action to be taken on connect, such as request
			// initial values from solicited, authenticate the client
			// from unsolicited one etc.
			_ = channel
			_ = pDispatcher
		}
	}
}

// Called when a ConnectEvent is processed off the onConnectEvent channel
func (self *Daemon) onConnect(c *gnet.Connection, solicited bool) {
	a := c.Addr()

	if solicited {
		logger.Info("Connected to %s as we requested", a)
	} else {
		logger.Info("Received unsolicited connection to %s", a)
	}

	serviceConList := self.pendingConnections[a] //list of services to connect to
	delete(self.pendingConnections, a)

	blacklisted := self.Peers.Peers.IsBlacklisted(a)
	if blacklisted {
		logger.Info("%s is blacklisted, disconnecting", a)
		self.Pool.Disconnect(c, DisconnectIsBlacklisted)
		return
	}

	if self.Pool.Addresses[a] != nil {
		logger.Info("Already connected to %s, disconnecting", a)
		self.Pool.Disconnect(c, DisconnectConnectedTwice)
	}

	if solicited {
		self.OutgoingConnections[a] = c
	}
	self.ExpectingIntroductions[a] = util.Now()
	logger.Debug("Sending introduction message to %s", a)

	m := NewIntroductionMessage(MirrorConstant, self.Config.Version,
		self.Pool.Config.Port)
	self.Service.Send(c, m)

	//send connection message to each service in list
	for _, service := range serviceConList {
		self.ConnectToService(c, service)
	}
}

func (self *AetherServer) OnDisconnect(c *gnet.Connection) {
	fmt.Printf("AetherServer: OnDisconnect, addr= %s \n", c.Addr())
}

func (sd *TestServiceServer) OnDisconnect(c *gnet.Connection) {
	fmt.Printf("TestServiceServer: OnDisconnect, addr= %s \n", c.Addr())
}

//this is called when a message is received
func onMessage(c *gnet.Connection, channel uint16,
	msg []byte) error {
	fmt.Printf("Event Callback: message event: addr= %s, channel %v, msg= %s \n", c.Addr(), channel, msg)
	return nil
}

func (sd *DaemonService) OnDisconnect(c *gnet.Connection) {
	fmt.Printf("SkywireDaemon: OnDisconnect, addr= %s \n", c.Addr())
}

func (sd *SkywireDaemon) OnConnect(c *gnet.Connection) {
	fmt.Printf("SkywireDaemon: OnConnect, addr= %s \n", c.Addr())
}