package main

import (
	"encoding/json"
	"fmt"
	"log"
	"math/rand"
	"strconv"
	"time"

	"github.com/streadway/amqp"
	tb "gopkg.in/tucnak/telebot.v2"
)

func MQGetMsgWorker(id int, msgs chan<- ChatWarsMessage) {
	//log.Printf("MQGetMsgWorker[" + strconv.Itoa(id) + "] : Starting.")
	var x ChatWarsMessage
	conn, err := amqp.Dial("amqp://" + cfg.Rabbit.User + ":" + cfg.Rabbit.Password + "@" + cfg.Rabbit.Host + "/" + cfg.Rabbit.Queue)
	failOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Failed to open a channel")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"msg", // name
		false, // durable
		false, // delete when unused
		false, // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Failed to declare a queue")

	m, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Failed to register a consumer")

	for d := range m {
		// log.Printf("MQGetMsgWorker["+strconv.Itoa(id)+"] : Received a message: %s", string(d.Body))
		err = json.Unmarshal(d.Body, &x)
		logOnError(err, "MQGetMsgWorker["+strconv.Itoa(id)+"] : Can't unmarshal.\n"+string(d.Body))
		if err == nil {
			msgs <- x
		}
	}

	log.Printf("MQGetMsgWorker[" + strconv.Itoa(id) + "] : Closing.")

}

func SQLCWMsgWorker(id int, msgs <-chan ChatWarsMessage, objIds chan<- int64) {
	//log.Printf("SQLCWMsgWorker[" + strconv.Itoa(id) + "] : Starting.")
	for m := range msgs {
		objId, err := addObjMsg(m.ID64, m.ChatID64, m.UserID64, m.SenderUserID64, m.Date, m.Text)
		logOnError(err, "SQLCWMsgWorker["+strconv.Itoa(id)+"] : Inserting message.")
		if err == nil && objId != 0 {
			// log.Printf("SQLCWMsgWorker["+strconv.Itoa(id)+"] : Message inserted (%d).\n", objId)
			objIds <- objId
		}
	}

	log.Printf("SQLCWMsgWorker[" + strconv.Itoa(id) + "] : Closing.")

}

