MovieNight/wasm/main.go

280 lines
6.9 KiB
Go

// +build js,wasm
package main
import (
"encoding/json"
"fmt"
"sort"
"strings"
"time"
"syscall/js"
"github.com/zorchenhimer/MovieNight/common"
)
var (
timestamp bool
color string
auth common.CommandLevel
global js.Value
)
func getElement(s string) js.Value {
return global.Get("document").Call("getElementById", s)
}
func join(v []js.Value) {
color := global.Call("getCookie", "color").String()
if color == "" {
// If a color is not set, do a random color
color = common.RandomColor()
} else if !common.IsValidColor(color) {
// Don't show the user the error, just clear the cookie
common.LogInfof("%#v is not a valid color, clearing cookie", color)
global.Call("deleteCookie", "color")
}
joinData, err := json.Marshal(common.JoinData{
Name: getElement("name").Get("value").String(),
Color: color,
})
if err != nil {
notify("Error prepping data for join")
common.LogErrorf("Could not prep data: %#v\n", err)
}
data, err := json.Marshal(common.ClientData{
Type: common.CdJoin,
Message: string(joinData),
})
if err != nil {
common.LogErrorf("Could not marshal data: %v", err)
}
global.Call("websocketSend", string(data))
}
func recieve(v []js.Value) {
if len(v) == 0 {
fmt.Println("No data received")
return
}
chatJSON, err := common.DecodeData(v[0].String())
if err != nil {
fmt.Printf("Error decoding data: %s\n", err)
global.Call("appendMessages", fmt.Sprintf("<div>%v</div>", v))
return
}
chat, err := chatJSON.ToData()
if err != nil {
fmt.Printf("Error converting ChatDataJSON to ChatData of type %d: %v", chatJSON.Type, err)
}
switch chat.Type {
case common.DTHidden:
h := chat.Data.(common.HiddenMessage)
switch h.Type {
case common.CdUsers:
names = nil
for _, i := range h.Data.([]interface{}) {
names = append(names, i.(string))
}
sort.Strings(names)
case common.CdAuth:
auth = h.Data.(common.CommandLevel)
case common.CdColor:
color = h.Data.(string)
global.Get("document").Set("cookie", fmt.Sprintf("color=%s; expires=Fri, 31 Dec 9999 23:59:59 GMT", color))
case common.CdEmote:
data := h.Data.(map[string]interface{})
emoteNames = make([]string, 0, len(data))
emotes = make(map[string]string)
for k, v := range data {
emoteNames = append(emoteNames, k)
emotes[k] = v.(string)
}
sort.Strings(emoteNames)
case common.CdJoin:
notify("")
global.Call("openChat")
case common.CdNotify:
notify(h.Data.(string))
}
case common.DTEvent:
d := chat.Data.(common.DataEvent)
// A server message is the only event that doesn't deal with names.
if d.Event != common.EvServerMessage {
websocketSend("", common.CdUsers)
}
// on join or leave, update list of possible user names
fallthrough
case common.DTChat:
msg := chat.Data.HTML()
if d, ok := chat.Data.(common.DataMessage); ok {
if timestamp && (d.Type == common.MsgChat || d.Type == common.MsgAction) {
h, m, _ := time.Now().Clock()
msg = fmt.Sprintf(`<span class="time">%02d:%02d</span> %s`, h, m, msg)
}
}
appendMessage(msg)
case common.DTCommand:
d := chat.Data.(common.DataCommand)
switch d.Command {
case common.CmdPlaying:
if d.Arguments == nil || len(d.Arguments) == 0 {
global.Call("setPlaying", "", "")
} else if len(d.Arguments) == 1 {
global.Call("setPlaying", d.Arguments[0], "")
} else if len(d.Arguments) == 2 {
global.Call("setPlaying", d.Arguments[0], d.Arguments[1])
}
case common.CmdRefreshPlayer:
global.Call("initPlayer", nil)
case common.CmdPurgeChat:
global.Call("purgeChat", nil)
appendMessage(d.HTML())
case common.CmdHelp:
url := "/help"
if d.Arguments != nil && len(d.Arguments) > 0 {
url = d.Arguments[0]
}
appendMessage(d.HTML())
global.Get("window").Call("open", url, "_blank", "menubar=0,status=0,toolbar=0,width=300,height=600")
case common.CmdEmotes:
url := "/emotes"
appendMessage(d.HTML())
global.Get("window").Call("open", url, "_blank", "menubar=0,status=0,toolbar=0,width=300,height=600")
}
}
}
func appendMessage(msg string) {
global.Call("appendMessages", "<div>"+msg+"</div>")
}
func websocketSend(msg string, dataType common.ClientDataType) error {
if strings.TrimSpace(msg) == "" && dataType == common.CdMessage {
return nil
}
data, err := json.Marshal(common.ClientData{
Type: dataType,
Message: msg,
})
if err != nil {
return fmt.Errorf("could not marshal data: %v", err)
}
global.Call("websocketSend", string(data))
return nil
}
func send(this js.Value, v []js.Value) interface{} {
if len(v) != 1 {
showChatError(fmt.Errorf("expected 1 parameter, got %d", len(v)))
return false
}
err := websocketSend(v[0].String(), common.CdMessage)
if err != nil {
showChatError(err)
return false
}
return true
}
func showChatError(err error) {
if err != nil {
fmt.Printf("Could not send: %v\n", err)
global.Call("appendMessages", `<div><span style="color: red;">Could not send message</span></div>`)
}
}
func notify(msg string) {
global.Call("setNotifyBox", msg)
}
func showTimestamp(v []js.Value) {
if len(v) != 1 {
// Don't bother with returning a value
return
}
timestamp = v[0].Bool()
}
func isValidColor(this js.Value, v []js.Value) interface{} {
if len(v) != 1 {
return false
}
return common.IsValidColor(v[0].String())
}
func debugValues(v []js.Value) {
for k, v := range map[string]interface{}{
"timestamp": timestamp,
"auth": auth,
"color": color,
"current suggestion": currentSug,
"current suggestion type": currentSugType,
"filtered suggestions": filteredSug,
"user names": names,
"emote names": emoteNames,
} {
fmt.Printf("%s: %#v\n", k, v)
}
}
func main() {
global = js.Global()
common.SetupLogging(common.LLDebug, "")
global.Set("processMessageKey", js.FuncOf(processMessageKey))
global.Set("sendMessage", js.FuncOf(send))
global.Set("isValidColor", js.FuncOf(isValidColor))
global.Set("recieveMessage", jsCallbackOf(recieve))
global.Set("processMessage", jsCallbackOf(processMessage))
global.Set("debugValues", jsCallbackOf(debugValues))
global.Set("showTimestamp", jsCallbackOf(showTimestamp))
global.Set("join", jsCallbackOf(join))
go func() {
time.Sleep(time.Second * 1)
inner := `<option value=""></option>`
for _, c := range common.Colors {
inner += fmt.Sprintf(`<option value="%s">%s</option>\n`, c, c)
}
global.Get("colorSelect").Set("innerHTML", inner)
}()
// This is needed so the goroutine does not end
for {
// heatbeat to keep connection alive to deal with nginx
if global.Get("inChat").Bool() {
websocketSend("", common.CdPing)
}
time.Sleep(time.Second * 10)
}
}
func jsCallbackOf(fnc func(v []js.Value)) js.Func {
return js.FuncOf(func(this js.Value, refs []js.Value) interface{} {
vals := make([]js.Value, 0, len(refs))
for _, ref := range refs {
vals = append(vals, ref)
}
fnc(vals)
return nil
})
}