package common
import (
"encoding/json"
"errors"
"fmt"
"strings"
)
type DataInterface interface {
HTML() string
}
type ChatData struct {
Type DataType
Data DataInterface
}
func (c ChatData) ToJSON() (ChatDataJSON, error) {
rawData, err := json.Marshal(c.Data)
return ChatDataJSON{
Type: c.Type,
Data: rawData,
}, err
}
type ChatDataJSON struct {
Type DataType
Data json.RawMessage
}
func (c ChatDataJSON) ToData() (ChatData, error) {
data, err := c.GetData()
return ChatData{
Type: c.Type,
Data: data,
}, err
}
func (c ChatDataJSON) GetData() (DataInterface, error) {
var data DataInterface
var err error
switch c.Type {
case DTInvalid:
return nil, errors.New("data type is invalid")
case DTChat:
d := DataMessage{}
err = json.Unmarshal(c.Data, &d)
data = d
case DTCommand:
d := DataCommand{}
err = json.Unmarshal(c.Data, &d)
data = d
case DTEvent:
d := DataEvent{}
err = json.Unmarshal(c.Data, &d)
data = d
case DTClient:
d := ClientData{}
err = json.Unmarshal(c.Data, &d)
data = d
case DTHidden:
d := HiddenMessage{}
err = json.Unmarshal(c.Data, &d)
data = d
default:
err = fmt.Errorf("unhandled data type: %d", c.Type)
}
return data, err
}
type ClientData struct {
Type ClientDataType
Message string
}
func (c ClientData) HTML() string {
// Client data is for client to server communication only, so clients should not see this
return `The developer messed up. You should not be seeing this.`
}
type DataMessage struct {
From string
Color string
Message string
Level CommandLevel
Type MessageType
}
// TODO: Read this HTML from a template somewhere
func (dc DataMessage) HTML() string {
switch dc.Type {
case MsgAction:
return `` + dc.From +
` ` + dc.Message + ``
case MsgServer:
return `` + dc.Message + ``
case MsgError:
return `` + dc.Message + ``
case MsgNotice:
return `` + dc.Message + ``
case MsgCommandResponse:
return `` + dc.Message + ``
case MsgCommandError:
return `` + dc.Message + ``
default:
badge := ""
switch dc.Level {
case CmdlMod:
badge = ``
case CmdlAdmin:
badge = ``
}
return `` + badge + `` + dc.From +
`: ` + dc.Message + ``
}
}
func NewChatMessage(name, color, msg string, lvl CommandLevel, msgtype MessageType) ChatData {
return ChatData{
Type: DTChat,
Data: DataMessage{
From: name,
Color: color,
Message: msg,
Type: msgtype,
Level: lvl,
},
}
}
type DataCommand struct {
Command CommandType
Arguments []string
}
func (de DataCommand) HTML() string {
switch de.Command {
case CmdPurgeChat:
return `Chat has been purged by a moderator.`
default:
return ""
}
}
func NewChatCommand(command CommandType, args []string) ChatData {
return ChatData{
Type: DTCommand,
Data: DataCommand{
Command: command,
Arguments: args,
},
}
}
type DataEvent struct {
Event EventType
User string
Color string
}
func (de DataEvent) HTML() string {
switch de.Event {
case EvKick:
return `` +
de.User + ` has been kicked.`
case EvLeave:
return `` +
de.User + ` has left the chat.`
case EvBan:
return `` +
de.User + ` has been banned.`
case EvJoin:
return `` +
de.User + ` has joined the chat.`
case EvNameChange:
names := strings.Split(de.User, ":")
if len(names) != 2 {
return `Somebody changed their name, but IDK who ` +
ParseEmotes("Jebaited") + `.`
}
return `` +
names[0] + ` has changed their name to ` + names[1] + `.`
case EvNameChangeForced:
names := strings.Split(de.User, ":")
if len(names) != 2 {
return `An admin changed somebody's name, but IDK who ` +
ParseEmotes("Jebaited") + `.`
}
return `` +
names[0] + ` has had their name changed to ` + names[1] + ` by an admin.`
}
return ""
}
func NewChatEvent(event EventType, name, color string) ChatData {
return ChatData{
Type: DTEvent,
Data: DataEvent{
Event: event,
User: name,
Color: color,
},
}
}
// DataHidden is for the server to send instructions and data
// to the client without the purpose of outputting it on the chat
type HiddenMessage struct {
Type ClientDataType
Data interface{}
}
func (h HiddenMessage) HTML() string {
return ""
}
func NewChatHiddenMessage(clientType ClientDataType, data interface{}) ChatData {
return ChatData{
Type: DTHidden,
Data: HiddenMessage{
Type: clientType,
Data: data,
},
}
}
func DecodeData(rawjson string) (ChatDataJSON, error) {
var data ChatDataJSON
err := json.Unmarshal([]byte(rawjson), &data)
return data, err
}
type JoinData struct {
Name string
Color string
}