gotcore

type Annotation struct {
	Key   string `json:"k"`
	Value string `json:"v"`
}

type ChunkingConfig struct {
	CD  *Chunking_CDConfig `json:"cd,omitempty"`
	Max *Chunking_Fixed    `json:"fixed,omitempty"`
}

type Chunking_CDConfig struct {
	MeanSize int `json:"mean_size"`
	MaxSize  int `json:"max_size"`
}

type Chunking_Fixed struct {
	Max uint32 `json:"max"`
	Min uint32 `json:"min"`
}

type DSConfig struct {
	// Salt is a 32-byte salt used to derive the cryptographic keys for the mark.
	Salt Salt `json:"salt"`
	// GotFS contains all configuration for GotFS
	GotFS FSConfig `json:"fs"`
}

type ErrInvalidName struct {
	Name   string
	Reason string
}

type ErrRefIntegrity struct {
	Ref   gdat.Ref
	Store string
}

type FSConfig struct {
	Data     ChunkingConfig    `json:"data_chunking"`
	Metadata Chunking_CDConfig `json:"metadata_chunking"`
}

type FSMach = gotfs.Machine

type Info struct {
	// Config holds the all the datastructure parameters
	Config DSConfig `json:"config"`
	// Annotations are arbitrary metadata associated with the mark.
	Annotations []Annotation `json:"annotations"`

	// CreatedAt is the time the mark was created.
	CreatedAt tai64.TAI64 `json:"created_at"`
}

type MarkTx struct {
	// contains filtered or unexported fields
}

type Metadata struct {
	Config      DSConfig     `json:"config"`
	Annotations []Annotation `json:"annotations"`
}

type ModifyCtx struct {
	VC     *VCMach
	FS     *FSMach
	Stores [3]stores.RW
	Root   *Snap
}

type Payload struct {
	Root gotfs.Root
	Aux  []byte
}

type Salt [32]byte

type Snap = gotvc.Vertex[Payload]

type SnapExpr interface {
	GetSpace() string
	// Resolve returns a valid Ref, which points to a Snapshot.
	Resolve(ctx context.Context, stx SpaceTx) (*gdat.Ref, error)
	// contains filtered or unexported methods
}

type SnapExpr_Exact struct {
	Space string
	Ref   gdat.Ref
}

type SnapExpr_Mark struct {
	Space string
	Name  string
}

type SnapExpr_Offset struct {
	X      SnapExpr
	Offset uint
}

type SnapInfo struct {
	AuthoredAt tai64.TAI64  `json:"authored_at"`
	Authors    []inet256.ID `json:"authors"`

	Message string `json:"message"`
}

type Space interface {
	// Do calls fn to perform a transaction.
	Do(ctx context.Context, modify bool, fn func(SpaceTx) error) error
}

type SpaceTx interface {
	// Create creates a new Mark at name in the Space.
	// The mark will have md for initial metadata.
	// An error is returned if the name already exists.
	Create(ctx context.Context, name string, md Metadata) (*Info, error)
	// Inspect returns all the info for a Mark
	Inspect(ctx context.Context, name string) (*Info, error)
	// SetMetadata sets the metadata for the Mark at name to md
	SetMetadata(ctx context.Context, name string, md Metadata) error
	// Delete deletes a Mark and all of it's metadata, the Snapshot is not removed.
	Delete(ctx context.Context, name string) error
	// All iterates over all the mark names.
	All(context.Context) iter.Seq2[string, error]

	// Store returns the space's underlying stores
	// These can all be the same store, but each will be passed to different systems.
	// 0: GotFS data stream
	// 1: GotFS metadata
	// 2: GotVC
	Stores() [3]stores.RW
	// SetTarget changes the mark so it points to a different snapshot
	SetTarget(ctx context.Context, name string, ref gdat.Ref) error
	// GetTarget retrieves the Snapshot referenced by gdat.Ref
	GetTarget(ctx context.Context, name string, dst *gdat.Ref) (bool, error)
}

type Span struct {
	Begin string
	End   string
}

type SyncSpacesTask struct {
	// Src is the space to read from.
	Src Space
	// Dst is the name ofthe space to write to.
	Dst Space

	// Filter is applied to src to determine what to copy.
	// If nil, then all marks are copied.
	Filter func(string) bool
	// MapName is applied to go from names in the Src space, to name in the Dst space.
	MapName func(string) string
}

type VCMach = gotvc.Machine[Payload]

type ViewCtx struct {
	VC     *VCMach
	FS     *FSMach
	Stores [3]stores.Reading
	Target gdat.Ref
	Root   *Snap
}