core/clients/telegram/tg.go

package telegram

import (
	"context"
	"errors"
	"fmt"
	"path/filepath"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/pj_errors"
	"penahub.gitlab.yandexcloud.net/backend/tdlib/client"
	"sync"
	"time"
)

type TelegramClient struct {
	repo           *dal.DAL
	TgClients      map[int64]*client.Client
	WaitingClients map[string]WaitingClient
	mu             sync.Mutex
}

type WaitingClient struct {
	TdLibClient *client.Client
	PreviousReq AuthTgUserReq
	Authorizer  *client.ClientAuthorizer
}

// todo come back saved tg accs to slice for check this status
func NewTelegramClient(ctx context.Context, repo *dal.DAL) (*TelegramClient, error) {
	tgClient := &TelegramClient{
		repo:           repo,
		TgClients:      make(map[int64]*client.Client),
		WaitingClients: make(map[string]WaitingClient),
	}

	allTgAccounts, err := repo.TgRepo.GetAllTgAccounts(ctx)
	if err != nil {
		if errors.Is(err, pj_errors.ErrNotFound) {
			return tgClient, nil
		}
		return nil, err
	}

	for _, account := range allTgAccounts {
		if account.Status == model.ActiveTg {
			authorizer := client.ClientAuthorizerr()
			authorizer.TdlibParameters <- &client.SetTdlibParametersRequest{
				UseTestDc:           false,
				DatabaseDirectory:   filepath.Join(".tdlib", "database"),
				FilesDirectory:      filepath.Join(".tdlib", "files"),
				UseFileDatabase:     false,
				UseChatInfoDatabase: false,
				UseMessageDatabase:  false,
				UseSecretChats:      false,
				ApiId:               account.ApiID,
				ApiHash:             account.ApiHash,
				SystemLanguageCode:  "en",
				DeviceModel:         "Server",
				SystemVersion:       "1.0.0",
				ApplicationVersion:  "1.0.0",
			}

			_, err := client.SetLogVerbosityLevel(&client.SetLogVerbosityLevelRequest{
				NewVerbosityLevel: 1,
			})
			if err != nil {
				return nil, err
			}

			var tdlibClient *client.Client
			var goErr error
			go func() {
				tdlibClient, goErr = client.NewClient(authorizer)
				if goErr != nil {
					fmt.Println("new client failed", err)
					return
				}
				fmt.Println("i am down")
			}()
			if goErr != nil {
				return nil, goErr
			}

			for {
				state, ok := <-authorizer.State
				if !ok {
					break
				}
				fmt.Println("currnet state:", state)
				switch state.AuthorizationStateType() {
				case client.TypeAuthorizationStateWaitPhoneNumber:
					authorizer.PhoneNumber <- account.PhoneNumber
				case client.TypeAuthorizationStateWaitCode:
					err := tgClient.repo.TgRepo.UpdateStatusTg(ctx, account.ID, model.InactiveTg)
					if err != nil {
						return nil, err
					}
				case client.TypeAuthorizationStateLoggingOut, client.TypeAuthorizationStateClosing, client.TypeAuthorizationStateClosed:
					err := tgClient.repo.TgRepo.UpdateStatusTg(ctx, account.ID, model.InactiveTg)
					if err != nil {
						return nil, err
					}
				case client.TypeAuthorizationStateReady:
					// костыль так как в либе тож костыль стоит пока там ьд обновиться будет ниловый всегда клиент
					time.Sleep(3 * time.Second)
					me, err := tdlibClient.GetMe()
					if err != nil {
						return nil, err
					}
					fmt.Printf("Me: %s %s [%v]", me.FirstName, me.LastName, me.Usernames)
					tgClient.mu.Lock()
					tgClient.TgClients[account.ID] = tdlibClient
					tgClient.mu.Unlock()
					break
				case client.TypeAuthorizationStateWaitPassword:
					authorizer.Password <- account.Password
				}
			}
		}
	}
	return tgClient, nil
}

