package updater

// import (
// 	"errors"
// 	"fmt"
// 	"os"
// 	"path/filepath"
// 	"runtime"
// 	"strings"
// 	"sync"

// 	"github.com/safing/portmaster/base/log"
// 	"github.com/safing/portmaster/base/utils"
// )

// const (
// 	onWindows = runtime.GOOS == "windows"
// )

// ResourceRegistry is a registry for managing update resources.
// type ResourceRegistry struct {
// 	sync.RWMutex

// 	Name       string
// 	storageDir *utils.DirStructure
// 	tmpDir     *utils.DirStructure
// 	indexes    []*Index
// 	state      *RegistryState

// 	resources        map[string]*Resource
// 	UpdateURLs       []string
// 	UserAgent        string
// 	MandatoryUpdates []string
// 	AutoUnpack       []string

// 	// Verification holds a map of VerificationOptions assigned to their
// 	// applicable identifier path prefix.
// 	// Use an empty string to denote the default.
// 	// Use empty options to disable verification for a path prefix.
// 	Verification map[string]*VerificationOptions

// 	// UsePreReleases signifies that pre-releases should be used when selecting a
// 	// version. Even if false, a pre-release version will still be used if it is
// 	// defined as the current version by an index.
// 	UsePreReleases bool

// 	// DevMode specifies if a local 0.0.0 version should be always chosen, when available.
// 	DevMode bool

// 	// Online specifies if resources may be downloaded if not available locally.
// 	Online bool

// 	// StateNotifyFunc may be set to receive any changes to the registry state.
// 	// The specified function may lock the state, but may not block or take a
// 	// lot of time.
// 	StateNotifyFunc func(*RegistryState)
// }

// // AddIndex adds a new index to the resource registry.
// // The order is important, as indexes added later will override the current
// // release from earlier indexes.
// func (reg *ResourceRegistry) AddIndex(idx Index) {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	// Get channel name from path.
// 	idx.Channel = strings.TrimSuffix(
// 		filepath.Base(idx.Path), filepath.Ext(idx.Path),
// 	)

// 	reg.indexes = append(reg.indexes, &idx)
// }

// // PreInitUpdateState sets the initial update state of the registry before initialization.
// func (reg *ResourceRegistry) PreInitUpdateState(s UpdateState) error {
// 	if reg.state != nil {
// 		return errors.New("registry already initialized")
// 	}

// 	reg.state = &RegistryState{
// 		Updates: s,
// 	}
// 	return nil
// }

// // Initialize initializes a raw registry struct and makes it ready for usage.
// func (reg *ResourceRegistry) Initialize(storageDir *utils.DirStructure) error {
// 	// check if storage dir is available
// 	err := storageDir.Ensure()
// 	if err != nil {
// 		return err
// 	}

// 	// set default name
// 	if reg.Name == "" {
// 		reg.Name = "updater"
// 	}

// 	// initialize private attributes
// 	reg.storageDir = storageDir
// 	reg.tmpDir = storageDir.ChildDir("tmp", 0o0700)
// 	reg.resources = make(map[string]*Resource)
// 	if reg.state == nil {
// 		reg.state = &RegistryState{}
// 	}
// 	reg.state.ID = StateReady
// 	reg.state.reg = reg

// 	// remove tmp dir to delete old entries
// 	err = reg.Cleanup()
// 	if err != nil {
// 		log.Warningf("%s: failed to remove tmp dir: %s", reg.Name, err)
// 	}

// 	// (re-)create tmp dir
// 	err = reg.tmpDir.Ensure()
// 	if err != nil {
// 		log.Warningf("%s: failed to create tmp dir: %s", reg.Name, err)
// 	}

// 	// Check verification options.
// 	if reg.Verification != nil {
// 		for prefix, opts := range reg.Verification {
// 			// Check if verification is disable for this prefix.
// 			if opts == nil {
// 				continue
// 			}

// 			// If enabled, a trust store is required.
// 			if opts.TrustStore == nil {
// 				return fmt.Errorf("verification enabled for prefix %q, but no trust store configured", prefix)
// 			}

// 			// DownloadPolicy must be equal or stricter than DiskLoadPolicy.
// 			if opts.DiskLoadPolicy < opts.DownloadPolicy {
// 				return errors.New("verification download policy must be equal or stricter than the disk load policy")
// 			}

