yocki

type EnvVar interface {
	// SetPath set operate target:
	// windows: sys or user, it's required in windows.
	// posix: /etc/enviroment, this only is empty method.
	SetPath(string) error

	// set global enviroment variable
	Set(string, any) error
	// set global enviroment variable when key isn't exist
	SafeSet(string, any) error

	// unset (delete) global enviroment variable
	Unset(string) error

	// set local enviroment variable
	SetL(string, string) error
	// set local enviroment variable when key isn't exist
	SafeSetL(string, string) error

	// export current enviroment string into specify file
	Export(string) error
	// load enviroment string to be export from disk
	Load(EnvVarLoadOpt) error

	// Print current enviroment variable
	Print()
}

type EnvVarLoadOpt struct {
	File string
	Keys []string
	Safe bool
}

type GoPool interface {
	Go(func())
	Run()
}

type LuaFuncs map[string]lua.LGFunction

type Promise interface {
	Load(id int64) (any, bool)
	LoadWithTimeout(id int64, timeout time.Duration) (any, bool)
	Store(id int64, v any)
	// NextID returns the unique snowflake id to ensure concurrency security
	NextID() int64
}

type PromiseEvent interface {
	Id() int64
	Proto() Protocal
}

type Protocal interface {
	Type() pb.ProtocalType
	String() string
}

type SignalStream interface {
	// Load returns the value of the specified singal.
	// If the singal isn't exist, the second parameter returns false, and vice versa.
	Load(sig string) (any, bool)
	// Store settings specify the value of the singal, similar to map's kv storage.
	Store(sig string, v bool)
}

type Table interface {
	TableAt
	TableSetter
	TableGetter
	SetDo(k string, v func(YockState) lua.LValue, env ...YockState)
	Bind(v any) error
	Clone(l *lua.LState) Table
	Value() *lua.LTable
}

type TableAt interface {
	ToString(n int) string
	ToTable(n int) Table
	ToFunctionByString(k string) *lua.LFunction
	ToFloat32ByString(k string) float32
	ToFloat64ByString(k string) float64
	ToIntByString(k string) int
	ToFunction(n int) *lua.LFunction
	ToFloat32(n int) float32
	ToFloat64(n int) float64
	ToInt(n int) int
}

type TableGetter interface {
	GetBool(k string) (bool, bool)
	GetString(k string) (string, bool)
	GetInt(k string) (int, bool)
	GetFloat(k string) (float64, bool)
	GetTable(k string) (Table, bool)
	GetLTable(k string) (*lua.LTable, bool)
	MustGetTable(key string) Table
}

type TableSetter interface {
	SetString(k, v string)
	SetBool(k string, v bool)
	SetNil(k string)
	SetInt(k string, v int)
	SetTable(k string, v Table)
	SetLTable(k string, v *lua.LTable)
	SetField(l *lua.LState, k string, v any)
	SetFields(l *lua.LState, v map[string]any)
}

type YGFunction func(YockState) int

type Ycho interface {
	Progress(total int64, r io.Reader) io.Writer
	Eventloop()
	Info(msg string)
	Infof(msg string, v ...any)
	Debug(msg string)
	Debugf(msg string, v ...any)
	Warn(msg string)
	Warnf(msg string, v ...any)
	Fatal(msg string)
	Fatalf(msg string, v ...any)
	Error(msg string)
	Errorf(msg string, v ...any)
	Print(msg string)
}

type YockDB interface {
	Get(k string) lua.LValue
	Put(k string, v lua.LValue)
}

type YockFuncInfo lua.P

type YockFuns map[string]YGFunction

type YockJob interface {
	Name() string
	Func() *lua.LFunction
}

type YockLib interface {
	Name() string
	Value() lua.LValue
	SetField(v map[string]any)
	SetFunction(name string, fn lua.LGFunction)
	SetFunctions(v map[string]lua.LGFunction)
	SetYFunction(v map[string]YGFunction)
	SetClosure(v map[string]lua.LGFunction)
	Meta() Table
	SetTable(t Table)
	State() YockState
	SetState(s YockState)
}

type YockLoader interface {
	// CreateLib returns a new library
	// and overrides old library when it's exist
	CreateLib(name string) YockLib
	// OpenLib opens library to be specified
	// and creates a new library when it isn't exist
	OpenLib(name string) YockLib
	RegLuaFn(LuaFuncs)
	RegYockFn(YockFuns)
	State() YockState
}

type YockMode interface {
	Mode() int32
	SetMode(m int32)
	UnsetMode(m int32)

	Debug() bool
	Strict() bool
}

