rss-tools @ 70f8cb68d68020ffbcd4b0b5d602cefaa36e5a2a

package telegram

import (

	"bytes"

	"context"

	"encoding/base64"

	"encoding/json"

	"fmt"

	"io"

	"net/http"

	"net/url"

	"strconv"

	"strings"

)

const (

	apiBase       = "https://api.telegram.org"

	maxPhotoBytes = 20 << 20

)

type TelegramSDK struct {

	client *http.Client

	token  string

}

func NewSDK(client *http.Client, token string) *TelegramSDK {

	return &TelegramSDK{

		token:  token,

		client: client,

	}

}

type Response[T any] struct {

	OK          bool   `json:"ok"`

	Result      T      `json:"result"`

	Description string `json:"description"`

}

type Update struct {

	UpdateID int64    `json:"update_id"`

	Message  *Message `json:"message"`

}

type User struct {

	ID        int64  `json:"id"`

	FirstName string `json:"first_name"`

	Username  string `json:"username"`

}

type Chat struct {

	ID int64 `json:"id"`

}

type Message struct {

	MessageID        int64             `json:"message_id"`

	From             *User             `json:"from"`

	Chat             *Chat             `json:"chat"`

	Text             string            `json:"text"`

	Caption          string            `json:"caption,omitempty"`

	Date             int64             `json:"date"`

	MediaGroupID     string            `json:"media_group_id,omitempty"`

	Photo            []PhotoSize       `json:"photo,omitempty"`

	PhotoBase64      string            `json:"photo_base64,omitempty"`

	PhotoMIMEType    string            `json:"photo_mime_type,omitempty"`

	PhotoAttachments []PhotoAttachment `json:"photo_attachments,omitempty"`

	LinkTitles       map[string]string `json:"-"`

}

type PhotoAttachment struct {

	Base64   string `json:"base64,omitempty"`

	MIMEType string `json:"mime_type,omitempty"`

}

type PhotoSize struct {

	FileID   string `json:"file_id"`

	Width    int    `json:"width"`

	Height   int    `json:"height"`

	FileSize int64  `json:"file_size"`

}

func (t *TelegramSDK) GetUpdates(ctx context.Context, offset int64) ([]Update, error) {

	params := url.Values{}

	params.Set("offset", strconv.FormatInt(offset, 10))

	params.Set("timeout", "30")

	var resp Response[[]Update]

	if err := t.req(ctx, "getUpdates", params, nil, &resp); err != nil {

		return nil, err

	}

	for i := range resp.Result {

		msg := resp.Result[i].Message

		if msg == nil || len(msg.Photo) == 0 {

			continue

		}

		data, mimeType, err := t.downloadLargestPhoto(ctx, msg.Photo)

		if err != nil {

			return nil, err

		}

		attachment := PhotoAttachment{

			Base64:   base64.StdEncoding.EncodeToString(data),

			MIMEType: mimeType,

		}

		msg.PhotoAttachments = append(msg.PhotoAttachments, attachment)

		if msg.PhotoBase64 == "" {

			msg.PhotoBase64 = attachment.Base64

			msg.PhotoMIMEType = attachment.MIMEType

		}

	}

	return resp.Result, nil

}

type messageReactionReq struct {

	Type  string `json:"type"`

	Emoji string `json:"emoji"`

}

type setReactionReq struct {

	ChatID    int64                `json:"chat_id"`

	MessageID int64                `json:"message_id"`

	Reaction  []messageReactionReq `json:"reaction"`

}

func (t *TelegramSDK) SetReaction(ctx context.Context, chatID, messageID int64, emoji string) error {

	var resp Response[bool]

	return t.req(ctx, "setMessageReaction", nil, setReactionReq{

		ChatID:    chatID,

		MessageID: messageID,

		Reaction:  []messageReactionReq{{Type: "emoji", Emoji: emoji}},

	}, &resp)

}

type tgFile struct {

	FilePath string `json:"file_path"`

}

func (t *TelegramSDK) downloadLargestPhoto(ctx context.Context, photos []PhotoSize) ([]byte, string, error) {

	if len(photos) == 0 {

		return nil, "", nil

	}

	filePath, err := t.getFilePath(ctx, photos[len(photos)-1].FileID)

	if err != nil {

		return nil, "", err

	}

	fileURL := fmt.Sprintf("%s/file/bot%s/%s", apiBase, t.token, filePath)

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fileURL, nil)

	if err != nil {

		return nil, "", err

	}

	res, err := t.client.Do(req)

	if err != nil {

		return nil, "", err

	}

	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {

		return nil, "", fmt.Errorf("photo download failed with status %d", res.StatusCode)

	}

	data, err := io.ReadAll(io.LimitReader(res.Body, maxPhotoBytes+1))

	if err != nil {

		return nil, "", err

	}

	if len(data) > maxPhotoBytes {

		return nil, "", fmt.Errorf("photo too large: %d bytes", len(data))

	}

	mimeType := http.DetectContentType(data)

	if !strings.HasPrefix(mimeType, "image/") {

		mimeType = "image/jpeg"

	}

	return data, mimeType, nil

}

func (t *TelegramSDK) getFilePath(ctx context.Context, fileID string) (string, error) {

	params := url.Values{}

	params.Set("file_id", fileID)

	var resp Response[tgFile]

	if err := t.req(ctx, "getFile", params, nil, &resp); err != nil {

		return "", err

	}

	return resp.Result.FilePath, nil

}

func (t *TelegramSDK) req(ctx context.Context, method string, params url.Values, body any, out any) error {

	u := fmt.Sprintf("%s/bot%s/%s", apiBase, t.token, method)

	if params != nil {

		u += "?" + params.Encode()

	}

	var req *http.Request

	var err error

	if body != nil {

		var data []byte

		data, err = json.Marshal(body)

		if err != nil {

			return err

		}

		req, err = http.NewRequestWithContext(ctx, http.MethodPost, u, bytes.NewReader(data))

		if err != nil {

			return err

		}

		req.Header.Set("Content-Type", "application/json")

	} else {

		req, err = http.NewRequestWithContext(ctx, http.MethodGet, u, nil)

		if err != nil {

			return err

		}

	}

	res, err := t.client.Do(req)

	if err != nil {

		return err

	}

	defer res.Body.Close()

	return json.NewDecoder(res.Body).Decode(out)

}