message.go

package user

import (
	"errors"
	"fmt"
	"regexp"
	"sort"
	"strings"
	"time"

	"github.com/wechaty/go-wechaty/wechaty-puppet/filebox"
	"github.com/wechaty/go-wechaty/wechaty-puppet/helper"
	"github.com/wechaty/go-wechaty/wechaty-puppet/schemas"
	"github.com/wechaty/go-wechaty/wechaty/config"
	_interface "github.com/wechaty/go-wechaty/wechaty/interface"
)

type Message struct {
	_interface.IAccessory

	id      string
	payload *schemas.MessagePayload
}

// NewMessage ...
func NewMessage(id string, accessory _interface.IAccessory) _interface.IMessage {
	return &Message{
		IAccessory: accessory,
		id:         id,
	}
}

func (m *Message) Ready() (err error) {
	if m.IsReady() {
		return nil
	}

	m.payload, err = m.GetPuppet().MessagePayload(m.id)

	if err != nil {
		return err
	}

	talkerId := m.payload.TalkerId
	roomId := m.payload.RoomId
	listenerId := m.payload.ListenerId

	if roomId != "" {
		if err := m.GetWechaty().Room().Load(roomId).Ready(false); err != nil {
			return err
		}
	}

	if talkerId != "" {
		if err := m.GetWechaty().Contact().Load(talkerId).Ready(false); err != nil {
			return err
		}
	}

	if listenerId != "" {
		if err := m.GetWechaty().Contact().Load(listenerId).Ready(false); err != nil {
			return err
		}
	}
	return nil
}

func (m *Message) IsReady() bool {
	return m.payload != nil
}

// String() message to print string
func (m *Message) String() string {
	talkerStr := ""
	roomStr := ""
	talker := m.Talker()
	if talker != nil {
		talkerStr = "🗣" + talker.String()
	}
	room := m.Room()
	if room != nil {
		roomStr = "@👥'" + room.String()
	}
	str := fmt.Sprintf("Message#%s[%s%s]", m.Type(), talkerStr, roomStr)
	switch m.Type() {
	case schemas.MessageTypeText, schemas.MessageTypeUnknown:
		r := []rune(m.Text())
		if len(r) > 70 {
			r = r[0:70]
		}
		str += "\t" + string(r)
	}
	return str
}

// Room get the room from the message.
func (m *Message) Room() _interface.IRoom {
	roomId := m.payload.RoomId
	if roomId == "" {
		return nil
	}
	return m.GetWechaty().Room().Load(roomId)
}

// Type get the type from the message.
func (m *Message) Type() schemas.MessageType {
	return m.payload.Type
}

// From get the sender from a message
// Deprecated: please use Talker()
func (m *Message) From() _interface.IContact {
	return m.Talker()
}

// Talker Get the talker of a message.
func (m *Message) Talker() _interface.IContact {
	if m.payload.TalkerId == "" {
		return nil
	}
	return m.GetWechaty().Contact().Load(m.payload.TalkerId)
}

// Text get the text content of the message
func (m *Message) Text() string {
	return m.payload.Text
}

// Self check if a message is sent by self
func (m *Message) Self() bool {
	userID := m.GetPuppet().SelfID()
	talker := m.Talker()

	//TODO talker 为 nil 的情况，群公告消息
	if talker == nil {
		return false
	}
	return userID == talker.ID()
}

func (m *Message) Age() time.Duration {
	return time.Since(m.Date())
}

// Date sent date
func (m *Message) Date() time.Time {
	return m.payload.Timestamp
}

