pkg

type Account interface {
	// full id of user (i.e. 11148817)
	ID() string

	// full lowercase name (i.e. pajlada)
	Name() string
}

type Actions interface {
	Timeout(user User, duration time.Duration) MuteAction

	Ban(user User) MuteAction

	Unban(user User) UnmuteAction

	Say(content string) MessageAction

	Delete(message string) DeleteAction

	Mention(user User, content string) MessageAction

	Whisper(user User, content string) WhisperAction

	Mutes() []MuteAction
	Unmutes() []UnmuteAction
	Deletes() []DeleteAction
	Messages() []MessageAction
	Whispers() []WhisperAction

	StopPropagation() bool
}

type Application interface {
	UserStore() UserStore
	ChannelStore() ChannelStore
	UserContext() UserContext
	StreamStore() StreamStore
	SQL() *sql.DB
	PubSub() PubSub
	TwitchBots() BotStore
	QuitChannel() chan string
	TwitchAuths() TwitchAuths
	MIMO() MIMO
}

type Banphrase interface {
	Triggers(text string) bool
	IsCaseSensitive() bool

	// IsAdvanced decides whether or not the banphrase should be run on all variations or only the first one
	IsAdvanced() bool

	GetName() string
	GetID() int
	GetDuration() time.Duration
}

type BaseEvent struct {
	UserStore UserStore
}

type BaseModule interface {
	LoadSettings([]byte) error
	Parameters() map[string]ModuleParameter
	ID() string
	Type() ModuleType
	Priority() int
}

type BotChannel interface {
	// Implement Channel interface
	GetName() string
	GetID() string

	MessageSender

	DatabaseID() int64
	Channel() Channel
	ChannelID() string
	ChannelName() string

	EnableModule(string) error
	DisableModule(string) error
	GetModule(string) (Module, error)

	// Implement ChannelWithStream interface
	Stream() Stream

	Events() *eventemitter.EventEmitter

	HandleMessage(user User, message Message) error
	HandleEventSubNotification(notification TwitchEventSubNotification) error
	OnModules(cb func(module Module) Actions, stop bool) []Actions

	SetSubscribers(state bool) error
	SetUniqueChat(state bool) error
	SetEmoteOnly(state bool) error
	SetSlowMode(state bool, durationS int) error
	SetFollowerMode(state bool, durationM int) error
	SetNonModChatDelay(state bool, durationS int) error

	Bot() Sender
}

type BotStore interface {
	Add(Sender)

	GetBotFromName(string) Sender
	GetBotFromID(string) Sender
	GetBotFromChannel(string) Sender

	Iterate() BotStoreIterator
}

type BotStoreIterator interface {
	Next() bool
	Value() Sender
}

type Channel interface {
	GetName() string
	GetID() string
}

type ChannelStore interface {
	TwitchChannel(channelID string) Channel
	RegisterTwitchChannel(channel Channel)
}

type ChannelWithStream interface {
	Channel

	Stream() Stream
}

type CommandInfo struct {
	Name        string
	Description string

	Maker func() CustomCommand2 `json:"-"`
}

type CommandMatcher interface {
	Register(aliases []string, command interface{}) interface{}
	Deregister(command interface{})
	DeregisterAliases(aliases []string)
	Match(text string) (interface{}, []string)
}

type CommandsManager interface {
	CommandMatcher
	OnMessage(event MessageEvent) Actions

	FindByCommandID(id int64) interface{}

	Register2(id int64, aliases []string, command interface{})
}

type CustomCommand2 interface {
	SimpleCommand

	HasCooldown(User) bool
	AddCooldown(User)
}

type DeleteAction interface {
	Message() string
}

type Emote interface {
	// i.e. "8vn23893nvcakuj23" for a bttv emote, or "85489481" for a twitch emote
	GetID() string

	// i.e. "NaM" or "forsenE"
	GetName() string

	// "twitch" or "bttv"
	GetType() string

	GetCount() int
}

type EmoteReader interface {
	Next() bool
	Get() Emote
}

type EventSubNotificationEvent struct {
	BaseEvent

	Notification TwitchEventSubNotification
}

type MIMO interface {
	Subscriber(channelNames ...string) chan interface{}
	Publisher(channelName string) chan interface{}
}

type Message interface {
	GetText() string
	SetText(string)

	GetTwitchReader() EmoteReader

	GetBTTVReader() EmoteReader
	AddBTTVEmote(Emote)
}

type MessageAction interface {
	// TODO: Add reply message action
	SetAction(v bool)
	Evaluate() string
}

type MessageEvent struct {
	BaseEvent

	User    User
	Message Message
	Channel ChannelWithStream
}

type MessageSender interface {
	Say(string)
	Mention(User, string)

	// Moderation
	Timeout(User, int, string)
	Ban(User, string)
}

type Module interface {
	BaseModule

	// Called when the module is disabled. The module can do any cleanup it needs to do here
	Disable() error

	// Returns the bot channel that the module has saved
	BotChannel() BotChannel

	OnWhisper(event MessageEvent) Actions
	OnMessage(event MessageEvent) Actions
	OnEventSubNotification(event EventSubNotificationEvent) Actions
}

type ModuleFactory func() ModuleSpec

type ModuleParameter interface {
	Description() string
	DefaultValue() interface{}
	Parse(string) error
	SetInterface(interface{})
	Get() interface{}
	Link(interface{})
	HasValue() bool
	HasBeenSet() bool
}

type ModuleParameterSpec func() ModuleParameter

