// Following function handles Incoming at Inbox from other peers.It reads those Event and forwards to StateMachine
func (rn *RaftNode) check_Inbox(node cluster.Server) {
	for {
		env := <-node.Inbox()
		switch env.Msg.(type) {
		// this packet is APPENDENTRIESRESP:
		case APPENDENTRIESRESP:
			temp := env.Msg.(APPENDENTRIESRESP)
			rn.sm.SMchanels.netCh <- temp

		//this packet is APPENDENTRIESREQ:
		case APPENDENTRIESREQ:
			temp := env.Msg.(APPENDENTRIESREQ)
			rn.sm.SMchanels.netCh <- temp

		// this packet is VOTERESP
		case VOTERESP:
			//	fmt.Println("VOTERESp");
			temp := env.Msg.(VOTERESP)
			rn.sm.SMchanels.netCh <- temp

		case VOTEREQ:
			temp := env.Msg.(VOTEREQ)
			rn.sm.SMchanels.netCh <- temp
		}
	}
} //End of check_Inbox function

//Process to listen incomming packets from other Servers.
func processInbox(server cluster.Server, sm *State_Machine) {
	for {
		env := <-server.Inbox()
		switch env.Msg.(type) {
		case VoteReq:
			sm.CommMedium.netCh <- env.Msg
		case VoteResp:
			sm.CommMedium.netCh <- env.Msg
		case AppEntrReq:
			sm.CommMedium.netCh <- env.Msg
		case AppEntrResp:
			sm.CommMedium.netCh <- env.Msg
		}
	}
}

//This goroutine receives Action coming from StateMAchine and take Actions Accordingly.
func (rn *RaftNode) check_SMAction(node cluster.Server) {
	for {

		actionEvent := <-rn.sm.SMchanels.Action
		switch actionEvent.(type) {
		case SEND:
			tempEvent := actionEvent.(SEND)
			id := tempEvent.ID_TOSEND
			mid := getMsgId(tempEvent.EVENT)
			msgid := int64(mid)
			if id == 300 {
				node.Outbox() <- &cluster.Envelope{Pid: cluster.BROADCAST, MsgId: msgid, Msg: tempEvent.EVENT}
			} else {
				node.Outbox() <- &cluster.Envelope{Pid: id, MsgId: msgid, Msg: tempEvent.EVENT}
			}
		case COMMIT:
			tempEvent := actionEvent.(COMMIT)
			data := tempEvent.DATA
			leader := rn.sm.LEADERID
			CI := COMMITINFO{Index: int64(leader), Err: 404, Data: data}
			rn.CommitChannel <- CI
		case ALARM:
			tempEvent := actionEvent.(ALARM)
			t := tempEvent.TIME
			if rn.timerFlag == 1 {
				rn.timer.Stop()
				rn.timer = time.AfterFunc(time.Duration(t)*time.Millisecond, func() {
					rn.sm.SMchanels.timeoutCh <- TIMEOUT{}
				})
			} else {
				rn.timer = time.AfterFunc(time.Duration(t)*time.Millisecond, func() {
					rn.sm.SMchanels.timeoutCh <- TIMEOUT{}
				})
			}
		case LOGSTORE:
			tempEvent := actionEvent.(LOGSTORE)
			index := tempEvent.INDEX
			data := tempEvent.DATA.COMMAND
			CI := COMMITINFO{Index: int64(index), Data: data, Err: 200}
			rn.CommitChannel <- CI
			rn.writeLog(tempEvent)
		}
	}
} //End of check_SMAction() function

//Signal to shut down all goroutines, stop sockets, flush log and close it, cancel timers.
func Shutdown(server cluster.Server) {
	server.Close()
}

//Process to send packets to other Servers.
func processOutbox(server cluster.Server, sm *State_Machine, msg Send) {
	//broadcaste messagess.
	if msg.PeerId == 0 {
		switch msg.Event.(type) {
		case AppEntrReq:
			AppReq := msg.Event.(AppEntrReq)
			server.Outbox() <- &cluster.Envelope{Pid: cluster.BROADCAST, MsgId: 11, Msg: AppReq}
		case VoteReq:
			VotReq := msg.Event.(VoteReq)
			server.Outbox() <- &cluster.Envelope{Pid: cluster.BROADCAST, MsgId: 1, Msg: VotReq}
		}
	} else {
		//send to particular node.
		switch msg.Event.(type) {
		case AppEntrReq:
			AppReq := msg.Event.(AppEntrReq)
			server.Outbox() <- &cluster.Envelope{Pid: int(msg.PeerId), MsgId: 11, Msg: AppReq}
		case AppEntrResp:
			AppResp := msg.Event.(AppEntrResp)
			AppResp.Peer = int32(server.Pid())
			server.Outbox() <- &cluster.Envelope{Pid: int(msg.PeerId), MsgId: 22, Msg: AppResp}
		case VoteResp:
			VotResp := msg.Event.(VoteResp)
			server.Outbox() <- &cluster.Envelope{Pid: int(msg.PeerId), MsgId: 2, Msg: VotResp}
		}
	}
}