42wim/matterbridge

package harmony

import (
    "fmt"
    "log"
    "strconv"
    "strings"
    "time"

    "github.com/42wim/matterbridge/bridge"
    "github.com/42wim/matterbridge/bridge/config"
    "github.com/harmony-development/shibshib"
    chatv1 "github.com/harmony-development/shibshib/gen/chat/v1"
    typesv1 "github.com/harmony-development/shibshib/gen/harmonytypes/v1"
    profilev1 "github.com/harmony-development/shibshib/gen/profile/v1"
)

type cachedProfile struct {
    data        *profilev1.GetProfileResponse
    lastUpdated time.Time
}

type Bharmony struct {
    *bridge.Config

    c            *shibshib.Client
    profileCache map[uint64]cachedProfile
}

func uToStr(in uint64) string {
    return strconv.FormatUint(in, 10)
}

func strToU(in string) (uint64, error) {
    return strconv.ParseUint(in, 10, 64)
}

func New(cfg *bridge.Config) bridge.Bridger {
    b := &Bharmony{
        Config:       cfg,
        profileCache: map[uint64]cachedProfile{},
    }

    return b
}

func (b *Bharmony) getProfile(u uint64) (*profilev1.GetProfileResponse, error) {
    if v, ok := b.profileCache[u]; ok && time.Since(v.lastUpdated) < time.Minute*10 {
        return v.data, nil
    }

    resp, err := b.c.ProfileKit.GetProfile(&profilev1.GetProfileRequest{
        UserId: u,
    })
    if err != nil {
        if v, ok := b.profileCache[u]; ok {
            return v.data, nil
        }
        return nil, err
    }
    b.profileCache[u] = cachedProfile{
        data:        resp,
        lastUpdated: time.Now(),
    }
    return resp, nil
}

func (b *Bharmony) avatarFor(m *chatv1.Message) string {
    if m.Overrides != nil {
        return m.Overrides.GetAvatar()
    }

    profi, err := b.getProfile(m.AuthorId)
    if err != nil {
        return ""
    }

    return b.c.TransformHMCURL(profi.Profile.GetUserAvatar())
}

func (b *Bharmony) usernameFor(m *chatv1.Message) string {
    if m.Overrides != nil {
        return m.Overrides.GetUsername()
    }

    profi, err := b.getProfile(m.AuthorId)
    if err != nil {
        return ""
    }

    return profi.Profile.UserName
}

func (b *Bharmony) toMessage(msg *shibshib.LocatedMessage) config.Message {
    message := config.Message{}
    message.Account = b.Account
    message.UserID = uToStr(msg.Message.AuthorId)
    message.Avatar = b.avatarFor(msg.Message)
    message.Username = b.usernameFor(msg.Message)
    message.Channel = uToStr(msg.ChannelID)
    message.ID = uToStr(msg.MessageId)

    switch content := msg.Message.Content.Content.(type) {
    case *chatv1.Content_EmbedMessage:
        message.Text = "Embed"
    case *chatv1.Content_AttachmentMessage:
        var s strings.Builder
        for idx, attach := range content.AttachmentMessage.Files {
            s.WriteString(b.c.TransformHMCURL(attach.Id))
            if idx < len(content.AttachmentMessage.Files)-1 {
                s.WriteString(", ")
            }
        }
        message.Text = s.String()
    case *chatv1.Content_PhotoMessage:
        var s strings.Builder
        for idx, attach := range content.PhotoMessage.GetPhotos() {
            s.WriteString(attach.GetCaption().GetText())
            s.WriteString("\n")
            s.WriteString(b.c.TransformHMCURL(attach.GetHmc()))
            if idx < len(content.PhotoMessage.GetPhotos())-1 {
                s.WriteString("\n\n")
            }
        }
        message.Text = s.String()
    case *chatv1.Content_TextMessage:
        message.Text = content.TextMessage.Content.Text
    }

    return message
}

func (b *Bharmony) outputMessages() {
    for {
        msg := <-b.c.EventsStream()

        if msg.Message.AuthorId == b.c.UserID {
            continue
        }

        b.Remote <- b.toMessage(msg)
    }
}

func (b *Bharmony) GetUint64(conf string) uint64 {
    num, err := strToU(b.GetString(conf))
    if err != nil {
        log.Fatal(err)
    }

    return num
}

func (b *Bharmony) Connect() (err error) {
    b.c, err = shibshib.NewClient(b.GetString("Homeserver"), b.GetString("Token"), b.GetUint64("UserID"))
    if err != nil {
        return
    }
    b.c.SubscribeToGuild(b.GetUint64("Community"))

    go b.outputMessages()

    return nil
}

func (b *Bharmony) send(msg config.Message) (id string, err error) {
    msgChan, err := strToU(msg.Channel)
    if err != nil {
        return
    }

    retID, err := b.c.ChatKit.SendMessage(&chatv1.SendMessageRequest{
        GuildId:   b.GetUint64("Community"),
        ChannelId: msgChan,
        Content: &chatv1.Content{
            Content: &chatv1.Content_TextMessage{
                TextMessage: &chatv1.Content_TextContent{
                    Content: &chatv1.FormattedText{
                        Text: msg.Text,
                    },
                },
            },
        },
        Overrides: &chatv1.Overrides{
            Username: &msg.Username,
            Avatar:   &msg.Avatar,
            Reason:   &chatv1.Overrides_Bridge{Bridge: &typesv1.Empty{}},
        },
        InReplyTo: nil,
        EchoId:    nil,
        Metadata:  nil,
    })
    if err != nil {
        err = fmt.Errorf("send: error sending message: %w", err)
        log.Println(err.Error())
    }

    return uToStr(retID.MessageId), err
}

func (b *Bharmony) delete(msg config.Message) (id string, err error) {
    msgChan, err := strToU(msg.Channel)
    if err != nil {
        return "", err
    }

    msgID, err := strToU(msg.ID)
    if err != nil {
        return "", err
    }

    _, err = b.c.ChatKit.DeleteMessage(&chatv1.DeleteMessageRequest{
        GuildId:   b.GetUint64("Community"),
        ChannelId: msgChan,
        MessageId: msgID,
    })
    return "", err
}

func (b *Bharmony) typing(msg config.Message) (id string, err error) {
    msgChan, err := strToU(msg.Channel)
    if err != nil {
        return "", err
    }

    _, err = b.c.ChatKit.Typing(&chatv1.TypingRequest{
        GuildId:   b.GetUint64("Community"),
        ChannelId: msgChan,
    })
    return "", err
}

func (b *Bharmony) Send(msg config.Message) (id string, err error) {
    switch msg.Event {
    case "":
        return b.send(msg)
    case config.EventMsgDelete:
        return b.delete(msg)
    case config.EventUserTyping:
        return b.typing(msg)
    default:
        return "", nil
    }
}

func (b *Bharmony) JoinChannel(channel config.ChannelInfo) error {
    return nil
}

func (b *Bharmony) Disconnect() error {
    return nil
}