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 Commit = gotvc.Vertex[Payload]

type CommitExpr interface {
	GetSpace() string
	// Resolve returns a valid Ref, which points to a Commit.
	// Resolve returns the zero valued Ref when a mark does not have a Ref set.
	Resolve(ctx context.Context, stx SpaceTx) (gdat.Ref, error)
	// contains filtered or unexported methods
}

type CommitExpr_Exact struct {
	Space string
	Ref   gdat.Ref
}

type CommitExpr_Mark struct {
	Space string
	Name  string
}

type CommitExpr_Offset struct {
	X      CommitExpr
	Offset uint
}

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

	Message string `json:"message"`
}

type CommitParams struct {
	Committer   inet256.ID
	CommittedAt tai64.TAI64
	Base        []Commit
	Snap        gotfs.Root
	Notes       CommitNotes
}

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 RW
	Target gdat.Ref
	Root   *Commit
}

type Payload struct {
	// Snap is the commit of the filesystem.
	Snap  gotfs.Root
	Notes []byte
}

type RO struct {
	FS gotfs.RO
	VC stores.RO
}

type RW struct {
	FS gotfs.RW
	VC stores.RW
}

type Salt [32]byte

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 Commit 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() RW
	// SetTarget changes the mark so it points to a different commit
	SetTarget(ctx context.Context, name string, ref gdat.Ref) error
	// GetTarget retrieves the Commit 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 RO
	Target gdat.Ref
	Root   *Commit
}

type WO struct {
	FS gotfs.WO
	VC stores.WO
}