package tokens

import (
	"amocrm/internal/models"
	"amocrm/internal/models/amo"
	"amocrm/internal/repository"
	"amocrm/pkg/amoClient"
	"context"
	"go.uber.org/zap"
	"time"
)

type Deps struct {
	AmoClient *amoClient.Amo
	Repo      *repository.Repository
	Logger    *zap.Logger
}

type Token struct {
	amoClient *amoClient.Amo
	repo      *repository.Repository
	logger    *zap.Logger
}

func NewRefreshWC(deps Deps) *Token {
	return &Token{
		amoClient: deps.AmoClient,
		repo:      deps.Repo,
		logger:    deps.Logger,
	}
}

func (wc *Token) Start(ctx context.Context) {
	ticker := time.NewTicker(5 * time.Minute)
	defer ticker.Stop()

	for {
		select {
		case <-ticker.C:
			wc.processTasks(ctx)

		case <-ctx.Done():
			return
		}
	}
}

func (wc *Token) processTasks(ctx context.Context) {
	tokens, err := wc.repo.CheckExpired(ctx)
	if err != nil {
		wc.logger.Error("error fetch expired tokens in mongo", zap.Error(err))
		return
	}
	for _, token := range tokens {
		req := amo.UpdateWebHookReq{
			GrantType:    "refresh_token",
			RefreshToken: token.RefreshToken,
		}
		newTokens, err := wc.amoClient.CreateWebHook(&req)
		if err != nil {
			wc.logger.Error("error create webhook for update tokens", zap.Error(err))
			continue
		}
		err = wc.repo.WebhookUpdate(ctx, models.Token{
			AccountID:    token.AccountID,
			RefreshToken: newTokens.RefreshToken,
			AccessToken:  newTokens.AccessToken,
			Expiration:   time.Now().Unix() + newTokens.ExpiresIn,
			CreatedAt:    time.Now().Unix(),
		})
		if err != nil {
			wc.logger.Error("error update new tokens in mongo", zap.Error(err))
			continue
		}
	}
}

func (wc *Token) Stop(ctx context.Context) error {
	return nil
}