package main

import (
	"context"
	"crypto/md5" //#nosec G501 // Used to derive a static jitter checksum, not cryptographically
	"fmt"
	"math"
	"strings"
	"time"

	"github.com/pkg/errors"
	log "github.com/sirupsen/logrus"

	"github.com/Luzifer/go-latestver/internal/database"
	"github.com/Luzifer/go-latestver/internal/fetcher"
)

const schedulerInterval = time.Minute

var schedulerRunActive bool

func schedulerRun() {
	if schedulerRunActive {
		return
	}
	schedulerRunActive = true
	defer func() { schedulerRunActive = false }()

	for i := range configFile.Catalog {
		ce := configFile.Catalog[i]
		if err := checkForUpdates(&ce); err != nil {
			log.WithField("entry", ce.Key()).WithError(err).Error("Unable to update entry")
		}
	}
}

func checkForUpdates(ce *database.CatalogEntry) error {
	logger := log.WithField("entry", ce.Key())

	cm, err := storage.Catalog.GetMeta(ce)
	if err != nil {
		return errors.Wrap(err, "getting catalog meta")
	}

	nct := nextCheckTime(ce, cm.LastChecked)
	logger = logger.WithFields(log.Fields{
		"last": cm.LastChecked,
		"next": nct,
	})
	logger.Trace("Next check time found")
	if nct.After(time.Now()) {
		// Not yet ready to check
		return nil
	}

	logger.Debug("Checking for updates")

	ver, vertime, err := fetcher.Get(ce.Fetcher).FetchVersion(context.Background(), ce.FetcherConfig)
	ver = strings.TrimPrefix(ver, "v")
	vertime = vertime.Truncate(time.Second).UTC()

	logger = logger.WithFields(log.Fields{
		"from": cm.CurrentVersion,
		"to":   ver,
	})

	var (
		compareErr   error
		shouldUpdate = true
	)
	if ce.VersionConstraint != nil {
		shouldUpdate, compareErr = ce.VersionConstraint.ShouldApply(cm.CurrentVersion, ver)
	}

	switch {
	case err != nil:
		logger.WithError(err).Error("Fetcher caused error, error is stored in entry")
		cm.Error = err.Error()

	case compareErr != nil:
		logger.WithError(compareErr).Error("Version compare caused error, error is stored in entry")
		cm.Error = compareErr.Error()

	case cm.CurrentVersion != ver && !shouldUpdate:
		logger.Info("Version-updated prevented by constraints")
		cm.Error = ""

	case cm.CurrentVersion != ver && shouldUpdate:
		logger.Info("Entry had version update")

		if err = storage.Logs.Add(&database.LogEntry{
			CatalogName: ce.Name,
			CatalogTag:  ce.Tag,
			Timestamp:   time.Now().Truncate(time.Second).UTC(),
			VersionTo:   ver,
			VersionFrom: cm.CurrentVersion,
		}); err != nil {
			return errors.Wrap(err, "adding log entry")
		}

		cm.VersionTime = ptrTime(vertime)
		cm.CurrentVersion = ver
		cm.Error = ""

	case cm.CurrentVersion == ver:
		logger.Debug("Version did not change")
		cm.Error = ""

	default:
		cm.Error = ""
	}

	cm.LastChecked = ptrTime(time.Now().Truncate(time.Second).UTC())
	return errors.Wrap(storage.Catalog.PutMeta(cm), "updating meta entry")
}

func nextCheckTime(ce *database.CatalogEntry, lastCheck *time.Time) time.Time {
	if lastCheck == nil {
		// Has never been checked, check ASAP
		return time.Now()
	}

	hash := md5.New() //#nosec G401 // Used to derive a static jitter checksum, not cryptographically
	fmt.Fprint(hash, ce.Key())

	var jitter int64
	for i, c := range hash.Sum(nil) {
		jitter += int64(c) * int64(math.Pow(10, float64(i))) //nolint:gomnd // No need for constant here
	}

	next := lastCheck.
		Truncate(cfg.CheckDistribution).
		Add(time.Duration(jitter) % cfg.CheckDistribution)

	if next.Before(lastCheck.Add(schedulerInterval)) {
		next = next.Add(cfg.CheckDistribution)
	}

	return next.Truncate(time.Second)
}

func ptrTime(t time.Time) *time.Time { return &t }