package main

import (
	"os"
	"strings"
	"time"

	"github.com/NicoNex/echotron/v3"
	"github.com/TelegramExchange/tgex-backend/tg_bot/backend"
	"github.com/TelegramExchange/tgex-backend/tg_bot/bot"
	"github.com/TelegramExchange/tgex-backend/tg_bot/screens"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	initLogger()

	botToken := mustEnv("TELEGRAM__TOKEN")

	backendClient := backend.New(backend.Config{
		BaseURL:  mustEnv("BACKEND__BASE_URL"),
		LoginURL: mustEnv("LOGIN_URL"),
	})

	var commandRouter = func(command string) bot.State {
		switch command {
		case "/start":
			return &screens.MainMenu{}
		case "/start login":
			return &screens.Login{}
		}
		panic("Unknown command: " + command)
	}

	var handleGlobalCallback = func(callbackData string) bot.State {
		id, ok := strings.CutPrefix(callbackData, "pending_channel:")
		if ok {
			return &screens.SelectWorkspace{ChannelID: id, BackState: &screens.MainMenu{}}
		}

		id, ok = strings.CutPrefix(callbackData, "workspace_invite_accept:")
		if ok {
			return &screens.AcceptWorkspaceInvite{InviteID: id}
		}

		return nil
	}

	newBot := func(chatID int64) echotron.Bot {
		return bot.NewBot(chatID, botToken, commandRouter, backendClient, handleGlobalCallback)
	}

	dsp := echotron.NewDispatcher(botToken, newBot)

	updateOpts := echotron.UpdateOptions{
		AllowedUpdates: []echotron.UpdateType{
			echotron.MessageUpdate,
			echotron.CallbackQueryUpdate,
			echotron.MyChatMemberUpdate,
			echotron.ChatMemberUpdate,
			echotron.UpdateType("chat_join_request"),
		},
	}

	echotron.SetChatRequestLimit(0, 0)

	for {
		err := dsp.PollOptions(false, updateOpts)
		if err != nil {
			log.Error().Err(err).Msg("dsp.Poll failed, retrying in 5 seconds...")
			time.Sleep(5 * time.Second)
			continue
		}
		break
	}
}

func initLogger() {
	zerolog.TimeFieldFormat = time.RFC3339

	level := zerolog.InfoLevel
	if parsedLevel, err := zerolog.ParseLevel(os.Getenv("LOGGER__LEVEL")); err == nil {
		level = parsedLevel
	}
	zerolog.SetGlobalLevel(level)

	log.Logger = zerolog.New(os.Stdout).With().Timestamp().Logger().Level(level)

	prettyConsole := os.Getenv("LOGGER__PRETTY_CONSOLE")
	if prettyConsole == "" {
		prettyConsole = "true"
	}
	if prettyConsole == "true" {
		log.Logger = zerolog.New(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: "15:04:05"}).
			With().
			Timestamp().
			Logger().
			Level(level)
	}

	log.Info().Msg("Logger initialized")
}

func mustEnv(key string) string {
	v := os.Getenv(key)
	if v == "" {
		log.Fatal().Str("env", key).Msg("missing required environment variable")
	}

	return v
}