func SQLIdentifyMsgWorker(id int, objIds <-chan int64) {
	var i int
	//log.Printf("SQLIdentifyMsgWorker[" + strconv.Itoa(id) + "] : Starting.")
	for objId := range objIds {
		m, err := getMsg(objId)
		logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Retrieving message.")
		if err == nil {
			//log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Message retrieved (%d)\n%s\n", objId, m.Text)
			for i = 0; i < len(msgParsingRules) && msgParsingRules[i].re.FindStringSubmatch(m.Text) == nil; i++ {

			}
			if i == len(msgParsingRules) {
				log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Can't find message type in rules(%d)\n%s\n", objId, m.Text)
			} else {
				r := msgParsingRules[i].re
				switch msgParsingRules[i].MsgTypeID {
				case objSubTypeMessageReportAck:
					cwm, err := parseSubTypeMessageReportAck(m, r)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageReportAck.")
					cwm.ObjID64 = objId
					err = setObjSubTypeId(objId, objSubTypeMessageReportAck)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(ReportAck)")
				case objSubTypeMessageMiniWar:
					cwm, err := parseSubTypeMessageMiniWar(m, r)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageMiniWar.")
					cwm.ObjID64 = objId
					err = insertMsgMiniWar(cwm)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgMiniWar")
					err = setObjSubTypeId(objId, objSubTypeMessageMiniWar)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(MiniWar)")
				case objSubTypeMessagePillageInc:
					cwm, err := parseSubTypeMessagePillageInc(m, r)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessagePillageInc.")
					cwm.ObjID64 = objId
					err = insertMsgPillageInc(cwm)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgPillageInc")
					err = setObjSubTypeId(objId, objSubTypeMessagePillageInc)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(PillageInc)")
					// only catch live pillages
					if m.Date.Add(3 * time.Minute).After(time.Now()) {
						s := TGCommand{
							Type:       commandSendMsg,
							Text:       fmt.Sprintf("Catching pillage (%s)", m.Date.Format(time.RFC3339)),
							ToUserID64: m.UserID64,
						}
						TGCmdQueue <- s
						p := JobPayloadPillage{
							ObjID64: objId,
						}
						b, _ := json.Marshal(&p)
						_, err = createJob(objSubTypeJobPillage, objJobPriority, m.UserID64, m.Date.Add(time.Duration(25+rand.Intn(35))*time.Second), b)
						logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : createJob(JobPillage)")
					}
				case objSubTypeMessageGo:
					err = setObjSubTypeId(objId, objSubTypeMessageGo)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(Go)")
				case objSubTypeMessageReportReq:
					err = setObjSubTypeId(objId, objSubTypeMessageReportReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(ReportReq)")
				case objSubTypeMessageGReportReq:
					err = setObjSubTypeId(objId, objSubTypeMessageGReportReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(GReportReq)")
				case objSubTypeMessageHeroReq:
					err = setObjSubTypeId(objId, objSubTypeMessageHeroReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(HeroReq)")
				case objSubTypeMessageMeReq:
					err = setObjSubTypeId(objId, objSubTypeMessageMeReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(MeReq)")
				case objSubTypeMessageInventoryReq:
					err = setObjSubTypeId(objId, objSubTypeMessageInventoryReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(InventoryReq)")
				case objSubTypeMessageTimeReq:
					err = setObjSubTypeId(objId, objSubTypeMessageTimeReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(TimeReq)")
				case objSubTypeMessagePledge:
					err = setObjSubTypeId(objId, objSubTypeMessagePledge)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(Pledge)")
				case objSubTypeMessagePillageGo:
					err = setObjSubTypeId(objId, objSubTypeMessagePillageGo)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(PillageGo)")
				case objSubTypeMessagePillageTimeout:
					err = setObjSubTypeId(objId, objSubTypeMessagePillageTimeout)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(PillageTimeout)")
				case objSubTypeMessagePillageWin:
					err = setObjSubTypeId(objId, objSubTypeMessagePillageWin)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(PillageWin)")
				case objSubTypeMessagePillageLoss:
					err = setObjSubTypeId(objId, objSubTypeMessagePillageLoss)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(PillageLoss)")
				case objSubTypeMessageDuelFight:
					cwm, err := parseSubTypeMessageDuelFight(m, r)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageDuelFight.")
					cwm.ObjID64 = objId
					err = insertMsgDuelFight(cwm)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgAuctionAnnounce")
					err = setObjSubTypeId(objId, objSubTypeMessageDuelFight)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(DuelFight)")
				case objSubTypeMessageGoQuest:
					err = setObjSubTypeId(objId, objSubTypeMessageGoQuest)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(GoQuest)")
				case objSubTypeMessageGoFastFight:
					err = setObjSubTypeId(objId, objSubTypeMessageGoFastFight)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(GoFastFight)")
				case objSubTypeMessageGoArena:
					err = setObjSubTypeId(objId, objSubTypeMessageGoArena)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(GoArena)")
				case objSubTypeMessageTop:
					err = setObjSubTypeId(objId, objSubTypeMessageTop)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(Top)")
				case objSubTypeMessageMenu:
					err = setObjSubTypeId(objId, objSubTypeMessageMenu)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(Menu)")
				case objSubTypeMessageBuyReq:
					err = setObjSubTypeId(objId, objSubTypeMessageBuyReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(BuyReq)")
				case objSubTypeMessageSellReq:
					err = setObjSubTypeId(objId, objSubTypeMessageSellReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(SellReq)")
				case objSubTypeMessageOrderbookReq:
					err = setObjSubTypeId(objId, objSubTypeMessageOrderbookReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(OrderbookReq)")
				case objSubTypeMessageOrderbookAck:
					err = setObjSubTypeId(objId, objSubTypeMessageSellReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(SellReq)")
				case objSubTypeMessageWithdrawReq:
					err = setObjSubTypeId(objId, objSubTypeMessageWithdrawReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(WithdrawReq)")
				case objSubTypeMessageWithdrawCode:
					err = setObjSubTypeId(objId, objSubTypeMessageWithdrawCode)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(WithdrawCode)")
				case objSubTypeMessageWithdrawRcv:
					err = setObjSubTypeId(objId, objSubTypeMessageWithdrawRcv)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(WithdrawRcv)")
				case objSubTypeMessageDepositReq:
					err = setObjSubTypeId(objId, objSubTypeMessageDepositReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(DepositReq)")
				case objSubTypeMessageDepositAck:
					err = setObjSubTypeId(objId, objSubTypeMessageDepositAck)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(DepositAck)")
				case objSubTypeMessageStockReq:
					err = setObjSubTypeId(objId, objSubTypeMessageStockReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(StockReq)")
				case objSubTypeMessageMiscReq:
					err = setObjSubTypeId(objId, objSubTypeMessageMiscReq)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(MiscReq)")
				case objSubTypeMessageUnionWar:
					_, err := parseSubTypeMessageUnionWar(m, r)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageUnionWar.")
					err = setObjSubTypeId(objId, objSubTypeMessageUnionWar)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(UnionWar)")
				case objSubTypeMessageAuctionAnnounce:
					cwm := ChatWarsMessageAuctionAnnounce{
						ObjID64: objId,
					}
					l, _ := strconv.ParseInt(r.ReplaceAllString(m.Text, "${Lot}"), 10, 32)
					cwm.LotID = int32(l)
					cwm.Item = r.ReplaceAllString(m.Text, "${Item}")
					cwm.Cond = r.ReplaceAllString(m.Text, "${Cond}")
					cwm.Quality = r.ReplaceAllString(m.Text, "${Quality}")
					cwm.Seller = r.ReplaceAllString(m.Text, "${Seller}")
					cwm.Buyer = r.ReplaceAllString(m.Text, "${Buyer}")
					p, _ := strconv.ParseInt(r.ReplaceAllString(m.Text, "${Price}"), 10, 32)
					cwm.Price = int32(p)
					cwm.Status = r.ReplaceAllString(m.Text, "${Status}")
					cwm.End, _ = fromChatWarsDate(r.ReplaceAllString(m.Text, "${End}"))
					err = insertMsgAuctionAnnounce(&cwm)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgAuctionAnnounce")
					err = setObjSubTypeId(objId, objSubTypeMessageAuctionAnnounce)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(AuctionAnnounce)")
				case objSubTypeMessageTimeAck:
					_, err := fromChatWarsDate(r.ReplaceAllString(m.Text, "${Day}") + " " + r.ReplaceAllString(m.Text, "${Month}") + " " + r.ReplaceAllString(m.Text, "${Year}") + " " + r.ReplaceAllString(m.Text, "${Hour}") + ":" + r.ReplaceAllString(m.Text, "${Minute}"))
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : fromChatWarsDate")
					err = setObjSubTypeId(objId, objSubTypeMessageTimeAck)
					logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId(objSubTypeMessageTimeAck)")
				default:
					log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Unknwon message type in rule %d : %d (%d)\n%s\n", msgParsingRules[i].ID, msgParsingRules[i].MsgTypeID, objId, m.Text)
				}
			}
		}
	}
	log.Printf("SQLIdentifyMsgWorker[" + strconv.Itoa(id) + "] : Closing.")
}

func SQLJobWorker(id int) {
	//log.Printf("SQLJobWorker[" + strconv.Itoa(id) + "] : Starting.")
	for true {
		jobs, err := loadCurrentJobs(id)
		logOnError(err, "SQLJobWorker["+strconv.Itoa(id)+"] : loadCurrentJobs")
		if len(jobs) > 0 {
			log.Printf("SQLJobWorker["+strconv.Itoa(id)+"] : %d jobs.\n", len(jobs))
		}
		for _, j := range jobs {
			switch j.JobTypeID {
			case objSubTypeJobRescanMsg:
				jobRescan(j)
			case objSubTypeJobSetJobDone:
				jobSetDone(j)
			case objSubTypeJobPillage:
				jobPillage(j)
			case objSubTypeJobMsgClient:
				jobMsgClient(j)
			default:
				log.Printf("SQLJobWorker["+strconv.Itoa(id)+"] : No handler for job type #%d.\n", j.JobTypeID)
			}
		}
		if len(jobs) < SQLJobSliceSize {
			time.Sleep(100 * time.Millisecond)
		}
	}
	log.Printf("SQLJobWorker[" + strconv.Itoa(id) + "] : Closing.")
}

func TGCmdWorker(id int, b *tb.Bot, cmds <-chan TGCommand) {
	//log.Printf("TGCmdWorker[" + strconv.Itoa(id) + "] : Starting.")
	for c := range cmds {
		j, err := json.Marshal(c)
		logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : Marshal(c)")
		log.Printf("TGCmdWorker["+strconv.Itoa(id)+"] : new command.\n%s\n", string(j))
		switch c.Type {
		case commandReplyMsg:
			ch := tb.Chat{
				ID: c.FromChatID64,
			}
			m := tb.Message{
				ID:   int(c.FromMsgID64),
				Chat: &ch,
			}
			_, err := b.Reply(&m, c.Text)
			logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : Reply")
		case commandSendMsg:
			if c.ToChatID64 != 0 {
				ch := tb.Chat{
					ID: c.ToChatID64,
				}
				_, err := b.Send(&ch, c.Text)
				logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : Send")
			} else if c.ToUserID64 != 0 {
				ch := tb.Chat{
					ID: c.ToUserID64,
				}
				_, err := b.Send(&ch, c.Text)
				logOnError(err, "TGCmdWorker["+strconv.Itoa(id)+"] : Send")
			}
		default:

		}

	}
	log.Printf("TGCmdWorker[" + strconv.Itoa(id) + "] : Closing.")
}

func MQTGCmdWorker(id int, cmds <-chan TGCommand) {
	//log.Printf("MQTGCmdWorker[" + strconv.Itoa(id) + "] : Starting.")
	for c := range cmds {
		if _, ok := clientsKeepAlive[c.FromUserID64]; ok {
			j, err := json.Marshal(c)
			logOnError(err, "MQTGCmdWorker["+strconv.Itoa(id)+"] : Marshal(c)")
			log.Printf("MQTGCmdWorker["+strconv.Itoa(id)+"] : new command.\n%s\n", string(j))
			err = clientsQueue[c.FromUserID64].Channel.Publish(
				"",                                      // exchange
				clientsQueue[c.FromUserID64].Queue.Name, // routing key
				false,                                   // mandatory
				false,                                   // immediate
				amqp.Publishing{
					ContentType: "application/json",
					Body:        []byte(j),
				})
			logOnError(err, "MQTGCmdWorker["+strconv.Itoa(id)+"] : Publishing message.")
		}
	}

	log.Printf("MQTGCmdWorker[" + strconv.Itoa(id) + "] : Closing.")

}

func MQKeepAliveWorker() {
	//log.Printf("MQKeepAliveWorker : Starting.")
	conn, err := amqp.Dial("amqp://" + cfg.Rabbit.User + ":" + cfg.Rabbit.Password + "@" + cfg.Rabbit.Host + "/" + cfg.Rabbit.Queue)
	failOnError(err, "MQKeepAliveWorker : Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "MQKeepAliveWorker : Failed to open a channel")
	defer ch.Close()

	q, err := ch.QueueDeclare(
		"keepalive", // name
		false,       // durable
		false,       // delete when unused
		false,       // exclusive
		false,       // no-wait
		nil,         // arguments
	)
	failOnError(err, "MQKeepAliveWorker : Failed to declare a queue")

	m, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "MQKeepAliveWorker : Failed to register a consumer")

	for d := range m {
		// log.Printf("MQKeepAliveWorker : Received a message: %s", string(d.Body))
		x := MQKeepAlive{}
		err = json.Unmarshal(d.Body, &x)
		logOnError(err, "MQKeepAliveWorker : Can't unmarshal.\n"+string(d.Body))
		if err == nil {
			if x.Date.Add(time.Minute).Before(time.Now()) {
				// outdated keep-alive
			} else if _, ok := clientsKeepAlive[x.UserID64]; ok {
				clientsKeepAlive[x.UserID64].Date = x.Date
			} else {
				clt := MQClient{}
				clt.Connection, err = amqp.Dial("amqp://" + cfg.Rabbit.User + ":" + cfg.Rabbit.Password + "@" + cfg.Rabbit.Host + "/" + x.Queue)
				logOnError(err, "MQKeepAliveWorker : Failed to connect to RabbitMQ")
				clt.Channel, err = clt.Connection.Channel()
				logOnError(err, "MQKeepAliveWorker : Failed to open a channel")
				clt.Queue, err = clt.Channel.QueueDeclare(
					"msg", // name
					false, // durable
					false, // delete when unused
					false, // exclusive
					false, // no-wait
					nil,   // arguments
				)
				logOnError(err, "MQKeepAliveWorker : Failed to declare a queue")
				clientsKeepAlive[x.UserID64] = &x
				clientsQueue[x.UserID64] = &clt

				c := TGCommand{
					Type:       commandSendMsg,
					ToUserID64: x.UserID64,
					Text:       "You are connected.",
				}
				TGCmdQueue <- c
				c = TGCommand{
					Type:       commandSendMsg,
					ToUserID64: cfg.Bot.Admin,
					Text:       fmt.Sprintf("%s is connected.", x.Nickname),
				}
				TGCmdQueue <- c

				c = TGCommand{
					Type:         commandSendMsg,
					FromUserID64: x.UserID64,
					ToChatID64:   userID64ChtWrsBot,
					Text:         `🏅Me`,
				}
				MQTGCmdQueue <- c
				c = TGCommand{
					Type:         commandSendMsg,
					FromUserID64: x.UserID64,
					ToChatID64:   userID64ChtWrsBot,
					Text:         `/hero`,
				}
				MQTGCmdQueue <- c

			}
		}
	}

	log.Printf("MQKeepAliveWorker : Closing.")

}

func MQTidyKeepAliveWorker() {
	//log.Printf("MQTidyKeepAliveWorker : Starting.")
	for true {
		t := time.Now()
		for _, v := range clientsKeepAlive {
			if v.Date.Add(90 * time.Second).Before(time.Now()) {
				msgs, err := clientsQueue[v.UserID64].Channel.QueuePurge(clientsQueue[v.UserID64].Queue.Name, false)
				logOnError(err, "MQTidyKeepAliveWorker : Channel.QueuePurge()")
				err = clientsQueue[v.UserID64].Channel.Close()
				logOnError(err, "MQTidyKeepAliveWorker : Channel.Close()")
				err = clientsQueue[v.UserID64].Connection.Close()
				logOnError(err, "MQTidyKeepAliveWorker : Connection.Close()")
				c := TGCommand{
					Type:       commandSendMsg,
					ToUserID64: v.UserID64,
					Text:       "Timeout, purging and closing command queue.",
				}
				TGCmdQueue <- c
				c = TGCommand{
					Type:       commandSendMsg,
					ToUserID64: cfg.Bot.Admin,
					Text:       fmt.Sprintf("Client %s timed out (%d messages purged).", v.Nickname, msgs),
				}
				TGCmdQueue <- c

				delete(clientsKeepAlive, v.UserID64)

			}
		}
		time.Sleep(time.Until(t.Add(time.Second)))
	}
	log.Printf("MQTidyKeepAliveWorker : Closing.")
}