package discord

import (
	"fmt"

	"github.com/bwmarrin/discordgo"
)

// EventKind tells apart the things that can happen to a watched message.
type EventKind int

const (
	MessageCreated EventKind = iota
	MessageDeleted
)

// Event is a change on the watched channel that the distributor has to mirror.
type Event struct {
	Kind        EventKind
	MessageID   string
	Content     string
	Attachments []*discordgo.MessageAttachment
	// ReplyToID is the ID of the message this one replies to, empty when the
	// message is not a reply.
	ReplyToID string
}

type Client struct {
	Token     string
	ChannelID string
	dgsession *discordgo.Session
}

func Discord(token string, channelId string) *Client {
	return &Client{
		Token:     token,
		ChannelID: channelId,
	}
}

func (d *Client) BeginRead(eventchannel chan<- Event) {
	d.read(eventchannel)
}

func (d *Client) read(eventchannel chan<- Event) {
	dgsession, err := discordgo.New("Bot " + d.Token)
	if err != nil {
		return
	}

	dgsession.AddHandler(func(s *discordgo.Session, m *discordgo.MessageCreate) {
		if m.ChannelID != d.ChannelID || m.Author.ID == s.State.User.ID {
			return
		}
		event := Event{
			Kind:        MessageCreated,
			MessageID:   m.ID,
			Content:     m.Content,
			Attachments: m.Attachments,
		}
		if m.MessageReference != nil {
			event.ReplyToID = m.MessageReference.MessageID
		}
		eventchannel <- event
	})

	// Deleted messages arrive without an author, so the channel is the only
	// thing to filter on; messages we never distributed are dropped later.
	dgsession.AddHandler(func(s *discordgo.Session, m *discordgo.MessageDelete) {
		if m.ChannelID != d.ChannelID {
			return
		}
		eventchannel <- Event{
			Kind:      MessageDeleted,
			MessageID: m.ID,
		}
	})

	d.dgsession = dgsession

	errOpen := dgsession.Open()
	if errOpen != nil {
		fmt.Println(errOpen)
	}
}
func Read() string {
	return "discord"
}

func (d *Client) Write(str string) {
	d.dgsession.ChannelMessageSend(d.ChannelID, str)
}