// 			// Warn if all policies are disabled.
// 			if opts.DownloadPolicy == SignaturePolicyDisable &&
// 				opts.DiskLoadPolicy == SignaturePolicyDisable {
// 				log.Warningf("%s: verification enabled for prefix %q, but all policies set to disable", reg.Name, prefix)
// 			}
// 		}
// 	}

// 	return nil
// }

// // StorageDir returns the main storage dir of the resource registry.
// func (reg *ResourceRegistry) StorageDir() *utils.DirStructure {
// 	return reg.storageDir
// }

// // TmpDir returns the temporary working dir of the resource registry.
// func (reg *ResourceRegistry) TmpDir() *utils.DirStructure {
// 	return reg.tmpDir
// }

// // SetDevMode sets the development mode flag.
// func (reg *ResourceRegistry) SetDevMode(on bool) {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	reg.DevMode = on
// }

// // SetUsePreReleases sets the UsePreReleases flag.
// func (reg *ResourceRegistry) SetUsePreReleases(yes bool) {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	reg.UsePreReleases = yes
// }

// // AddResource adds a resource to the registry. Does _not_ select new version.
// func (reg *ResourceRegistry) AddResource(identifier, version string, index *Index, available, currentRelease, preRelease bool) error {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	err := reg.addResource(identifier, version, index, available, currentRelease, preRelease)
// 	return err
// }

// func (reg *ResourceRegistry) addResource(identifier, version string, index *Index, available, currentRelease, preRelease bool) error {
// 	res, ok := reg.resources[identifier]
// 	if !ok {
// 		res = reg.newResource(identifier)
// 		reg.resources[identifier] = res
// 	}
// 	res.Index = index

// 	return res.AddVersion(version, available, currentRelease, preRelease)
// }

// // AddResources adds resources to the registry. Errors are logged, the last one is returned. Despite errors, non-failing resources are still added. Does _not_ select new versions.
// func (reg *ResourceRegistry) AddResources(versions map[string]string, index *Index, available, currentRelease, preRelease bool) error {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	// add versions and their flags to registry
// 	var lastError error
// 	for identifier, version := range versions {
// 		lastError = reg.addResource(identifier, version, index, available, currentRelease, preRelease)
// 		if lastError != nil {
// 			log.Warningf("%s: failed to add resource %s: %s", reg.Name, identifier, lastError)
// 		}
// 	}

// 	return lastError
// }

// // SelectVersions selects new resource versions depending on the current registry state.
// func (reg *ResourceRegistry) SelectVersions() {
// 	reg.RLock()
// 	defer reg.RUnlock()

// 	for _, res := range reg.resources {
// 		res.Lock()
// 		res.selectVersion()
// 		res.Unlock()
// 	}
// }

// // GetSelectedVersions returns a list of the currently selected versions.
// func (reg *ResourceRegistry) GetSelectedVersions() (versions map[string]string) {
// 	reg.RLock()
// 	defer reg.RUnlock()

// 	for _, res := range reg.resources {
// 		res.Lock()
// 		versions[res.Identifier] = res.SelectedVersion.VersionNumber
// 		res.Unlock()
// 	}

// 	return
// }

// // Purge deletes old updates, retaining a certain amount, specified by the keep
// // parameter. Will at least keep 2 updates per resource.
// func (reg *ResourceRegistry) Purge(keep int) {
// 	reg.RLock()
// 	defer reg.RUnlock()

// 	for _, res := range reg.resources {
// 		res.Purge(keep)
// 	}
// }

// // ResetResources removes all resources from the registry.
// func (reg *ResourceRegistry) ResetResources() {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	reg.resources = make(map[string]*Resource)
// }

// // ResetIndexes removes all indexes from the registry.
// func (reg *ResourceRegistry) ResetIndexes() {
// 	reg.Lock()
// 	defer reg.Unlock()

// 	reg.indexes = make([]*Index, 0, len(reg.indexes))
// }

// // Cleanup removes temporary files.
// func (reg *ResourceRegistry) Cleanup() error {
// 	// delete download tmp dir
// 	return os.RemoveAll(reg.tmpDir.Path)
// }