FlameInTheDark / dtbot

import (

	"bytes"

	"fmt"

	"github.com/DiscordBotList/dblgo"

	"net/http"

	"net/url"

	"os"

	"os/signal"

	"strings"

	"syscall"

	"time"

	"gopkg.in/robfig/cron.v2"

	"github.com/FlameInTheDark/dtbot/bot"

	"github.com/FlameInTheDark/dtbot/cmd"

	"github.com/bwmarrin/discordgo"

)

var (

	conf *bot.Config

	// CmdHandler bot command handler

	CmdHandler *bot.CommandHandler

	// Sessions bot session manager

	Sessions        *bot.SessionManager

	youtube         *bot.Youtube

	botMsg          *bot.BotMessages

	dataType        *bot.DataType

	dbWorker        *bot.DBWorker

	guilds          bot.GuildsMap

	botCron         *cron.Cron

	messagesCounter int

)

// Handle discord messages

func commandHandler(discord *discordgo.Session, message *discordgo.MessageCreate) {

	messagesCounter++

	user := message.Author

	if user.ID == botId || user.Bot {

		return

	}

	args := strings.Split(message.Content, " ")

	name := strings.ToLower(args[0])

	command, found := CmdHandler.Get(name)

	if !found {

		return

	}

	var permission = true

	var msg string

	// Checking permissions

	perm, err := discord.State.UserChannelPermissions(botId, message.ChannelID)

	if err != nil {

		msg = fmt.Sprintf("Error whilst getting bot permissions %v\n", err)

		permission = false

	} else {

		if perm&discordgo.PermissionSendMessages != discordgo.PermissionSendMessages ||

			perm&discordgo.PermissionAttachFiles != discordgo.PermissionAttachFiles {

			msg = "Permissions denied"

			permission = false

		}

	}

	channel, err := discord.State.Channel(message.ChannelID)

	if err != nil {

		fmt.Println("Error getting channel,", err)

		return

	}

	guild, err := discord.State.Guild(channel.GuildID)

	if err != nil {

		fmt.Println("Error getting guild,", err)

		return

	}

	if permission {

		ctx := bot.NewContext(

			botId,

			discord,

			guild,

			channel,

			user,

			message,

			conf,

			CmdHandler,

			Sessions,

			youtube,

			botMsg,

			dataType,

			dbWorker,

			guilds,

			botCron)

		ctx.Args = args[1:]

		c := *command

		c(*ctx)

	} else {

		dbWorker.Log("Message", guild.ID, msg)

		query := []byte(fmt.Sprintf("logs,server=%v module=\"%v\"", guild.ID, "message"))

		addr := fmt.Sprintf("%v/write?db=%v", conf.Metrics.Address, conf.Metrics.Database)

		r := bytes.NewReader(query)

		_, _ = http.Post(addr, "", r)

	}

}

// Adds bot commands

func registerCommands() {

	CmdHandler.Register("!r", cmd.PlayerCommand)

	CmdHandler.Register("!w", cmd.WeatherCommand)

	CmdHandler.Register("!t", cmd.TranslateCommand)

	CmdHandler.Register("!n", cmd.NewsCommand)

	CmdHandler.Register("!c", cmd.CurrencyCommand)

	CmdHandler.Register("!y", cmd.YoutubeCommand)

	CmdHandler.Register("!v", cmd.VoiceCommand)

	CmdHandler.Register("!b", cmd.BotCommand)

	CmdHandler.Register("!play", cmd.YoutubeShortCommand)

	CmdHandler.Register("!d", cmd.DebugCommand)

	CmdHandler.Register("!p", cmd.PollCommand)

	CmdHandler.Register("!m", cmd.YandexmapCommand)

	CmdHandler.Register("!dice", cmd.DiceCommand)

	CmdHandler.Register("!help", cmd.HelpCommand)

	CmdHandler.Register("!cron", cmd.CronCommand)

	CmdHandler.Register("!geoip", cmd.GeoIPCommand)

}

// MetricsSender sends metrics to InfluxDB

func MetricsSender(d *discordgo.Session) {

	for {

		query := []byte(fmt.Sprintf("messages count=%v", messagesCounter))

		addr := fmt.Sprintf("%v/write?db=%v&u=%v&p=%v",

			conf.Metrics.Address, conf.Metrics.Database, conf.Metrics.User, conf.Metrics.Password)

		r := bytes.NewReader(query)

		_, _ = http.Post(addr, "", r)

		if conf.DBL.Token != "" {

			s := dblgo.NewDBL(conf.DBL.Token, d.State.User.ID)

			_ = s.PostStats(len(d.State.Guilds))

		}

		if conf.DBL.TokenDBL != "" {

			users := 0

			for _, g := range d.State.Guilds {

				users += len(g.Members)

			}

			data := url.Values{}

			data.Set("guilds", string(len(d.State.Guilds)))

			data.Set("users", string(users))

			client := &http.Client{}

			req, err := http.NewRequest("POST", fmt.Sprintf("https://discordbotlist.com/api/bots/%v/stats",conf.DBL.DBLID), bytes.NewBuffer([]byte(data.Encode())))

			if err != nil {

				fmt.Println(err.Error())

			}

			req.Header.Add("Authorization", fmt.Sprintf("Bot %v", conf.DBL.TokenDBL))

			defer req.Body.Close()

			_,_ = client.Do(req)

		}

		messagesCounter = 0

		time.Sleep(time.Minute)

	}

}