lambda/gtk-message.go

package main

// This file contains the function that generates message widgets depending on message stanza

import (
	"context"
	"encoding/base64"
	"fmt"
	"github.com/diamondburned/gotk4/pkg/gdk/v4"
	"github.com/diamondburned/gotk4/pkg/glib/v2"
	"github.com/diamondburned/gotk4/pkg/gtk/v4"
	"github.com/google/uuid"
	"github.com/jasonlovesdoggo/gopen"
	"gosrc.io/xmpp/stanza"
	xmpp_color "mellium.im/xmpp/color"
	"mellium.im/xmpp/jid"
	"os"
	"path/filepath"
	"runtime"
	"strings"
)

func generatePresenceWidget(p stanza.Packet) gtk.Widgetter {
	b := gtk.NewBox(gtk.OrientationHorizontal, 0)
	presence, ok := p.(stanza.Presence)
	if !ok {
		return gtk.NewLabel(loadedLocale["unsupportedMessage"])
	}

	nick := JidMustParse(presence.From).Resource

	if presence.Type == stanza.PresenceTypeUnavailable {
		var mu MucUser
		ok := presence.Get(&mu)
		if ok {
			if mu.MucUserItem.Affiliation == "outcast" {
				if loadedConfig.CompactMode {
					l := gtk.NewLabel("")
					if mu.MucUserItem.Actor.Nick != "" {
						l.SetMarkup(fmt.Sprintf("<span background='black' foreground='white'>%s%s%s!</span>", nick, loadedLocale["bannedWidget"], mu.MucUserItem.Actor.Nick))
					} else {
						l.SetMarkup(fmt.Sprintf("<span background='black' foreground='white'>%s%s%s!</span>", nick, loadedLocale["bannedWidgetNoActor"]))
					}
					b.Append(l)
					return b
				}

				b.Append(gtk.NewImageFromPaintable(clientAssetsLoad("outcast")))
				b.Append(gtk.NewLabel(nick + loadedLocale["bannedWidget"] + mu.MucUserItem.Actor.Nick + "!"))
				return b
			}
		}

		if loadedConfig.CompactMode {
			l := gtk.NewLabel("")
			l.SetMarkup(fmt.Sprintf("<span foreground='%s'>- %s</span>", "red", nick))
			b.Append(l)
		} else {
			b.Append(gtk.NewImageFromPaintable(clientAssetsLoad("door_out")))
			b.Append(gtk.NewLabel(nick))
		}
	} else {
		if loadedConfig.CompactMode {
			l := gtk.NewLabel("")
			l.SetMarkup(fmt.Sprintf("<span foreground='%s'>+ %s</span>", "green", nick))
			b.Append(l)
		} else {
			b.Append(gtk.NewImageFromPaintable(clientAssetsLoad("door_in")))
			b.Append(gtk.NewLabel(JidMustParse(presence.From).Resource))
		}
	}

	b.SetTooltipText(presence.Status)
	return b
}

