package app

import (
	"context"
	"time"

	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
	"go.etcd.io/bbolt"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/config"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/initialize"
	"penahub.gitlab.yandexcloud.net/backend/templategen_feedback/internal/server"
)

func Run(cfg *config.Config) {
	cfgLogger := zap.NewDevelopmentConfig()
	cfgLogger.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
	cfgLogger.EncoderConfig.ConsoleSeparator = "    "

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	logger, err := cfgLogger.Build()
	if err != nil {
		panic(err)
	}

	logger.Info("RUN", zap.Any("ENV", cfg))

	db, err := bbolt.Open("bolt.db", 0666, nil)
	if err != nil {
		logger.Error("BoltDB", zap.Error(err))
		return
	}

	bot, err := tgbotapi.NewBotAPI(cfg.TelegramToken)
	if err != nil {
		logger.Error("TelegramBotApi", zap.Error(err))
		return
	}

	repositories, err := initialize.NewRepositories(logger, db)
	if err != nil {
		logger.Error("BoltDB", zap.Error(err))
		return
	}

	clients := initialize.NewClients(logger, bot, cfg.TelegramChannelID, cfg.TemplatePath)

	bot.GetUpdatesChan(tgbotapi.UpdateConfig{
		Offset:         0,
		Limit:          0,
		Timeout:        0,
		AllowedUpdates: nil,
	})

	err = clients.Telegram.SendMessage("Bot started")
	if err != nil {
		logger.Error("TelegramBot", zap.Error(err))
		return
	}
	
	// Send alive message
	now := time.Now()
	alarm := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, now.Location())
	timer := time.NewTimer(time.Until(alarm))
	go func() {
		for {
			select {
			case now = <-timer.C:
				err = clients.Telegram.SendMessage("Я пока еще не сдох!")
				if err != nil {
					logger.Error("TelegramBot", zap.Error(err))
					return
				}

				alarm = now.AddDate(0, 0, 1)
				timer.Reset(time.Until(alarm))
			case <-ctx.Done():
				timer.Stop()
				return
			}
		}
		
	}()

	controllers := initialize.NewControllers(logger, repositories.Feedback, clients.Telegram)

	if err = controllers.Feedback.WarmUpService(); err != nil {
		logger.Error("Controllers.Feedback", zap.Error(err))
		return
	}

	logger.Info("Feedback service", zap.String("status", "warmed up"))

	go controllers.Feedback.RunService()

	logger.Info("Feedback service", zap.String("status", "started"))

	httpSrv := server.NewHTTP(cfg, logger).Register(controllers.List()...)

	go func() {
		err := httpSrv.Start()
		if err != nil {
			logger.Error("CanNotServe", zap.Error(err))
			return
		}
	}()

	gracefulShutdown(logger, httpSrv, db, controllers)
}