store

type AlgorithmManager interface {
	Find(name string) (git.Algorithm, error)

	FindCompression(name string) (git.Compression, error)

	FindDigest(name string) (git.Digest, error)

	FindPathMapping(name string) (git.PathMapping, error)
}

type Binding interface {
	SetLib(lib Lib) error
	GetLib() (Lib, error)
}

type Config interface {
	NodeLocation
	RepositoryConfig
	Save() error
	Load() error
}

type ConfigChain interface {
	Config() Config

	Mix() ConfigChain

	Parent() ConfigChain

	Scope() ConfigScope

	FindByScope(scope ConfigScope) ConfigChain

	Load() error
}

type ConfigChainFactory interface {
	Create(p *ConfigChainParams) ConfigChain
	Root() ConfigChain
}

type ConfigChainParams struct {
	File       afs.Path
	Parent     ConfigChain
	Scope      ConfigScope
	Required   bool
	IgnoreCase bool
}

type ConfigScope int

type Context struct {
	Lib Lib

	CLI cli.CLI

	Algorithms []git.AlgorithmRegistry

	Services []ServiceRegistry

	CoreConfigurers []CoreConfigurer

	Connectors []pktline.Connector

	FS afs.FS

	Locator RepositoryLocator

	Finder RepositoryFinder

	ServiceManager ServiceManager

	RepositoryLoader RepositoryLoader

	ConfigChainFactory ConfigChainFactory

	AlgorithmManager AlgorithmManager

	ConnectorManager pktline.ConnectorManager // the main connector
}

type ContextConfiguration struct {
	Factory            ContextFactory
	ContextConfigurers []ContextConfigurer
	CoreConfigurers    []CoreConfigurer

	UseCLI    bool
	CLIConfig *cli.Configuration
	CLI       cli.CLI
}

type ContextConfigurer interface {
	Configure(c *Context) error
}

type ContextFactory interface {
	Create(cfg *ContextConfiguration) (*Context, error)

	// get info about the factory
	String() string
}

type Core struct {
	WD afs.Path // 工作目录

	Context *Context

	Config ConfigChain // 配置链：repo -> user -> system

	Head HEAD

	Index Index

	Layout RepositoryLayout

	Objects Objects

	Refs Refs

	Repository RepositoryProfile

	Workspace Workspace // aka the default worktree

	Worktrees Worktrees

	Submodules Submodules

	SessionFactory SessionFactory

	Digest      git.Digest      // default="SHA-1"
	Compression git.Compression // default="DEFLATE"
	PathMapping git.PathMapping // default="xx/xxxx"
}

type CoreConfigurer interface {
	Configure(c *Core) error
}

type Entity interface {
	OpenReader() (io.ReadCloser, error)
}

type FileReaderPool interface {
	io.Closer

	OpenReader(file afs.Path, op *afs.Options) (io.ReadSeekCloser, error)
}

type HEAD interface {
	NodeLocation

	GetValue(s Session) (git.ReferenceName, error)
}

type ImportPackParams struct {
	ID        git.PackID
	PackFile  afs.Path
	IdxFile   afs.Path
	MoveFiles bool
}

type ImportPackResult struct {
	Params *ImportPackParams
	ID     git.PackID
	Pack   Pack
}

type Index interface {
	NodeLocation
}

type InfoFolder interface {
	Path() afs.Path
}

type LayoutBuilder struct {
	WD     afs.Path
	DotGit afs.Path

	Repository afs.Path // the repository core dir
	Workspace  afs.Path

	SubmodulePoint afs.Path
	WorktreePoint  afs.Path
	CorePoint      afs.Path

	Config  afs.Path
	HEAD    afs.Path
	Index   afs.Path
	Objects afs.Path
	Refs    afs.Path
}

type Lib interface {
	FS() afs.FS

	GetCLI(required bool) cli.CLI

	RepositoryLoader() RepositoryLoader

	RepositoryFinder() RepositoryFinder

	RepositoryLocator() RepositoryLocator

	InstructionServiceManager() ServiceManager

	Connectors() pktline.ConnectorManager

	// 把这个 Lib 绑定到指定的 Context
	Bind(cc context.Context) context.Context
}

type LibAgent interface {
	GetLib() (Lib, error)
}

type Meta struct {
	Context context.Context
	Name    string   // the command name
	WD      afs.Path // Working Directory
}

type Node struct {
	Name string
	Path afs.FS
	Type NodeType
}

type NodeLocation interface {
	Path() afs.Path
	NodeType() NodeType
}

type NodeType string

type Object git.Object

type Objects interface {
	Path() afs.Path

	GetSparseObject(oid git.ObjectID) SparseObject

	GetPack(pid git.PackID) Pack

	ListPacks() []git.PackID

	Info() InfoFolder
}

type Pack interface {
	GetID() git.PackID

	GetDotIdx() afs.Path

	GetDotPack() afs.Path

	GetObject(oid git.ObjectID) PackObject

	Exists() bool
}

type PackBuilder interface {
	io.Closer

	WriteObject(o *Object, data io.Reader) (*Object, error)
}

type PackFile interface {
	ReadPackObject(item *git.PackIndexItem) (io.ReadCloser, *git.Object, error)
}

type PackIndex interface {
	Count() int64

	Get(index int64) (*git.PackIndexItem, error)

	List(index, limit int64) ([]*git.PackIndexItem, error)

	Find(id git.ObjectID) (*git.PackIndexItem, error)
}

type PackObject interface {
	GetID() git.ObjectID
	Container() Pack
}

