feat(send): translate ReplyMarkup to MTProto reply markup

replyMarkupToTg maps the sealed ReplyMarkup union (inline/reply keyboards,
remove, force-reply) and their buttons onto tg.ReplyMarkupClass via the gotd
message/markup helpers. The union switch is exhaustive (gochecksumtype).
Inline text buttons are rejected with a 400, matching the Bot API.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ernado

markup_to_tg.go

@@ -0,0 +1,97 @@
+package botapi
+
+import (
+	"github.com/gotd/td/telegram/message/markup"
+	"github.com/gotd/td/tg"
+)
+
+// replyMarkupToTg translates a Bot API ReplyMarkup into the MTProto
+// tg.ReplyMarkupClass understood by the sender.
+//
+// The switch over the sealed ReplyMarkup union is exhaustive (enforced by the
+// gochecksumtype linter): every variant is handled.
+func replyMarkupToTg(m ReplyMarkup) (tg.ReplyMarkupClass, error) {
+	switch m := m.(type) {
+	case *InlineKeyboardMarkup:
+		rows := make([]tg.KeyboardButtonRow, 0, len(m.InlineKeyboard))
+		for _, row := range m.InlineKeyboard {
+			buttons := make([]tg.KeyboardButtonClass, len(row))
+			for i, btn := range row {
+				b, err := inlineButtonToTg(btn)
+				if err != nil {
+					return nil, err
+				}
+				buttons[i] = b
+			}
+			rows = append(rows, tg.KeyboardButtonRow{Buttons: buttons})
+		}
+		return &tg.ReplyInlineMarkup{Rows: rows}, nil
+	case *ReplyKeyboardMarkup:
+		rows := make([]tg.KeyboardButtonRow, 0, len(m.Keyboard))
+		for _, row := range m.Keyboard {
+			buttons := make([]tg.KeyboardButtonClass, len(row))
+			for i, btn := range row {
+				buttons[i] = keyboardButtonToTg(btn)
+			}
+			rows = append(rows, tg.KeyboardButtonRow{Buttons: buttons})
+		}
+		res := &tg.ReplyKeyboardMarkup{
+			Resize:     m.ResizeKeyboard,
+			SingleUse:  m.OneTimeKeyboard,
+			Selective:  m.Selective,
+			Persistent: m.IsPersistent,
+			Rows:       rows,
+		}
+		if m.InputFieldPlaceholder != "" {
+			res.SetPlaceholder(m.InputFieldPlaceholder)
+		}
+		return res, nil
+	case *ReplyKeyboardRemove:
+		if m.Selective {
+			return markup.SelectiveHide(), nil
+		}
+		return markup.Hide(), nil
+	case *ForceReply:
+		res := &tg.ReplyKeyboardForceReply{Selective: m.Selective}
+		if m.InputFieldPlaceholder != "" {
+			res.SetPlaceholder(m.InputFieldPlaceholder)
+		}
+		return res, nil
+	default:
+		return nil, &Error{Code: 400, Description: "Bad Request: unsupported reply markup"}
+	}
+}
+
+func inlineButtonToTg(btn InlineKeyboardButton) (tg.KeyboardButtonClass, error) {
+	switch {
+	case btn.URL != "":
+		return markup.URL(btn.Text, btn.URL), nil
+	case btn.CallbackData != "":
+		return markup.Callback(btn.Text, []byte(btn.CallbackData)), nil
+	case btn.WebApp != nil:
+		return markup.WebView(btn.Text, btn.WebApp.URL), nil
+	case btn.SwitchInlineQuery != nil:
+		return markup.SwitchInline(btn.Text, *btn.SwitchInlineQuery, false), nil
+	case btn.SwitchInlineQueryCurrentChat != nil:
+		return markup.SwitchInline(btn.Text, *btn.SwitchInlineQueryCurrentChat, true), nil
+	case btn.Pay:
+		return markup.Buy(btn.Text), nil
+	default:
+		return nil, &Error{Code: 400, Description: "Bad Request: text buttons are unallowed in the inline keyboard"}
+	}
+}
+
+func keyboardButtonToTg(btn KeyboardButton) tg.KeyboardButtonClass {
+	switch {
+	case btn.RequestContact:
+		return markup.RequestPhone(btn.Text)
+	case btn.RequestLocation:
+		return markup.RequestGeoLocation(btn.Text)
+	case btn.RequestPoll != nil:
+		return markup.RequestPoll(btn.Text, btn.RequestPoll.Type == PollQuiz)
+	case btn.WebApp != nil:
+		return markup.SimpleWebView(btn.Text, btn.WebApp.URL)
+	default:
+		return markup.Button(btn.Text)
+	}
+}

