api

type Base interface {
	Ctx() context.Context
	CloseSignal() <-chan error
	Close() error
}

type BookKeeping interface {
	// take a snapshot of all token positions and market into an accounting book
	Snapshot(Treasury) error
	// Profit and Loss for a wallet
	ProfitChild(start time.Time, finish time.Time, valuationMint sgo.PublicKey, childID sgo.PublicKey) (child float64, err error)
	// Profit and Loss for the parent and aggregate the net income from child wallets
	ProfitParent(start time.Time, finish time.Time, valuationMint sgo.PublicKey) (parentOnly float64, overall float64, err error)
}

type Bot struct {
	Hash  sgo.Hash
	SendC chan<- catmsg.FixedPair
	RecvC <-chan catmsg.FixedPair
}

type BotCoder interface {
	// Compile the wasm binary. The startingFiles get copied into the base directory of the coding directory in the container compiling the code.
	Compiler(ctx context.Context, startingFiles fs.FS) (BotCompiler, error)
}

type BotCompiler interface {
	// FileSystem returns a live view onto the coding container's own
	// filesystem -- every Read/Write/Edit/LsInfo/GrepRaw/GlobInfo call
	// reads or mutates that container directly, not any host-side copy,
	// so an LLM editing through it is editing the same files Compile
	// builds from.
	FileSystem(ctx context.Context) (FilesystemWrapper, error)

	// Compile the code
	Compile(ctx context.Context, binaryPath []string) LogResult

	// Lint the code
	Lint(ctx context.Context) LogResult

	// Format the code in place. paths, when non-empty, are crate-relative
	// file paths passed directly to `rustfmt` (not `cargo fmt -- ...`,
	// which does not actually scope to the given paths - see the real
	// implementation's own doc comment) so only those files are
	// reformatted; an empty paths formats the whole crate (plain
	// `cargo fmt`).
	Format(ctx context.Context, paths []string) error

	// Test the code
	Test(ctx context.Context) LogResult

	// WARNING: generic exec
	Exec(ctx context.Context, command string, args []string, mEnv map[string]string) (stdin io.WriteCloser, stdout io.ReadCloser, stderr io.ReadCloser)
}

type BotRuntime interface {
	Status() RuntimeStatusType
	// Deploy uploads the wasm image at pathToWasm and waits for it to
	// complete its handshake (or ctx to end). args becomes the
	// deployed process's own argv on the validator runtime; env is
	// forwarded to it as environment variables -- env["MODE"] in
	// particular selects which behavior the image runs (e.g. "marketwatchv1"),
	// so it must be set for the deployed bot to do anything meaningful.
	Deploy(ctx context.Context, pathToWasm string, args []string, env map[string]string) (Bot, error)
	BotList() []Bot
}

type BotRuntimeManager interface {
	// Connect to a remote Bot runtime
	Connect(ctx context.Context, pipelineID sgo.PublicKey) (BotRuntime, error)
}

type Budget interface {
	ID() sgo.PublicKey
	Pubkey() sgo.PublicKey
	// if the target falls below SolDelta, top up the account
	SetSOL(budget graph.Lamports)
	// send money to a wallet
	Fund(mint sgo.PublicKey, amount uint64)
	// sweep token funds, leave minAmount in account
	Sweep(mint sgo.PublicKey, minAmount uint64)
	// Close all token accounts, close all protocol positions; sweep funds back to parent; Use Jupiter to power sweeps.
	Close() error
	// SetPositionCloser registers the callback Close() invokes first, to
	// unwind whatever protocol-specific positions (lending deposits,
	// perps, LP, etc.) this child wallet holds, before its resulting
	// SOL/SPL token balances get swept back to the parent. The treasury
	// package has no protocol-specific knowledge of its own -- these
	// positions live entirely in each running bot instance's own
	// on-chain state -- so whoever owns that context (typically the
	// brain module driving this child's bot instance) must supply it.
	// Close only sweeps SOL/token balances, skipping this step entirely,
	// if nothing has been registered.
	SetPositionCloser(closer func(ctx context.Context) error)
}

type ChainState interface {
	Base
	// Database accesses the underlying database
	Database() *store.DB
	// Access an account
	Account(sgo.PublicKey) graph.Account
}

type CompileBinary struct {
	Path string
	Data []byte
}

type FileStore interface {
	Read(ctx context.Context, path string) (io.ReadCloser, error)
	Write(ctx context.Context, path string) (io.WriteCloser, error)
}

type FilesystemWrapper interface {
	// List file info in a directory
	LsInfo(ctx context.Context, req *filesystem.LsInfoRequest) ([]filesystem.FileInfo, error)

	// Read file content, supports line offset and limit
	Read(ctx context.Context, req *filesystem.ReadRequest) (*filesystem.FileContent, error)

	// batch write file content
	BatchRead(ctx context.Context, listPath []*ReadHeader) []*io.PipeReader

	// Search for matching content in files
	GrepRaw(ctx context.Context, req *filesystem.GrepRequest) ([]filesystem.GrepMatch, error)

	// Match files by glob pattern
	GlobInfo(ctx context.Context, req *filesystem.GlobInfoRequest) ([]filesystem.FileInfo, error)

	// Write file content
	Write(ctx context.Context, req *filesystem.WriteRequest) error

	// batch write file content
	BatchWrite(ctx context.Context, listWrite []*WriteHeader) error

	// Edit file content (string replacement)
	Edit(ctx context.Context, req *filesystem.EditRequest) error
}

type LogResult struct {
	LogC   <-chan string
	ErrorC <-chan error
	// BinaryC receives one CompileBinary per file named in Compile's own
	// binaryPath argument, as the server streams it back inline with the
	// log output -- nil for Lint/Format/Test, which never produce binary
	// output. Closed once the underlying stream ends, at the same moment
	// ErrorC receives its final value.
	BinaryC <-chan CompileBinary
}

type ReadHeader struct {
	Path   string
	Offset int
	Limit  int
}

type RuntimeStatusType = uint8

type TokenBalance = map[sgo.PublicKey]uint64

type Treasury interface {
	// Parent public key that distributes funds
	Parent() Wallet
	Children() []sgo.PublicKey
	// Child derives a child key; this is for observing the current balances
	Child(childID sgo.PublicKey) Wallet
	// SOLBalance returns the current SOL balance in lamports
	SOLBalance() uint64
	// TokenBalance returns the current balance of tokens
	TokenBalance() map[sgo.PublicKey]uint64
	// manage funds via budget
	Budget(childID sgo.PublicKey) Budget
}

type Valuation struct {
	Valuation float64
	Token     TokenBalance
}

type Wallet interface {
	ID() sgo.PublicKey
	PublicKey() sgo.PublicKey
	// SOLBalance returns the current SOL balance in lamports
	SOLBalance() uint64
	// TokenBalance returns the current balance of tokens
	TokenBalance() TokenBalance
}

type WriteHeader struct {
	Path   string
	Size   int
	Reader io.ReadCloser
}