type AuthTgUserReq struct {
	ApiID       int32  `json:"api_id"`
	ApiHash     string `json:"api_hash"`
	PhoneNumber string `json:"phone_number"`
	Password    string `json:"password"`
}

func (tg *TelegramClient) AddedToMap(data WaitingClient, id string) {
	fmt.Println("AddedToMap")
	tg.mu.Lock()
	defer tg.mu.Unlock()
	tg.WaitingClients[id] = data
}

func (tg *TelegramClient) GetFromMap(id string) (WaitingClient, bool) {
	fmt.Println("GetFromMap")
	tg.mu.Lock()
	defer tg.mu.Unlock()
	if data, ok := tg.WaitingClients[id]; ok {
		delete(tg.WaitingClients, id)
		return data, true
	}
	return WaitingClient{}, false
}

func (tg *TelegramClient) SaveTgAccount(ctx context.Context, tdLibClient *client.Client, account model.TgAccount) (int64, error) {
	tg.mu.Lock()
	defer tg.mu.Unlock()
	id, err := tg.repo.TgRepo.CreateTgAccount(ctx, account)
	if err != nil {
		return 0, err
	}
	tg.TgClients[id] = tdLibClient
	return id, nil
}

func (tg *TelegramClient) CreateChannel(channelName string, botID int64) (string, error) {
	tg.mu.Lock()
	defer tg.mu.Unlock()

	var activeClient *client.Client
	for _, c := range tg.TgClients {
		activeClient = c
		break
	}

	if activeClient == nil {
		return "", errors.New("no active Telegram clients")
	}

	channel, err := activeClient.CreateNewSupergroupChat(&client.CreateNewSupergroupChatRequest{
		Title:       channelName,
		IsChannel:   true,
		Description: "private channel",
	})
	if err != nil {
		return "", fmt.Errorf("failed to create channel: %s", err.Error())
	}

	//resp, err := activeClient.AddChatMember(&client.AddChatMemberRequest{
	//	ChatId: channel.Id,
	//	UserId: botID,
	//})
	//if err != nil {
	//	return "", fmt.Errorf("failed to add bot to channel: %s", err.Error())
	//}
	//
	//fmt.Println("resp", resp)
	//
	//_, err = activeClient.SetChatMemberStatus(&client.SetChatMemberStatusRequest{
	//	ChatId:   channel.Id,
	//	MemberId: &client.MessageSenderUser{UserId: botID},
	//	Status: &client.ChatMemberStatusAdministrator{
	//		CanBeEdited: true,
	//		Rights: &client.ChatAdministratorRights{
	//			CanManageChat:       false,
	//			CanChangeInfo:       true,
	//			CanPostMessages:     true,
	//			CanEditMessages:     true,
	//			CanDeleteMessages:   true,
	//			CanInviteUsers:      true,
	//			CanRestrictMembers:  true,
	//			CanPinMessages:      true,
	//			CanManageTopics:     true,
	//			CanPromoteMembers:   true,
	//			CanManageVideoChats: true,
	//			CanPostStories:      true,
	//			CanEditStories:      true,
	//			CanDeleteStories:    true,
	//			IsAnonymous:         true,
	//		},
	//	},
	//})
	//if err != nil {
	//	return "", fmt.Errorf("failed to make bot admin: %s", err.Error())
	//}

	//_, err = activeClient.LeaveChat(&client.LeaveChatRequest{
	//	ChatId: channel.Id,
	//})
	//if err != nil {
	//	return "", fmt.Errorf("failed to leave the channel: %s", err.Error())
	//}

	inviteLink, err := activeClient.CreateChatInviteLink(&client.CreateChatInviteLinkRequest{
		ChatId:             channel.Id,
		Name:               channelName,
		ExpirationDate:     0,
		MemberLimit:        0,
		CreatesJoinRequest: false,
	})
	if err != nil {
		return "", fmt.Errorf("failed to get invite link: %s", err.Error())
	}

	return inviteLink.InviteLink, nil
}