// SPDX-License-Identifier: GPL-3.0-or-later

package jobmgr

import (
	"context"
	"sync"

	"github.com/netdata/netdata/go/go.d.plugin/agent/confgroup"
	"github.com/netdata/netdata/go/go.d.plugin/agent/module"
)

func newDiscoveredConfigsCache() *discoveredConfigs {
	return &discoveredConfigs{
		items: make(map[string]map[uint64]confgroup.Config),
	}
}

func newSeenConfigCache() *seenConfigs {
	return &seenConfigs{
		items: make(map[string]*seenConfig),
	}
}

func newExposedConfigCache() *exposedConfigs {
	return &exposedConfigs{
		items: make(map[string]*seenConfig),
	}
}

func newRunningJobsCache() *runningJobs {
	return &runningJobs{
		mux:   sync.Mutex{},
		items: make(map[string]*module.Job),
	}
}

func newRetryingTasksCache() *retryingTasks {
	return &retryingTasks{
		items: make(map[string]*retryTask),
	}
}

type (
	discoveredConfigs struct {
		// [Source][Hash]
		items map[string]map[uint64]confgroup.Config
	}

	seenConfigs struct {
		// [cfg.UID()]
		items map[string]*seenConfig
	}
	exposedConfigs struct {
		// [cfg.FullName()]
		items map[string]*seenConfig
	}
	seenConfig struct {
		cfg    confgroup.Config
		status dyncfgStatus
	}

	runningJobs struct {
		mux sync.Mutex
		// [cfg.FullName()]
		items map[string]*module.Job
	}

	retryingTasks struct {
		// [cfg.UID()]
		items map[string]*retryTask
	}
	retryTask struct {
		cancel context.CancelFunc
	}
)

func (c *discoveredConfigs) add(group *confgroup.Group) (added, removed []confgroup.Config) {
	cfgs, ok := c.items[group.Source]
	if !ok {
		if len(group.Configs) == 0 {
			return nil, nil
		}
		cfgs = make(map[uint64]confgroup.Config)
		c.items[group.Source] = cfgs
	}

	seen := make(map[uint64]bool)

	for _, cfg := range group.Configs {
		hash := cfg.Hash()
		seen[hash] = true

		if _, ok := cfgs[hash]; ok {
			continue
		}

		cfgs[hash] = cfg
		added = append(added, cfg)
	}

	for hash, cfg := range cfgs {
		if !seen[hash] {
			delete(cfgs, hash)
			removed = append(removed, cfg)
		}
	}

	if len(cfgs) == 0 {
		delete(c.items, group.Source)
	}

	return added, removed
}

func (c *seenConfigs) add(sj *seenConfig) {
	c.items[sj.cfg.UID()] = sj
}
func (c *seenConfigs) remove(cfg confgroup.Config) {
	delete(c.items, cfg.UID())
}
func (c *seenConfigs) lookup(cfg confgroup.Config) (*seenConfig, bool) {
	v, ok := c.items[cfg.UID()]
	return v, ok
}

func (c *exposedConfigs) add(sj *seenConfig) {
	c.items[sj.cfg.FullName()] = sj
}
func (c *exposedConfigs) remove(cfg confgroup.Config) {
	delete(c.items, cfg.FullName())
}
func (c *exposedConfigs) lookup(cfg confgroup.Config) (*seenConfig, bool) {
	v, ok := c.items[cfg.FullName()]
	return v, ok
}

func (c *exposedConfigs) lookupByName(module, job string) (*seenConfig, bool) {
	key := module + "_" + job
	if module == job {
		key = job
	}
	v, ok := c.items[key]
	return v, ok
}

func (c *runningJobs) lock() {
	c.mux.Lock()
}
func (c *runningJobs) unlock() {
	c.mux.Unlock()
}
func (c *runningJobs) add(fullName string, job *module.Job) {
	c.items[fullName] = job
}
func (c *runningJobs) remove(fullName string) {
	delete(c.items, fullName)
}
func (c *runningJobs) lookup(fullName string) (*module.Job, bool) {
	j, ok := c.items[fullName]
	return j, ok
}
func (c *runningJobs) forEach(fn func(fullName string, job *module.Job)) {
	for k, j := range c.items {
		fn(k, j)
	}
}

func (c *retryingTasks) add(cfg confgroup.Config, retry *retryTask) {
	c.items[cfg.UID()] = retry
}
func (c *retryingTasks) remove(cfg confgroup.Config) {
	if v, ok := c.lookup(cfg); ok {
		v.cancel()
	}
	delete(c.items, cfg.UID())
}
func (c *retryingTasks) lookup(cfg confgroup.Config) (*retryTask, bool) {
	v, ok := c.items[cfg.UID()]
	return v, ok
}