type PackReadCloser interface {
	io.Closer
	GetIndex() PackIndex
	GetPack() PackFile
}

type Packs interface {
	FindPackObject(oid git.ObjectID) (PackObject, error)

	FindPackObjectInPack(pid git.PackID, oid git.ObjectID) (PackObject, error)

	ReadPackObject(o PackObject) (*git.Object, io.ReadCloser, error)

	CheckPack(pid git.PackID, flags pack.CheckFlag) error

	ListPacks() ([]git.PackID, error)

	NewPackBuilder() PackBuilder

	ImportPack(p *ImportPackParams) (*ImportPackResult, error)
}

type Ref interface {
	Path() afs.Path

	Name() git.ReferenceName

	Exists() bool

	GetValue(s Session) (git.ObjectID, error)
}

type Refs interface {
	Path() afs.Path

	GetRef(name git.ReferenceName) Ref

	List() []git.ReferenceName
}

type Repository interface {
	RepositoryProfile
}

type RepositoryConfig interface {
	Import(src map[string]string)
	Export() map[string]string
	GetProperty(name string) string
	SetProperty(name, value string)
	Clear()
}

type RepositoryFinder interface {
	Find(pwd afs.Path) ([]afs.Path, error)
}

type RepositoryLayout interface {

	// 取工作目录
	WD() afs.Path

	Workspace() afs.Path
	DotGit() afs.Path
	Repository() afs.Path
	Config() afs.Path
	Index() afs.Path
	HEAD() afs.Path
	Objects() afs.Path
	Refs() afs.Path

	IsBare() bool
	IsSubmodule() bool
	IsWorktree() bool
}

type RepositoryLoader interface {
	Load(l RepositoryLayout) (Repository, error)
	LoadWithPath(path afs.Path) (Repository, error)
}

type RepositoryLocator interface {
	Locate(pwd afs.Path) (RepositoryLayout, error)
}

type RepositoryProfile interface {
	Layout() RepositoryLayout

	Config() ConfigChain

	HEAD() HEAD

	Index() Index

	Refs() Refs

	Objects() Objects

	Worktrees() Worktrees

	Submodules() Submodules

	Digest() git.Digest           // default="SHA-1"
	Compression() git.Compression // default="DEFLATE"
	PathMapping() git.PathMapping // default="xx/xxxx"

	OpenSession() (Session, error)
}

type Service interface {
}

type ServiceManager interface {
	Find(name string) (Service, error)
}

type ServiceRegistration struct {
	Name    string
	Service Service
}

type ServiceRegistry interface {
	ListRegistrations() []*ServiceRegistration
}

type Session interface {
	io.Closer

	// 取仓库接口
	GetRepository() Repository

	// 根据名称，取指定的组件
	GetComponent(name string) (any, error)

	// 取工作目录
	GetWD() afs.Path

	// 取仓库布局
	GetLayout() RepositoryLayout

	// 新建临时文件
	NewTemporaryFile(dir afs.Path) afs.Path

	NewTemporaryBuffer(dir afs.Path) TemporaryBuffer

	NewReaderPool(size int) afs.ReaderPool

	GetReaderPool() afs.ReaderPool

	GetObjectContext() *objects.Context

	// objects
	ReadObject(id git.ObjectID) (*git.Object, io.ReadCloser, error)

	WriteObject(o *git.Object, data io.Reader) (*git.Object, error)

	GetSparseObjects() SparseObjects

	GetPacks() Packs

	LoadText(id git.ObjectID) (string, *git.Object, error)
	LoadBinary(id git.ObjectID) ([]byte, *git.Object, error)

	// commit, tag, tree
	LoadCommit(id git.ObjectID) (*git.Commit, error)
	LoadTag(id git.ObjectID) (*git.Tag, error)
	LoadTree(id git.ObjectID) (*git.Tree, error)

	// refs
	LoadRef(r Ref) (*git.Ref, error)
	SaveRef(r *git.Ref) error

	// HEAD
	LoadHEAD(head HEAD) (*git.HEAD, error)
	SaveHEAD(h *git.HEAD) error
}

type SessionFactory interface {
	OpenSession(repo Repository) (Session, error)
}

type SparseObject interface {
	Path() afs.Path

	GetID() git.ObjectID

	Exists() bool
}

type SparseObjects interface {
	ReadSparseObject(o SparseObject) (*git.Object, io.ReadCloser, error)
	ReadSparseObjectRaw(o SparseObject) (io.ReadCloser, error)
	WriteSparseObject(o *git.Object, data io.Reader) (*git.Object, error)
	WriteSparseObjectRaw(o *git.Object, data io.Reader) (*git.Object, error)
}

type Submodule interface {
	Name() string
	URL() string
	Path() string
	IsActive() bool

	Workspace() Workspace
	Exists() bool
}

type Submodules interface {
	Get(name string) Submodule
	List() []Submodule
}

type Task interface {
	GetMeta() *Meta
	Run() error
}

type TemporaryBuffer interface {
	io.Closer
	io.Writer

	GetTemporaryFile() afs.Path

	GetFlushSize() int

	SetFlushSize(size int)

	SaveToFile(dst afs.Path) error
}

type Workspace interface {

	// alias of WorkingDirectory
	Path() afs.Path

	// return the working directory
	WorkingDirectory() afs.Path

	// return the '.git' file or directory
	DotGit() afs.Path
}

type Worktree interface {
	Name() string
	Workspace() Workspace
	Exists() bool
}

type Worktrees interface {
	Get(name string) Worktree
	List() []Worktree
}