// Say reply a Text or Media File message to the sender.
// Support msg:
// string
// Contact
// filebox.FileBox
// UrlLink
// MiniProgram
// Location
func (m *Message) Say(sayable interface{}) (_interface.IMessage, error) {
	conversationId, err := m.sayId()
	if err != nil {
		return nil, err
	}
	var messageID string
	switch v := sayable.(type) {
	case string:
		messageID, err = m.GetPuppet().MessageSendText(conversationId, v)
	case *Contact:
		messageID, err = m.GetPuppet().MessageSendContact(conversationId, v.Id)
	case *filebox.FileBox:
		messageID, err = m.GetPuppet().MessageSendFile(conversationId, v)
	case *UrlLink:
		messageID, err = m.GetPuppet().MessageSendURL(conversationId, v.payload)
	case *MiniProgram:
		messageID, err = m.GetPuppet().MessageSendMiniProgram(conversationId, v.payload)
	case *Location:
		messageID, err = m.GetPuppet().MessageSendLocation(conversationId, v.payload)
	default:
		return nil, fmt.Errorf("unknown msg: %v", sayable)
	}
	if err != nil {
		return nil, err
	}
	if messageID == "" {
		return nil, nil
	}
	message := m.GetWechaty().Message().Load(messageID)
	if err := message.Ready(); err != nil {
		return nil, err
	}
	return message, nil
}

func (m *Message) sayId() (string, error) {
	room := m.Room()
	if room != nil {
		return room.ID(), nil
	}
	talker := m.Talker()
	if talker != nil {
		return talker.ID(), nil
	}
	return "", errors.New("neither room nor talker? ")
}

// To get the destination of the message
// Deprecated: please use Listener()
func (m *Message) To() _interface.IContact {
	return m.Listener()
}

/*
Listener Get the destination of the message.
listener() will return nil if a message is in a room
use Room() to get the room.
*/
func (m *Message) Listener() _interface.IContact {
	if m.payload.ListenerId == "" {
		return nil
	}
	return m.GetWechaty().Contact().Load(m.payload.ListenerId)
}

// ToRecalled get the recalled message
func (m *Message) ToRecalled() (_interface.IMessage, error) {
	if m.Type() != schemas.MessageTypeRecalled {
		return nil, errors.New("can not call toRecalled() on message which is not recalled type")
	}
	originalMessageId := m.Text()
	if originalMessageId == "" {
		return nil, errors.New("can not find recalled message")
	}
	message := m.GetWechaty().Message().Load(originalMessageId)
	err := message.Ready()
	if err != nil {
		return nil, err
	}
	return message, nil
}

// Recall recall a message
func (m *Message) Recall() (bool, error) {
	recall, err := m.GetPuppet().MessageRecall(m.id)
	if err != nil {
		return false, err
	}
	return recall, nil
}

// MentionList get message mentioned contactList.
func (m *Message) MentionList() []_interface.IContact {
	room := m.Room()
	if m.Type() != schemas.MessageTypeText || room == nil {
		return nil
	}
	var contactList []_interface.IContact
	if len(m.payload.MentionIdList) > 0 {
		async := helper.NewAsync(helper.DefaultWorkerNum)
		for _, id := range m.payload.MentionIdList {
			id := id
			async.AddTask(func() (interface{}, error) {
				contact := m.GetWechaty().Contact().Load(id)
				return contact, contact.Ready(false)
			})
		}
		for _, v := range async.Result() {
			if v.Err != nil {
				continue
			}
			contactList = append(contactList, v.Value.(_interface.IContact))
		}
		return contactList
	}

	atList := config.AtSeparatorRegex.Split(m.Text(), -1)
	if len(atList) == 0 {
		return nil
	}
	var mentionNameList []string
	for _, v := range atList {
		if !strings.Contains(v, "@") {
			continue
		}
		for _, v := range m.multipleAt(v) {
			if v == "" {
				continue
			}
			mentionNameList = append(mentionNameList, v)
		}
	}
	async := helper.NewAsync(helper.DefaultWorkerNum)
	for _, name := range mentionNameList {
		name := name
		async.AddTask(func() (interface{}, error) {
			return room.MemberAll(name)
		})
	}
	for _, v := range async.Result() {
		if v.Err != nil {
			continue
		}
		contactList = append(contactList, v.Value.([]_interface.IContact)...)
	}
	return contactList
}

