btree

type Btree[TK Comparable, TV any] struct {
	Store Store
	// contains filtered or unexported fields
}

type BtreeInterface[TK Comparable, TV any] interface {
	// Add adds an item to the b-tree and does not check for duplicates.
	Add(key TK, value TV) (bool, error)
	// AddIfNotExist adds an item if there is no item matching the key yet.
	// Otherwise, it will do nothing and return false, for not adding the item.
	// This is useful for cases one wants to add an item without creating a duplicate entry.
	AddIfNotExist(key TK, value TV) (bool, error)
	// FindOne will search Btree for an item with a given key. Return true if found,
	// otherwise false. firstItemWithKey is useful when there are items with same key.
	// true will position pointer to the first item with the given key,
	// according to key ordering sequence.
	FindOne(key TK, firstItemWithKey bool) (bool, error)
	// GetCurrentKey returns the current item's key.
	GetCurrentKey() TK
	// GetCurrentValue returns the current item's value.
	GetCurrentValue() (TV, error)
	// Update finds the item with key and update its value to the value argument.
	Update(key TK, value TV) (bool, error)
	// UpdateCurrentItem will update the Value of the current item.
	// Key is read-only, thus, no argument for the key.
	UpdateCurrentItem(newValue TV) (bool, error)
	// Remove will find the item with a given key then remove that item.
	Remove(key TK) (bool, error)
	// RemoveCurrentItem will remove the current key/value pair from the store.
	RemoveCurrentItem() (bool, error)

	// Cursor like "move" functions. Use the CurrentKey/CurrentValue to retrieve the
	// "current item" details(key &/or value).
	MoveToFirst() (bool, error)
	MoveToLast() (bool, error)
	MoveToNext() (bool, error)
	MoveToPrevious() (bool, error)
	// IsValueDataInNodeSegment is true if "Value" data is stored in the B-Tree node's segment.
	// Otherwise is false.
	IsValueDataInNodeSegment() bool

	// IsUnique returns true if B-Tree is specified to store items with Unique keys, otherwise false.
	// Specifying uniqueness base on key makes the B-Tree permanently set. If you want just a temporary
	// unique check during Add of an item, then you can use AddIfNotExist method for that.
	IsUnique() bool
}

type Comparable interface {
	cmp.Ordered | *Comparer | any
}

type Comparer interface {
	// Implement Compare to compare this object with the 'other' object.
	// Returns -1 (this object < other), 0 (this object == other), 1 (this object > other)
	Compare(other interface{}) int
}

type EntityType uint

type Handle struct {
	LogicalId   UUID
	PhysicalIdA UUID
	PhysicalIdB UUID
	IsActiveIdB bool
	Version     int
	IsDeleted   bool
}

type Item[TK Comparable, TV any] struct {
	// Key is the key part in key/value pair.
	Key TK
	// Value is saved nil if data is to be persisted in the "data segment"(& ValueId set to a valid UUID),
	// otherwise it should point to the actual data and persisted in B-Tree Node segment together with the Key.
	Value *TV
	// ValueLogicalId should be a valid (logical) Id of the data if it is saved in the "data segment",
	// otherwise this should be nil(unused).
	ValueLogicalId UUID
	Version        int
	// contains filtered or unexported fields
}

type Node[TK Comparable, TV any] struct {
	Id        UUID
	ParentId  UUID
	Slots     []*Item[TK, TV]
	Count     int
	Version   int
	IsDeleted bool
	// contains filtered or unexported fields
}

type NodeDataBlocks struct {
	Id               Handle
	SlotDataBlock    []byte
	SlotDataBlockIds []UUID
	Children         []UUID

	Version   int
	IsDeleted bool
	// contains filtered or unexported fields
}

type NodeRepository[TK Comparable, TV any] interface {
	Get(nodeId UUID) (*Node[TK, TV], error)
	Upsert(*Node[TK, TV]) error
	Remove(nodeId UUID) error
}

type Recyclable struct {
	ObjectType int
	ObjectId   UUID
	LockDate   int64
	IsDeleted  bool
}

type RecyclerRepository interface {
	Get(itemCount int, objectType int) []Recyclable
	Add(recyclables []Recyclable) error
	Remove(items []Recyclable) error
}

type SlotValue struct {
	Id        Handle
	Value     []byte
	IsDeleted bool
}

type SlotValueDataBlocks struct {
	Id                Handle
	Value             []byte
	ValueDataBlockIds []UUID
	IsDeleted         bool
}

type Store struct {
	// Name of this (B-Tree store).
	Name string
	// Count of items that can be stored on a given node.
	SlotLength int
	// IsUnique tells whether key/value pair (items) of this tree should be unique on key.
	IsUnique  bool
	KeyInfo   string
	ValueInfo string
	// RootNodeId is the root node's Id.
	RootNodeId UUID
	// Total count of items stored.
	Count int64
	// Version number.
	Version int
	// Is marked deleted or not.
	IsDeleted bool
	// IsValueDataInNodeSegment is true if "Value" data is stored in the B-Tree node's data segment.
	// Otherwise is false.
	IsValueDataInNodeSegment bool
}

type StoreInterface[TK Comparable, TV any] struct {
	// StoreRepository is used to manage/access stores.
	StoreRepository StoreRepository
	// NodeRepository is used to manage/access B-Tree nodes.
	NodeRepository NodeRepository[TK, TV]
	// VirtualIdRepository is used to manage/access all objects keyed off of their virtual Ids (UUIDs).
	VirtualIdRepository VirtualIdRepository
	// RecyclerRepository is used to manage/access all deleted objects' "data blocks".
	RecyclerRepository RecyclerRepository
	// TransactionRepository is used to manage a transaction.
	TransactionRepository TransactionRepository
	// Transaction object if there is one.
	Transaction Transaction
}

type StoreRepository interface {
	Get(name string) (Store, error)
	Add(Store) error
	Remove(name string) error
}

type Transaction interface {
	Begin() error
	Commit() error
	Rollback() error
	HasBegun() bool
}

type TransactionActionType uint

type TransactionEntry struct {
	EntityLogicalId UUID
	EntityType      EntityType
	Sequence        int
	Action          TransactionActionType
	IsDeleted       bool
}

type TransactionRepository interface {
	Get(transactionId UUID) ([]TransactionEntry, error)
	GetByStore(transactionId UUID, storeName string) ([]TransactionEntry, error)
	Add([]TransactionEntry) error
	MarkDone([]TransactionEntry) error
}

type UUID uuid.UUID

type VirtualIdRepository interface {
	Get(lid UUID) (Handle, error)
	Add(Handle) error
	Update(Handle) error
	Remove(lid UUID) error
}