telegabber/telegram/handlers.go

package telegram

import (
	"crypto/sha256"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"sync"

	"dev.narayana.im/narayana/telegabber/xmpp/gateway"

	log "github.com/sirupsen/logrus"
	"github.com/zelenin/go-tdlib/client"
)

func uhOh() {
	log.Fatal("Update type mismatch")
}

func int64SliceToStringSlice(ints []int64) []string {
	strings := make([]string, len(ints))
	wg := sync.WaitGroup{}

	for i, xi := range ints {
		wg.Add(1)
		go func(i int, xi int64) {
			strings[i] = strconv.FormatInt(xi, 10)
			wg.Done()
		}(i, xi)
	}
	wg.Wait()

	return strings
}

func (c *Client) updateHandler() {
	listener := c.client.GetListener()
	defer listener.Close()

	for update := range listener.Updates {
		if update.GetClass() == client.ClassUpdate {
			switch update.GetType() {
			case client.TypeUpdateUser:
				typedUpdate, ok := update.(*client.UpdateUser)
				if !ok {
					uhOh()
				}
				c.updateUser(typedUpdate)
				log.Debugf("%#v", typedUpdate.User)
			case client.TypeUpdateUserStatus:
				typedUpdate, ok := update.(*client.UpdateUserStatus)
				if !ok {
					uhOh()
				}
				c.updateUserStatus(typedUpdate)
				log.Debugf("%#v", typedUpdate.Status)
			case client.TypeUpdateNewChat:
				typedUpdate, ok := update.(*client.UpdateNewChat)
				if !ok {
					uhOh()
				}
				c.updateNewChat(typedUpdate)
				log.Debugf("%#v", typedUpdate.Chat)
			case client.TypeUpdateNewMessage:
				typedUpdate, ok := update.(*client.UpdateNewMessage)
				if !ok {
					uhOh()
				}
				c.updateNewMessage(typedUpdate)
				log.Debugf("%#v", typedUpdate.Message)
			case client.TypeUpdateMessageContent:
				typedUpdate, ok := update.(*client.UpdateMessageContent)
				if !ok {
					uhOh()
				}
				c.updateMessageContent(typedUpdate)
				log.Debugf("%#v", typedUpdate.NewContent)
			case client.TypeUpdateDeleteMessages:
				typedUpdate, ok := update.(*client.UpdateDeleteMessages)
				if !ok {
					uhOh()
				}
				c.updateDeleteMessages(typedUpdate)
			case client.TypeUpdateFile:
				typedUpdate, ok := update.(*client.UpdateFile)
				if !ok {
					uhOh()
				}
				c.updateFile(typedUpdate)
				log.Debugf("%#v", typedUpdate.File)
			default:
				// log only handled types
				continue
			}

			log.Debugf("%#v", update)
		}
	}
}

// new user discovered
func (c *Client) updateUser(update *client.UpdateUser) {
	cache.users[update.User.Id] = update.User
	show, status := userStatusToText(update.User.Status)
	c.processStatusUpdate(update.User.Id, status, show)
}

// user status changed
func (c *Client) updateUserStatus(update *client.UpdateUserStatus) {
	show, status := userStatusToText(update.Status)
	c.processStatusUpdate(update.UserId, status, show, gateway.SPImmed(false))
}

// new chat discovered
func (c *Client) updateNewChat(update *client.UpdateNewChat) {
	if update.Chat != nil && update.Chat.Photo != nil && update.Chat.Photo.Small != nil {
		_, err := c.client.DownloadFile(&client.DownloadFileRequest{
			FileId:      update.Chat.Photo.Small.Id,
			Priority:    32,
			Synchronous: true,
		})

		if err != nil {
			log.Error("Failed to download the chat photo")
		}
	}

	cache.chats[update.Chat.Id] = update.Chat

	var isChannel = false
	if update.Chat.Type.ChatTypeType() == client.TypeChatTypeSupergroup {
		typeSupergroup, ok := update.Chat.Type.(*client.ChatTypeSupergroup)
		if !ok {
			uhOh()
		}
		isChannel = typeSupergroup.IsChannel
	}

	if !(isChannel && update.Chat.LastReadInboxMessageId == 0) {
		gateway.SendPresence(
			c.xmpp,
			c.jid,
			gateway.SPFrom(strconv.Itoa(int(update.Chat.Id))),
			gateway.SPType("subscribe"),
			gateway.SPNickname(update.Chat.Title),
		)
	}

	if update.Chat.Id < 0 {
		c.processStatusUpdate(int32(update.Chat.Id), update.Chat.Title, "chat")
	}
}

// message received
func (c *Client) updateNewMessage(update *client.UpdateNewMessage) {
	// ignore self outgoing messages
	if update.Message.IsOutgoing &&
		update.Message.SendingState != nil &&
		update.Message.SendingState.MessageSendingStateType() == client.TypeMessageSendingStatePending {
		return
	}

	log.WithFields(log.Fields{
		"chat_id": update.Message.ChatId,
	}).Warn("New message from chat")

	text := c.messageToText(update.Message)
	file, filename := c.contentToFilename(update.Message.Content)

	// download file(s)
	if file != nil && !file.Local.IsDownloadingCompleted {
		c.client.DownloadFile(&client.DownloadFileRequest{
			FileId:      file.Id,
			Priority:    32,
			Synchronous: true,
		})
	}
	// OTR support (I do not know why would you need it, seriously)
	if !strings.HasPrefix(text, "?OTR") {
		var prefix strings.Builder
		prefix.WriteString(c.messageToPrefix(update.Message, c.formatContent(file, filename)))
		if text != "" {
			// \n if it is groupchat and message is not empty
			if update.Message.ChatId < 0 {
				prefix.WriteString("\n")
			} else if update.Message.ChatId > 0 {
				prefix.WriteString(" | ")
			}

			prefix.WriteString(text)
		}

		text = prefix.String()
	}

	// mark message as read
	c.client.ViewMessages(&client.ViewMessagesRequest{
		ChatId:     update.Message.ChatId,
		MessageIds: []int64{update.Message.Id},
		ForceRead:  true,
	})
	// forward message to XMPP
	gateway.SendMessage(c.jid, strconv.Itoa(int(update.Message.ChatId)), text, c.xmpp)
}

// message content updated
func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
	if update.NewContent.MessageContentType() == client.TypeMessageText {
		textContent := update.NewContent.(*client.MessageText)
		text := fmt.Sprintf("✎ %v | %s", update.MessageId, textContent.Text.Text)
		gateway.SendMessage(c.jid, strconv.FormatInt(update.ChatId, 10), text, c.xmpp)
	}
}

// message(s) deleted
func (c *Client) updateDeleteMessages(update *client.UpdateDeleteMessages) {
	if update.IsPermanent {
		text := "✗ " + strings.Join(int64SliceToStringSlice(update.MessageIds), ",")
		gateway.SendMessage(c.jid, strconv.FormatInt(update.ChatId, 10), text, c.xmpp)
	}
}

// file downloaded
func (c *Client) updateFile(update *client.UpdateFile) {
	// not really
	if !update.File.Local.IsDownloadingCompleted {
		return
	}

	err := os.Symlink(
		update.File.Local.Path,
		fmt.Sprintf(
			"%s/%s%s",
			c.content.Path,
			fmt.Sprintf("%x", sha256.Sum256([]byte(update.File.Remote.Id))),
			filepath.Ext(update.File.Local.Path),
		),
	)
	if err != nil {
		log.Errorf("Error creating symlink: %v", err)
	}
}