// convert 'hello@a@b@c' to [ 'c', 'b@c', 'a@b@c' ]
func (m *Message) multipleAt(str string) []string {
	r, _ := regexp.Compile("^.*?@")
	strs := strings.Split(r.ReplaceAllString(str, "@"), "@")
	var name string
	var nameList []string
	var filterStrs []string
	for _, mentionName := range strs {
		if mentionName == "" {
			continue
		}
		filterStrs = append(filterStrs, mentionName)
	}
	//reverse
	sort.Slice(filterStrs, func(i, j int) bool {
		return filterStrs[i] > filterStrs[j]
	})
	for _, mentionName := range filterStrs {
		name = mentionName + "@" + name
		r := []rune(name)
		nameList = append(nameList, string(r[0:len(r)-1]))
	}
	return nameList
}

func (m *Message) MentionText() string {
	text := m.Text()
	room := m.Room()
	mentionList := m.MentionList()

	if room == nil || len(mentionList) == 0 {
		return text
	}

	toAliasName := func(member _interface.IContact) string {
		alias, _ := room.Alias(member)
		if alias != "" {
			return alias
		}
		return member.Name()
	}

	var mentionNameList []string
	for _, v := range mentionList {
		mentionNameList = append(mentionNameList, toAliasName(v))
	}

	for _, v := range mentionNameList {
		reg := regexp.MustCompile("@" + regexp.QuoteMeta(v) + "(\u2005|\u0020|$)")
		text = reg.ReplaceAllString(text, "")
	}
	return strings.TrimSpace(text)
}

func (m *Message) MentionSelf() bool {
	selfID := m.GetPuppet().SelfID()
	mentionList := m.MentionList()
	for _, v := range mentionList {
		if v.ID() == selfID {
			return true
		}
	}
	return false
}

// Forward Forward the received message.
func (m *Message) Forward(contactOrRoomId string) error {
	_, err := m.GetPuppet().MessageForward(contactOrRoomId, m.id)
	return err
}

// ToFileBox extract the Media File from the Message, and put it into the FileBox.
func (m *Message) ToFileBox() (*filebox.FileBox, error) {
	if m.Type() == schemas.MessageTypeText {
		return nil, errors.New("text message no file")
	}
	return m.GetPuppet().MessageFile(m.id)
}

// ToImage extract the Image File from the Message, so that we can use different image sizes.
func (m *Message) ToImage() (_interface.IImage, error) {
	if m.Type() != schemas.MessageTypeImage {
		return nil, errors.New("not a image type message")
	}
	return m.GetWechaty().Image().Create(m.id), nil
}

// ToContact Get Share Card of the Message
// Extract the Contact Card from the Message, and encapsulate it into Contact class
func (m *Message) ToContact() (_interface.IContact, error) {
	if m.Type() != schemas.MessageTypeContact {
		return nil, errors.New("message not a ShareCard")
	}
	contactID, err := m.GetPuppet().MessageContact(m.id)
	if err != nil {
		return nil, err
	}
	contact := m.GetWechaty().Contact().Load(contactID)
	err = contact.Ready(false)
	if err != nil {
		return nil, err
	}
	return contact, nil
}

func (m *Message) ToUrlLink() (*UrlLink, error) {
	if m.Type() != schemas.MessageTypeURL {
		return nil, errors.New("message not a Url Link")
	}
	urlPayload, err := m.GetPuppet().MessageURL(m.id)
	if err != nil {
		return nil, err
	}
	return NewUrlLink(urlPayload), nil
}

func (m *Message) ToMiniProgram() (*MiniProgram, error) {
	if m.Type() != schemas.MessageTypeMiniProgram {
		return nil, errors.New("message not a MiniProgram")
	}
	miniProgramPayload, err := m.GetPuppet().MessageMiniProgram(m.id)
	if err != nil {
		return nil, err
	}
	return NewMiniProgram(miniProgramPayload), nil
}

func (m *Message) ToLocation() (*Location, error) {
	if m.Type() != schemas.MessageTypeLocation {
		return nil, errors.New("message not a Location")
	}

	payload, err := m.GetPuppet().MessageLocation(m.id)
	if err != nil {
		return nil, err
	}
	return NewLocation(payload), nil
}

// ID message id
func (m *Message) ID() string {
	return m.id
}