func generateMessageWidget(p stanza.Packet, blocked bool, target string) (gtk.Widgetter, bool) {
	m, ok := p.(stanza.Message)
	if !ok {
		return gtk.NewLabel("Unsupported message."), true
	}

	readmarker := Marker{}
	ok = m.Get(&readmarker)
	if ok {
		b := gtk.NewBox(gtk.OrientationHorizontal, 0)
		b.Append(gtk.NewLabel(fmt.Sprintf("%s%s", JidMustParse(m.From).Resource, loadedLocale["readWidget"])))
		return b, true
	}

	composing := stanza.StateComposing{}
	ok = m.Get(&composing)
	if ok {
		b := gtk.NewBox(gtk.OrientationHorizontal, 0)
		b.Append(gtk.NewLabel(fmt.Sprintf("%s%s", JidMustParse(m.From).Resource, loadedLocale["isTyping"])))
		return b, true
	}

	if m.Error.Type != "" {
		error_box := gtk.NewBox(gtk.OrientationHorizontal, 0)
		cancel_img := gtk.NewImageFromPaintable(clientAssetsLoad("cancel"))
		error_label := gtk.NewLabel(m.Error.Text + ": ")

		error_box.Append(cancel_img)
		error_box.Append(error_label)
		error_box.Append(gtk.NewLabel(m.Error.Reason))
		return error_box, true
	}

	store_label := false
	tab, ok := tabs.Load(target)
	if ok {
		store_label = true
	}
	typed_tab := tab.(*chatTab)

	sid := StanzaID{}
	m.Get(&sid)

	ocu := OccupantID{}

	m.Get(&ocu)
	id := JidMustParse(m.From).Resource

	name := id

	custom_nick, ok := loadedConfig.CustomNicks[ocu.ID]
	if ok {
		name = custom_nick
	}

	// Avatar hash custom nicks. This code needs to be optimised.
	mo, ok := mucmembers.Load(JidMustParse(m.From).Bare())
	if ok {
		mm, ok := mo.(mucUnit)
		if ok {
			mmm, ok := mm.Members.Load(id)
			if ok {
				u := mmm.(stanza.Presence)
				var vcu VCardUpdate
				ok = u.Get(&vcu)
				if ok {
					av_nick, ok := loadedConfig.CustomNicksAV[vcu.Photo]
					if ok {
						name = av_nick
					}
				}
			}
		}
	}

	padding := 10
	orientation := gtk.OrientationVertical
	if loadedConfig.CompactMode {
		padding = 5
		orientation = gtk.OrientationHorizontal
	}
	mainBox := gtk.NewBox(orientation, padding)
	gesture := gtk.NewGestureClick()
	gesture.SetButton(3) // Right click

	popover := gtk.NewPopover()
	popover.SetParent(mainBox)
	popover.SetHasArrow(false)

	gesture.Connect("pressed", func(n_press, x, y int) {
		rc_box := gtk.NewBox(gtk.OrientationVertical, 0)

		reactions := gtk.NewBox(gtk.OrientationHorizontal, 0)
		reaction := []string{"👍", "👎", "♥️", "🤣", "💀"}
		for _, v := range reaction {
			like := gtk.NewButtonWithLabel(v)
			like.SetHExpand(true)
			like.ConnectClicked(func() {
				client.SendRaw(fmt.Sprintf(`
		<message from='%s' to='%s' id='%s' type='%s'>
		<reactions id='%s' xmlns='urn:xmpp:reactions:0'>
		<reaction>%s</reaction>
		</reactions>
		</message>
		`, m.To, jid.MustParse(m.From).Bare().String(), uuid.New().String(), m.Type, sid.ID, v))
			})
			reactions.Append(like)
		}

		rc_box.Append(reactions)
		custom := gtk.NewEntry()
		custom.SetPlaceholderText("...")
		enter_custom := gtk.NewButtonWithLabel("React")
		enter_custom.SetLabel("React")
		enter_custom.SetHExpand(true)
		enter_custom.ConnectClicked(func() {

			client.SendRaw(fmt.Sprintf(`
		<message from='%s' to='%s' id='%s' type='%s'>
		<reactions id='%s' xmlns='urn:xmpp:reactions:0'>
		<reaction>%s</reaction>
		</reactions>
		</message>
		`, m.To, jid.MustParse(m.From).Bare().String(), uuid.New().String(), m.Type, sid.ID, custom.Text()))
		})
		rc_box.Append(custom)
		rc_box.Append(enter_custom)

		quote := gtk.NewButtonWithLabel("Quote")
		quote.ConnectClicked(func() {
			lines := strings.Split(m.Body, "\n")
			for i, line := range lines {
				quoteline := "> " + line
				lines[i] = quoteline
			}

			newstr := strings.Join(lines, "\n") + "\n\n"

			message_en.SetText(newstr)
		})
		rc_box.Append(quote)

		vp := gtk.NewButtonWithLabel("View profile")
		vp.ConnectClicked(func() {
			mo, ok := mucmembers.Load(JidMustParse(m.From).Bare())
			if ok {
				mm, ok := mo.(mucUnit)
				if ok {
					mmm, ok := mm.Members.Load(id)
					if ok {
						u := mmm.(stanza.Presence)
						showUserWindow(u, name)
					}
				}
			}
		})

		rc_box.Append(vp)

		popover.SetChild(rc_box)
		rect := gdk.NewRectangle(x, y, 1, 1)
		popover.SetPointingTo(&rect)
		popover.Popup()
	})

	mainBox.AddController(gesture)

	if name == "" {
		name = JidMustParse(m.From).Bare()
	}

	if loadedConfig.CompactMode {
		if m.Body == "" {
			/*
				mlabel.SetText(loadedLocale["noBodySet"])
				mlabel.AddCSSClass("visitor")
			*/
			return nil, false
		}
		al := gtk.NewLabel(name)
		ycbcr := xmpp_color.String(id, 255, loadedConfig.CVD)
		r, g, b, _ := ycbcr.RGBA()
		hexcolor := fmt.Sprintf("#%02x%02x%02x", r, g, b)

		al.SetMarkup(fmt.Sprintf("<span foreground='%s'>%s</span>", hexcolor, name))
		al.SetSelectable(true)
		al.SetVAlign(gtk.AlignStart)
		mainBox.Append(al)

		body := m.Body
		body = XEPToPango(body, false)

		mlabel := gtk.NewLabel("")
		mlabel.SetMarkup(body)

		mlabel.SetWrap(true)
		mlabel.SetSelectable(true)
		// mlabel.SetHAlign(gtk.AlignFill)
		mainBox.Append(mlabel)

		if store_label {
			typed_tab.msg_refsID[m.Id].label_ref = mlabel
			tabs.Store(target, tab)
		}
	} else {
		authorBox := gtk.NewBox(gtk.OrientationHorizontal, 10)
		contentBox := gtk.NewBox(gtk.OrientationHorizontal, 0)

		al := gtk.NewLabel(name)
		al.AddCSSClass("author")
		al.SetSelectable(true)

		if m.Type == stanza.MessageTypeGroupchat {
			can_generate := true
			mo, ok := mucmembers.Load(JidMustParse(m.From).Bare())
			if !ok {
				can_generate = false
			}

			mm, ok := mo.(mucUnit)
			if !ok {
				can_generate = false
			}
			mmm := mm.Members
			mmmm, ok := mmm.Load(id)
			if !ok {
				can_generate = false
			}

			im := gtk.NewImage()
			im.SetFromPaintable(clientAssetsLoad("DefaultAvatar"))
			im.SetPixelSize(40)
			im.AddCSSClass("author_img")
			// createIdenticon(m.From, false, im)
			authorBox.Append(im)
			if can_generate {
				pres := mmmm.(stanza.Presence)
				var vu VCardUpdate
				pres.Get(&vu)
				if vu.Photo != "" {
					go getAvatar(m.From, vu.Photo, im)
				}
			} else {
				createIdenticon(m.From, false, im)
				/*
					im.SetPixelSize(40)
					im.AddCSSClass("author_img")
					authorBox.Append(im)
				*/
			}
		} else if m.Type == stanza.MessageTypeChat {
			al.SetText(al.Text() + loadedLocale["whispers"])
		}

		authorBox.Append(al)

		if m.Thread != "" {
			im := gtk.NewImage()
			createIdenticon(m.Thread, true, im)
			im.SetPixelSize(10)
			authorBox.Append(im)
		}

		wxdc := XDCEl{}
		ok = m.Get(&wxdc)
		if ok {
			authorBox.Append(gtk.NewLabel("🎮"))
		}

		body := m.Body
		body = XEPToPango(body, false)

		mlabel := gtk.NewLabel("")
		if m.Body == "" {
			/*
				mlabel.SetText(loadedLocale["noBodySet"])
				mlabel.AddCSSClass("visitor")
			*/
			return nil, false
		}

		mlabel.SetMarkup(body)
		mlabel.SetWrap(true)
		mlabel.SetSelectable(true)
		mlabel.SetHAlign(gtk.AlignFill)

		if store_label {
			msg, ok := typed_tab.msg_refsID[m.Id]
			if !ok {
				msg = new(abMessage)
				typed_tab.msg_refsID[m.Id] = msg
			}

			msg.label_ref = mlabel
			msg.ocu_id = ocu.ID
			tabs.Store(target, typed_tab)
		}
		contentBox.Append(mlabel)

		mainBox.Append(authorBox)
		mainBox.Append(contentBox)

		oob := stanza.OOB{}
		ok = m.Get(&oob)
		if ok {
			// media := newPictureFromWeb(oob.URL)
			// media.SetCanShrink(false)
			// mainBox.Append(media)
			// media.AddCSSClass("chat_image")
			mbtn := gtk.NewButtonWithLabel("🖼️")
			// mbtn.SetChild(newImageFromWeb(oob.URL))
			mbtn.ConnectClicked(func() {
				gopen.Open(oob.URL)
			})
			authorBox.Append(mbtn)
		}

		if m.Subject != "" {
			subjectlabel := gtk.NewLabel(m.Subject)
			subjectlabel.SetWrap(true)
			subjectlabel.SetSelectable(true)
			subjectlabel.SetHAlign(gtk.AlignFill)
			subjectlabel.AddCSSClass("subject")
			mainBox.Append(subjectlabel)
		}

		link_preview := LinkPreview{}
		ok = m.Get(&link_preview)
		if ok {
			lp_box := gtk.NewBox(gtk.OrientationVertical, 10)
			lp_box.AddCSSClass("link_preview")
			lp_title := gtk.NewLabel(link_preview.Title)
			lp_title.SetSelectable(true)
			lp_title.SetWrap(true)
			lp_title.SetHAlign(gtk.AlignFill)
			lp_desc := gtk.NewLabel(link_preview.URL + "\n" + link_preview.Description)
			lp_desc.SetSelectable(true)
			lp_desc.SetWrap(true)
			lp_desc.SetHAlign(gtk.AlignFill)

			lp_box.Append(lp_title)
			lp_box.Append(lp_desc)

			warning := gtk.NewLabel("⚠️")
			warning.SetTooltipText(loadedLocale["linkPreviewWarning"])
			lp_box.Append(warning)

			mainBox.Append(lp_box)
		}

	}

	if loadedConfig.BlockingMode == Highlight && blocked {
		mainBox.AddCSSClass("blocked")
	}

	if loadedConfig.BlockingMode == Hide && blocked {
		mainBox.SetVisible(false)
		blocked_box := gtk.NewBox(gtk.OrientationVertical, 0)
		blocked_part := gtk.NewBox(gtk.OrientationHorizontal, 0)
		blocked_part.Append(gtk.NewLabel("This message is from a user you have blocked. "))

		show_hide := gtk.NewButtonWithLabel("Toggle")
		show_hide.ConnectClicked(func() {
			mainBox.SetVisible(!mainBox.IsVisible())
		})

		blocked_part.Append(show_hide)
		blocked_box.Append(blocked_part)
		blocked_box.Append(mainBox)
		return blocked_box, true
	}

	return mainBox, true
}