markup_to_tg_test.go

@@ -0,0 +1,80 @@
+package botapi
+
+import (
+	"testing"
+
+	"github.com/gotd/td/tg"
+)
+
+func TestReplyMarkupToTg_Inline(t *testing.T) {
+	q := "go"
+	m := &InlineKeyboardMarkup{InlineKeyboard: [][]InlineKeyboardButton{{
+		{Text: "site", URL: "https://example.com"},
+		{Text: "ok", CallbackData: "ok:1"},
+		{Text: "switch", SwitchInlineQuery: &q},
+		{Text: "pay", Pay: true},
+	}}}
+
+	got, err := replyMarkupToTg(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	inline, isInline := got.(*tg.ReplyInlineMarkup)
+	if !isInline || len(inline.Rows) != 1 || len(inline.Rows[0].Buttons) != 4 {
+		t.Fatalf("unexpected: %#v", got)
+	}
+	if _, isURL := inline.Rows[0].Buttons[0].(*tg.KeyboardButtonURL); !isURL {
+		t.Fatalf("button 0: want URL, got %T", inline.Rows[0].Buttons[0])
+	}
+	cb, isCb := inline.Rows[0].Buttons[1].(*tg.KeyboardButtonCallback)
+	if !isCb || string(cb.Data) != "ok:1" {
+		t.Fatalf("button 1: want callback ok:1, got %#v", inline.Rows[0].Buttons[1])
+	}
+	si, isSwitch := inline.Rows[0].Buttons[2].(*tg.KeyboardButtonSwitchInline)
+	if !isSwitch || si.Query != "go" || si.SamePeer {
+		t.Fatalf("button 2: want switch-inline, got %#v", inline.Rows[0].Buttons[2])
+	}
+}
+
+func TestReplyMarkupToTg_InlineTextButtonRejected(t *testing.T) {
+	m := &InlineKeyboardMarkup{InlineKeyboard: [][]InlineKeyboardButton{{{Text: "plain"}}}}
+	if _, err := replyMarkupToTg(m); err == nil {
+		t.Fatal("plain text inline button must be rejected")
+	}
+}
+
+func TestReplyMarkupToTg_Reply(t *testing.T) {
+	m := &ReplyKeyboardMarkup{
+		Keyboard:        [][]KeyboardButton{{Button("hi"), ButtonContact("phone"), ButtonLocation("where")}},
+		ResizeKeyboard:  true,
+		OneTimeKeyboard: true,
+	}
+	got, err := replyMarkupToTg(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	kb, ok := got.(*tg.ReplyKeyboardMarkup)
+	if !ok || !kb.Resize || !kb.SingleUse {
+		t.Fatalf("unexpected: %#v", got)
+	}
+	if _, ok := kb.Rows[0].Buttons[1].(*tg.KeyboardButtonRequestPhone); !ok {
+		t.Fatalf("want request-phone, got %T", kb.Rows[0].Buttons[1])
+	}
+	if _, ok := kb.Rows[0].Buttons[2].(*tg.KeyboardButtonRequestGeoLocation); !ok {
+		t.Fatalf("want request-geo, got %T", kb.Rows[0].Buttons[2])
+	}
+}
+
+func TestReplyMarkupToTg_RemoveAndForceReply(t *testing.T) {
+	if _, err := replyMarkupToTg(RemoveKeyboard()); err != nil {
+		t.Fatal(err)
+	}
+	got, err := replyMarkupToTg(&ForceReply{ForceReply: true, InputFieldPlaceholder: "type"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	fr, ok := got.(*tg.ReplyKeyboardForceReply)
+	if !ok || fr.Placeholder != "type" {
+		t.Fatalf("unexpected force reply: %#v", got)
+	}
+}