stodb

var (
	CfgNodeId              = configAccessor("nodeId")
	CfgTheMovieDbApikey    = configAccessor(stoservertypes.CfgTheMovieDbApikey)
	CfgIgdbApikey          = configAccessor(stoservertypes.CfgIgdbApikey)
	CfgFuseServerBaseUrl   = configAccessor(stoservertypes.CfgFuseServerBaseUrl)
	CfgNetworkShareBaseUrl = configAccessor(stoservertypes.CfgNetworkShareBaseUrl)
	CfgUbackupConfig       = configAccessor(stoservertypes.CfgUbackupConfig)
	CfgUpdateStatusAt      = configAccessor(stoservertypes.CfgUpdateStatusAt)
	CfgNodeTlsCertKey      = configAccessor(stoservertypes.CfgNodeTlsCertKey)
	CfgGrafanaUrl          = configAccessor(stoservertypes.CfgGrafanaUrl)
	CfgMediascannerState   = configAccessor(stoservertypes.CfgMediascannerState)
)

var (
	StartFromFirst = blorm.StartFromFirst
	StopIteration  = blorm.StopIteration
)

var BlobRepository = register("Blob", blorm.NewSimpleRepo(
	"blobs",
	func() interface{} { return &stotypes.Blob{} },
	func(record interface{}) []byte { return record.(*stotypes.Blob).Ref }))

var BlobsPendingReplicationByVolumeIndex = blorm.NewValueIndex("repl_pend", BlobRepository, func(record interface{}, index func(val []byte)) {
	blob := record.(*stotypes.Blob)

	for _, volId := range blob.VolumesPendingReplication {
		index([]byte(fmt.Sprintf("%d", volId)))
	}
})

var ClientRepository = register("Client", blorm.NewSimpleRepo(
	"clients",
	func() interface{} { return &stotypes.Client{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.Client).ID) }))

var CollectionRepository = register("Collection", blorm.NewSimpleRepo(
	"collections",
	func() interface{} { return &stotypes.Collection{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.Collection).ID) }))

var CollectionsByDataEncryptionKeyIndex = blorm.NewValueIndex("dek", CollectionRepository, func(record interface{}, index func(val []byte)) {
	coll := record.(*stotypes.Collection)

	for _, dekEnvelopes := range coll.EncryptionKeys {
		index([]byte(dekEnvelopes.KeyId))
	}
})

var CollectionsByDirectoryIndex = blorm.NewValueIndex("directory", CollectionRepository, func(record interface{}, index func(val []byte)) {
	coll := record.(*stotypes.Collection)

	index([]byte(coll.Directory))
})

var CollectionsGlobalVersionIndex = blorm.NewRangeIndex("globalversion", CollectionRepository, func(record interface{}, index func(sortKey []byte)) {
	coll := record.(*stotypes.Collection)

	globalVersion := make([]byte, 8)
	binary.BigEndian.PutUint64(globalVersion, coll.GlobalVersion)

	index(globalVersion)
})

var DirectoryRepository = register("Directory", blorm.NewSimpleRepo(
	"directories",
	func() interface{} { return &stotypes.Directory{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.Directory).ID) }))

var IntegrityVerificationJobRepository = register("IntegrityVerificationJob", blorm.NewSimpleRepo(
	"ivjobs",
	func() interface{} { return &stotypes.IntegrityVerificationJob{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.IntegrityVerificationJob).ID) }))

var KeyEncryptionKeyRepository = register("KeyEncryptionKey", blorm.NewSimpleRepo(
	"keyencryptionkeys",
	func() interface{} { return &stotypes.KeyEncryptionKey{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.KeyEncryptionKey).ID) }))

var NodeRepository = register("Node", blorm.NewSimpleRepo(
	"nodes",
	func() interface{} { return &stotypes.Node{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.Node).ID) }))

var ReplicationPolicyRepository = register("ReplicationPolicy", blorm.NewSimpleRepo(
	"replicationpolicies",
	func() interface{} { return &stotypes.ReplicationPolicy{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.ReplicationPolicy).ID) }))

var RepoByRecordType = map[string]blorm.Repository{}

var ScheduledJobRepository = register("ScheduledJob", blorm.NewSimpleRepo(
	"scheduledjobs",
	func() interface{} { return &stotypes.ScheduledJob{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.ScheduledJob).ID) }))

var SubdirectoriesIndex = blorm.NewValueIndex("parent", DirectoryRepository, func(record interface{}, index func(val []byte)) {
	dir := record.(*stotypes.Directory)

	if dir.Parent != "" {
		index([]byte(dir.Parent))
	}
})

var VolumeMountRepository = register("VolumeMount", blorm.NewSimpleRepo(
	"volumemounts",
	func() interface{} { return &stotypes.VolumeMount{} },
	func(record interface{}) []byte { return []byte(record.(*stotypes.VolumeMount).ID) }))

var VolumeRepository = register("Volume", blorm.NewSimpleRepo(
	"volumes",
	func() interface{} { return &stotypes.Volume{} },
	func(record interface{}) []byte {
		return volumeIntIdToBytes(record.(*stotypes.Volume).ID)
	}))