func getVAdjustment(scrolledWindow *gtk.ScrolledWindow) *gtk.Adjustment {
	val := scrolledWindow.ObjectProperty("vadjustment").(*gtk.Adjustment)
	return val
}

func getAvatar(j, hash string, i *gtk.Image) { // TODO: This function probably shouldn't be here, and should probably be in xmpp-helpers or somewhere similar.
	oghash := hash
	p, err := ensureCache()
	if err != nil {
		createIdenticon(j, false, i)
		return
	}

	if hash == "" {
		createIdenticon(j, false, i)
		return
	}

	_, ok := invalidImages.Load(hash)
	if ok {
		createIdenticon(j, false, i)
		return
	}

	hash = filepath.Join(p, hash)

	_, err = os.ReadFile(hash)
	if err == nil {
		/*
			i, err = newImageFromPath(hash)
			if err != nil {
				invalidImages.Store(oghash, true)
				createIdenticon(j, false, i)
			}
		*/

		glib.IdleAdd(func() {
			setImageFromPath(hash, i)
		})
		return
	}

	iqResp, err := stanza.NewIQ(stanza.Attrs{
		Type: "get",
		From: clientroot.Session.BindJid,
		To:   j,
		Id:   uuid.New().String(),
		Lang: "en",
	})

	if err != nil {
		panic(err)
	}

	iqResp.Payload = &VCard{}

	ctx := context.TODO()
	mychan, err := client.SendIQ(ctx, iqResp)
	if err != nil {
		panic(err)
	}
	result := <-mychan
	card, ok := result.Payload.(*VCard)
	if !ok {
		createIdenticon(j, false, i)
		return
	}

	base64_data := card.Photo.Binval
	if card.Photo.Binval == "" || ((card.Photo.Type == "image/svg+xml" || card.Photo.Type == "image/webp") && (runtime.GOOS == "windows" || runtime.GOOS == "netbsd")) {
		invalidImages.Store(oghash, true)
		createIdenticon(j, false, i)
		return
	}

	data, err := base64.StdEncoding.DecodeString(base64_data)
	if err != nil {
		panic(err)
	}

	err = os.WriteFile(hash, data, 0644)
	if err != nil {
		panic(err)
	}

	glib.IdleAdd(func() {
		err = setImageFromPath(hash, i)
		if err != nil {
			invalidImages.Store(oghash, true)
			createIdenticon(j, false, i)
		}

		i.AddCSSClass(loadedConfig.CVD.String() + "_CVD")
	})
}