type ModuleSpec interface {
	ID() string
	Name() string
	Type() ModuleType
	EnabledByDefault() bool
	Parameters() map[string]ModuleParameterSpec

	Create(bot BotChannel) Module

	Priority() int
}

type ModuleType uint

type MuteAction interface {
	User() User
	SetReason(reason string)
	Reason() string

	Type() MuteType

	Duration() time.Duration
}

type MuteType uint

type Permission uint64

type PubSub interface {
	Subscribe(source PubSubSource, topic string, parameters json.RawMessage)
	Publish(source PubSubSource, topic string, data interface{})

	HandleSubscribe(connection PubSubSubscriptionHandler, topic string)
	HandleJSON(source PubSubSource, bytes []byte) error
}

type PubSubBan struct {
	Channel string
	Target  string
	Reason  string
}

type PubSubBanEvent struct {
	Channel PubSubUser
	Target  PubSubUser
	Source  PubSubUser
	Reason  string
}

type PubSubConnection interface {
	MessageReceived(source PubSubSource, topic string, bytes []byte) error
}

type PubSubSource interface {
	IsApplication() bool
	Connection() PubSubConnection
	AuthenticatedUser() User
}

type PubSubSubscriptionHandler interface {
	ConnectionSubscribed(source PubSubSource, topic string, parameters json.RawMessage) (bool, error)
}

type PubSubTimeout struct {
	Channel  string
	Target   string
	Reason   string
	Duration uint32
}

type PubSubTimeoutEvent struct {
	Channel  PubSubUser
	Target   PubSubUser
	Source   PubSubUser
	Duration int
	Reason   string
}

type PubSubUntimeout struct {
	Channel string
	Target  string
}

type PubSubUser struct {
	ID   string
	Name string
}

type Sender interface {
	TwitchAccount() TwitchAccount
	GetTokenSource() oauth2.TokenSource

	Connected() bool

	Say(Channel, string)
	Mention(Channel, User, string)
	Whisper(User, string)
	Whisperf(User, string, ...interface{})

	// Timeout times the user out a single time immediately
	Timeout(Channel, User, int, string)

	Ban(Channel, User, string)

	GetPoints(Channel, string) uint64

	// give or remove points from user in channel
	BulkEdit(string, []string, int32)

	AddPoints(Channel, string, uint64) (bool, uint64)
	RemovePoints(Channel, string, uint64) (bool, uint64)
	ForceRemovePoints(Channel, string, uint64) uint64

	PointRank(Channel, string) uint64

	// ChannelIDs returns a slice of the channels this bot is connected to
	ChannelIDs() []string

	InChannel(string) bool
	InChannelName(string) bool
	GetUserStore() UserStore
	GetUserContext() UserContext

	GetBotChannel(channelName string) BotChannel
	GetBotChannelByID(channelID string) BotChannel

	MakeUser(string) User
	MakeChannel(string) Channel

	// Permanently join channel with the given channel ID
	JoinChannel(channelID string) error

	// Permanently leave channel with the given channel ID
	LeaveChannel(channelID string) error

	// Connect to the OnNewChannelJoined callback
	OnNewChannelJoined(cb func(channel Channel))

	Quit(message string)

	Application() Application

	// DEV
	Disconnect()
}

type SimpleCommand interface {
	Trigger([]string, MessageEvent) Actions
}

type Stream interface {
	Status() StreamStatus

	// Update forwards the given helix data to its internal status
	Update(*helix.Stream)
}

type StreamStatus interface {
	Live() bool
	StartedAt() time.Time
}

type StreamStore interface {
	// GetStream ensures that the given Account is being followed & polled for stream status updates
	// If the account is already being followed, the Stream that was already stored is returned.
	GetStream(Account) Stream
}

type TwitchAccount interface {
	ID() string
	Name() string
}

type TwitchAuths interface {
	Bot() *oauth2.Config
	Streamer() *oauth2.Config
	User() *oauth2.Config
}

type TwitchEventSubNotification struct {
	Subscription helix.EventSubSubscription `json:"subscription"`
	Challenge    string                     `json:"challenge"`
	Event        json.RawMessage            `json:"event"`
}

type UnmuteAction interface {
	User() User

	Type() MuteType
}

type User interface {
	// Has channel or global permission
	HasPermission(Channel, Permission) bool

	// Has global permission
	HasGlobalPermission(Permission) bool

	// Has channel permission
	HasChannelPermission(Channel, Permission) bool

	GetName() string
	GetDisplayName() string
	GetID() string
	IsModerator() bool
	IsBroadcaster() bool
	IsVIP() bool
	IsSubscriber() bool
	GetBadges() map[string]int

	// Set the ID of this user
	// Will return an error if the ID of this user was already set
	SetID(string) error

	// Set the Name of this user
	// Will return an error if the Name of this user was already set
	SetName(string) error
}

type UserContext interface {
	GetContext(channelID, userID string) []string

	// The message must be preformatted. i.e. [2018-09-13 502:501:201] username: message
	AddContext(channelID, userID, message string)
}

type UserStore interface {
	// Input: Lowercased twitch usernames
	// Returns: user IDs as strings in no specific order, and a bool indicating whether the user needs to exhaust the list first and wait
	GetIDs([]string) map[string]string

	GetID(string) string

	GetUserByLogin(string) (User, error)
	GetUserByID(string) (User, error)

	GetName(string) string

	// Input: list of twitch IDs
	// Returns: map of twitch IDs pointing at twitch usernames
	GetNames([]string) map[string]string

	Hydrate([]User) error
}

type UserStoreRequest struct {
	// contains filtered or unexported fields
}

type WhisperAction interface {
	User() User
	Content() string
}