package main

import (
	"context"
	"log/slog"
	"os"
	"os/signal"
	"strings"

	"git.maximotejeda.com/maximo/telegram-base-bot/config"
	"git.maximotejeda.com/maximo/telegram-base-bot/internal/adapters/grpc/tgbuser"
	"git.maximotejeda.com/maximo/telegram-base-bot/internal/application/commands"
	"git.maximotejeda.com/maximo/telegram-base-bot/internal/application/messages"
	"git.maximotejeda.com/maximo/telegram-base-bot/internal/application/middlewares"
	"git.maximotejeda.com/maximo/telegram-base-bot/internal/application/queries"
	"git.maximotejeda.com/maximo/telegram-base-bot/internal/ports"
	"github.com/go-telegram/bot"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)


var log *slog.Logger

func main() {
	lvelEnv:= config.GetEnvironment()
	var lvel slog.Level
	if lvelEnv == "dev" || lvelEnv == "development"{
		lvel = slog.LevelDebug
	}else {
		lvel = slog.LevelInfo
	}
	log = slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{
		AddSource: true,
		Level: lvel,
	}))
	
	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
	defer cancel()
	userSVC, conn := CreateAdaptersGRPC()
	defer conn.Close()
	authRequired := middlewares.SetAuthRequired(userSVC, log)
	logMD := middlewares.CreateLogMiddleWare(ctx, log)
	opts := []bot.Option{
		bot.WithMiddlewares(logMD, authRequired),
		bot.WithAllowedUpdates(bot.AllowedUpdates{
			"message",
			"edited_message",
			"message_reaction",
			"message_reaction_count",
			"callback_query",
			"id",
		}),
		//		bot.WithDefaultHandler(api.Handler),
	}
	b, err := bot.New(config.GetToken(), opts...)
	if err != nil {
		panic(err)
	}
	bInfo , err := b.GetMe(ctx)
	if err != nil {
		panic(err)
	}
	
	// attempt to add bot to db
	err = userSVC.CreateBot(bInfo.Username)
	if err != nil {
		// want to fail fast in case of creating and svc not available
		// if i cant auth i dont want to run
		if strings.Contains(err.Error(), "rpc error: code = Unavailable desc = connection error: desc") {
			panic(err)
		}
	}

	commands.RegisterCommands(ctx, log, b)
	messages.RegisterMessageHandler(ctx, log, b)
	queries.RegisterQueries(ctx, log, b)
	messages.RegisterMessageReactionHandler(ctx, log, b)
	b.Start(ctx)
}

// CreateAdaptersGRPC
// Create connections for service
func CreateAdaptersGRPC() (ports.UserService, *grpc.ClientConn) {
	// we are outside update so we will be querying db to
	// get users interested in specific updates ex bpd, brd, apa
	// userID inst=> comma separated string
	var opts []grpc.DialOption
	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
	userConn, err := grpc.NewClient(config.GetUserServiceURL(), opts...)
	if err != nil {
		log.Error("creating grpc conn", "error", err)
		panic(err)
	}

	log.Info("success creating conn", "error", err)
	user, err := tgbuser.NewAdapter(userConn)
	if err != nil {
		log.Error("creating service adapter", "error", err)
		panic(err)
	}
	log.Info("success creating svc ",  "error", err)
	return user, userConn
}