type YockRuntime interface {
	// Call to call specify function without arguments
	Call(string) ([]lua.LValue, error)
	// FastCall to call specify function without arguments and not return value
	FastCall(string) error
	// Call to call specify function with arguments
	// CallByParam(string, []lua.LValue) ([]lua.LValue, error)
	// FastCallByParam to call specify function with arguments and not return value
	// FastCallByParam(string, []lua.LValue) error
	// Eval to execute string of script
	Eval(string) error
	// EvalFile to execute file of script
	EvalFile(string) error
	// EvalFunc to execute function
	EvalFunc(lua.LValue, []lua.LValue) ([]lua.LValue, error)
	// FastEvalFunc to execute function and not return value
	FastEvalFunc(lua.LValue, []lua.LValue) error
	// SetGlobalFn to set global function
	SetGlobalFn(map[string]lua.LGFunction)
	// SafeSetGlobalFn to set global function when it isn't exist
	SafeSetGlobalFn(map[string]lua.LGFunction)
	// GetGlobalVar returns global variable
	GetGlobalVar(string) lua.LValue
	// SetGlobalVar to set global variable
	SetGlobalVar(string, lua.LValue)
	// SafeSetGlobalVar to set global variable when variable isn't exist
	SafeSetGlobalVar(string, lua.LValue)
	// RegisterModule to register modules
	// RegisterModule(map[string]lua.LGFunction)
	// UnregisterModule to unregister specify module
	// UnregisterModule(string)
	// LoadModule to immediately load module to be specified
	// LoadModule(string, lua.LGFunction)
	// State returns LState
	State() YockState
	// SetState sets interp
	SetState(l YockState)
	// NewState returns new interp
	NewState() (YockState, context.CancelFunc)
}

type YockScheduler interface {
	// yock runtime
	YockLoader
	YockRuntime
	RegYocksFn(funcs YocksFuncs)
	MntYocksFn(lib YockLib, funcs YocksFuncs)

	// yocks field
	EnvVar() EnvVar
	Signal() SignalStream
	Opt() Table
	SetOpt(o Table)
	Env() YockLib

	// yocks goroutines
	Do(f func())

	GetTask(name string) bool
	AppendTask(name string, job YockJob)

	YockDB
}

type YockState interface {
	Call(info YockFuncInfo, args ...any) error

	YockStateIs
	YockStateCheck
	YockStatePush

	NewLFunction(f lua.LGFunction) *lua.LFunction
	NewYFunction(f YGFunction) *lua.LFunction
	Exit() int

	Stack(i int) (*lua.Debug, bool)
	Stacktrace() string

	LState() *lua.LState
	Argc() int
	PopAll()
	Clone() YockState
}

type YockStateCheck interface {
	CheckTable(n int) Table
	CheckString(n int) string
	CheckRune(n int) rune
	CheckNumber(n int) lua.LNumber
	CheckInt(n int) int
	CheckBool(n int) bool
	CheckFunction(n int) *lua.LFunction
	CheckAny(n int) any
	CheckLValue(n int) lua.LValue
	CheckLTable(n int) *lua.LTable
}

type YockStateIs interface {
	IsNil(n int) bool
	IsFunction(n int) bool
	IsNumber(n int) bool
	IsBool(n int) bool
	IsTable(n int) bool
	IsString(n int) bool
	IsUserData(n int) bool
	IsThread(n int) bool
	IsChannel(n int) bool
}

type YockStatePush interface {
	Throw(err error) YockState
	PushError(err error) YockState
	PushNil() YockState
	Push(v lua.LValue) YockState
	PushNilTable() YockState
	PushString(str string) YockState
	PushBool(b bool) YockState
	PushInt(i int) YockState
	Pusha(val any) YockState
	PushAll(vals ...any) YockState
}

type YockdClient interface {
	YockdClientSignal
	YockdClientFS
	YockdClientGateway
	YockdClientMeta
	YockdClientNet
	YockdClientProcess
}

type YockdClientFS interface {
	FileSystemPut(src, dst string) error
	FileSystemGet(src, dst string) error
}

type YockdClientGateway interface{}

type YockdClientMeta interface {
	IsPublic() bool
	Name() string
	Info() (string, error)
	Status()
	Close()
}

type YockdClientNet interface {
	Ping() error
	Mark(name, addr string) error
	Dial(form, to *pb.NodeInfo) error
	Call(node, method string, args ...string) (string, error)
	MakeTunnel(name string, ctx context.Context, p Promise, event chan PromiseEvent) error
}

type YockdClientProcess interface {
	ProcessList() ([]*pb.Process, error)
	ProcessKill(pid int64) error
	ProcessFind(pid int64, cmd string) ([]*pb.Process, error)
	ProcessSpawn(t pb.ProcessSpawnType, spec, cmd string) (int64, error)
}

type YockdClientSignal interface {
	SignalNotify(sig string) error
	SignalWait(sig string) (bool, error)
	SignalInfo(sig string) (bool, bool, error)
	SignalList() ([]string, error)
	SignalClear(sigs ...string) error
}

type YocksFuncs map[string]YocksFunction

type YocksFunction func(yocks YockScheduler, state YockState) int