move messagectx to its own file

4 files changed, 213 insertions, 6 deletions

diff --git a/commands.go b/commands.go
new file mode 100644
index 0000000..d3f5684
--- /dev/null
+++ b/commands.go
@@ -0,0 +1,7 @@
+package thulani
+
+import "github.com/bwmarrin/discordgo"
+
+func printHelp(s *discordgo.Session, create *discordgo.MessageCreate) {
+
+}
diff --git a/messagectx.go b/messagectx.go
new file mode 100644
index 0000000..ee38f5f
--- /dev/null
+++ b/messagectx.go
@@ -0,0 +1,84 @@
+package thulani
+
+import (
+	"strings"
+	"sync"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+type messageCtx struct {
+	sync.Mutex
+
+	*discordgo.Session
+	*discordgo.MessageCreate
+
+	Command string
+	Matched bool
+
+	Channel *discordgo.Channel
+	Member  *discordgo.Member
+	Guild   *discordgo.Guild
+}
+
+func newCtx(s *discordgo.Session, m *discordgo.MessageCreate) (*messageCtx, error) {
+	matches := regex.FindStringSubmatch(m.Content)
+	command := ""
+
+	if len(matches) != 0 {
+		command = strings.Split(matches[1], " ")[0]
+	}
+
+	channel, err := s.State.Channel(m.ChannelID)
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		wg         sync.WaitGroup
+		guild      *discordgo.Guild
+		member     *discordgo.Member
+		gErr, mErr error
+	)
+
+	wg.Add(2)
+	go func() {
+		guild, gErr = s.State.Guild(channel.GuildID)
+		defer wg.Done()
+	}()
+
+	go func() {
+		member, mErr = s.GuildMember(channel.GuildID, m.Author.ID)
+		defer wg.Done()
+	}()
+	wg.Wait()
+
+	if gErr != nil {
+		return nil, gErr
+	}
+
+	if mErr != nil {
+		return nil, mErr
+	}
+
+	return &messageCtx{
+		Session:       s,
+		MessageCreate: m,
+
+		Command: command,
+		Matched: len(matches) == 0,
+
+		Channel: channel,
+		Guild:   guild,
+		Member:  member,
+	}, nil
+}
+
+func (ctx *messageCtx) sendMessage(str string, tts bool) {
+	if !ctx.Tts {
+		ctx.ChannelMessageSend(ctx.ChannelID, str)
+		return
+	}
+
+	ctx.ChannelMessageSendTTS(ctx.ChannelID, str)
+}
diff --git a/thulani.go b/thulani.go
index d64cb7c..0b0f144 100644
--- a/thulani.go
+++ b/thulani.go
@@ -1,20 +1,48 @@
 package thulani
 
 import (
+	"fmt"
+	"net/url"
 	"os"
 	"os/signal"
+	"regexp"
+	"strings"
 	"syscall"
 
 	"github.com/bwmarrin/discordgo"
 )
 
+var config *Config
+var regex *regexp.Regexp
+
 func Run(conf *Config) {
+	config = conf
+	regex = regexp.MustCompile("(?i)^[!/]" + conf.Trigger + " (.*)")
+
 	dg, err := discordgo.New("Bot " + conf.Token)
 	handle(err)
 
 	dg.AddHandler(onReady)
+	dg.AddHandler(onMessage)
 	dg.Open()
 
+	joined := false
+
+	for !joined {
+		for _, v := range dg.State.Guilds {
+			if v.Name == conf.Server {
+				joined = true
+				break
+			}
+		}
+
+		if !joined {
+			fmt.Println("Please input the token for whatever the fuck.")
+			var response string
+			fmt.Scanln(&response)
+		}
+	}
+
 	sc := make(chan os.Signal, 1)
 	signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
 	<-sc
@@ -23,5 +51,79 @@ func Run(conf *Config) {
 }
 
 func onReady(s *discordgo.Session, m *discordgo.Ready) {
-	log.Debugf("Logged in as %v (%v)", m.User.Username, m.User.ID)
+	log.Infof("Logged in as %v (%v)", m.User.Username, m.User.ID)
+}
+
+func onMessage(s *discordgo.Session, m *discordgo.MessageCreate) {
+	if m.Author.ID == s.State.User.ID {
+		return
+	}
+
+	log.Debugf("got message %q", m.Content)
+
+	ctx, err := newCtx(s, m)
+	if err != nil {
+		log.Errorf("error constructing message context: %q", err)
+	}
+
+	if ctx.Channel.IsPrivate {
+		log.Infof("Ignoring private message")
+		return
+	}
+
+	if ctx.Channel.GuildID != config.Server {
+		log.Infof("Wrong guild. Ignoring.")
+		return
+	}
+
+	_ = func() bool {
+		for _, v := range ctx.Member.Roles {
+			if v == config.OpRole {
+				return true
+			}
+		}
+		log.Infof("User %v not authorized.", m.Author.Username)
+
+		ctx.sendMessage("fuck you. you're not allowed to do that.", m.Tts)
+		return false
+	}
+
+	//fmap := map[string]func(){
+	//	"sup": func() {},
+	//}[ctx.Command]
+
+	switch ctx.Command {
+	case "skip":
+		break
+
+	case "die":
+		break
+
+	default:
+		target, err := url.Parse(ctx.Command)
+		if err != nil {
+			log.Errorf("Url parse failed: %q", err)
+			ctx.sendMessage("format your commands right. fuck you.", m.Tts)
+			return
+		}
+
+		if target.Path == "" || (target.Path == "/watch" && len(target.Query()) == 0) {
+			log.Warningf("Bad url format: %q", ctx.Command)
+			ctx.sendMessage("that\nis\na\nbad\nurl", m.Tts)
+			return
+		}
+
+		if strings.Contains(target.Hostname(), "imgur") {
+			log.Infof("Ignoring imgur link.")
+
+			if m.Author.Username == "boomshticky" {
+				ctx.sendMessage("fuck you conway", true)
+			} else {
+				ctx.sendMessage("NO IMGUR", m.Tts)
+			}
+			break
+		}
+
+		// TODO: play audio
+	}
 }
diff --git a/util.go b/util.go
index ae4ca2c..105b5bb 100644
--- a/util.go
+++ b/util.go
@@ -7,11 +7,19 @@ import (
 	"github.com/op/go-logging"
 )
 
-func handle(err error) {
-	if err != nil {
-		log.Fatal(err)
-	}
-}
+const help = `wew lad. you should know these commands already.
+
+Usage: ` + "`!thulani [command]`" + `
+
+commands:
+**help**:\t\t\t\tprint this help message
+**[url]**:\t\t\t   a url with media that thulani can play. queued up to play after everything that's already waiting.
+**list, queue**:\tlist items in the queue, as well as the currently-playing item.
+**pause**:\t\t\tpause sound.
+**resume**:\t\t resume sound.
+**die**:\t\t\t\t empty the queue and stop playing.
+**skip**:\t\t\t   skip the current item.
+`
 
 var log = logging.MustGetLogger("thulani")
 
@@ -25,6 +33,12 @@ type Config struct {
 	Token        string `json:"token"`
 }
 
+func handle(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
 func LoadConfig(filename string) (*Config, error) {
 	file, err := os.Open("config.json")
 	if err != nil {