dot

type AfterAllDestroyer interface {
	AfterAllDestroy(l Line)
}

type AfterAllInjecter interface {
	AfterAllInject(l Line)
}

type AfterAllStarter interface {
	AfterAllStart(l Line)
}

type AllEvent func(l Line)

type BeforeAllStopper interface {
	BeforeAllStop(l Line)
}

type BuildNewer func(l Line) error

type Builder struct {
	Add BuildNewer

	BeforeCreate  AllEvent //Before all dot create
	AfterCreate   AllEvent //after  all dot create
	BeforeStart   AllEvent //Before  all dot start
	AfterStart    AllEvent //After  all dot start
	BeforeStop    AllEvent //Before  all dot stop
	AfterStop     AllEvent //After  all dot stop
	BeforeDestroy AllEvent //Before  all dot destroy
	AfterDestroy  AllEvent //After  all dot destroy

	LineLiveID string //line unique id， default value is “default”
}

type Checker interface {
	Check(args interface{}) interface{}
}

type Cmd struct {
	//ConfigPath config file path
	ConfigPath string
	//ConfigFile config file name without path
	ConfigFile string
}

type CmdParameterName string

type Config struct {
	Log  LogConfig         `json:"log" toml:"log" yaml:"log"`
	Dots []MetaLivesConfig `json:"dots" toml:"dots" yaml:"dots"`
}

type ConfigTypeLive struct {
	TypeIDConfig TypeID      `json:"typeId"`
	ConfigInfo   interface{} `json:"json"`
}

type Creator interface {
	//Create When this method is initializing, running or monitoring same content, better to realize it in Start method
	Create(l Line) error
}

type Destroyer interface {
	//Destroy Dot
	//ignore When calling other Lifer, if true erred will continue, if false erred will return directly
	Destroy(ignore bool) error
}

type Dot interface{}

type Error struct {
	NilParameter     Errorer
	Existed          Errorer
	NotExisted       Errorer
	Parameter        Errorer
	RelyTypeNotMatch Errorer
	TypeIDEmpty      Errorer
	Config           Errorer
	NoDotNewer       Errorer
	NotStruct        Errorer
	DotInvalid       Errorer
}

type Errorer interface {
	error
	Code() string
	AddNewError(info string) Errorer
}

type Event = func(live *Live, l Line)

type Eventer interface {
	//
	ReSetLiveEvents(lid LiveID, liveEvents *LiveEvents)
	//
	AddLiveEvents(lid LiveID, liveEvents *LiveEvents)
	//
	LiveEvents(lid LiveID) []LiveEvents
	//
	ReSetTypeEvents(tid TypeID, typeEvents *TypeEvents)
	//
	AddTypeEvents(tid TypeID, typeEvents *TypeEvents)
	//
	TypeEvents(tid TypeID) []TypeEvents
}

type Events struct {
	//Before the dot create
	BeforeCreate Event
	//after the dot create
	AfterCreate Event
	//Before the dot start
	BeforeStart Event
	//After the dot start
	AfterStart Event
	//Before the dot stop
	BeforeStop Event
	//After the dot stop
	AfterStop Event
	//Before the dot destroy
	BeforeDestroy Event
	//After the dot destroy
	AfterDestroy Event
}

type GetInterfaceType interface {
	//get interface type
	GetInterfaceType() reflect.Type
}

type HotConfig interface {
	//Update Update config info, return true means successful
	HotConfig(newConf SConfig) bool
}

type Injected interface {
	//Injected call the function after inject
	Injected(l Line) error
}

type Injecter interface {
	//Inject inject
	//obj only support structure
	//dot.TagDot (dot) tag is in the field
	//If tag is empty, then input with field type, otherwise input with tag value（dot.LiveID）
	//In the process if error occurred, it will not quit, returned error is the first one occurred
	Inject(obj interface{}) error
	//GetByType get by type
	//If no related object in current container, then will call parent to search
	//type container is seperate with liveid container
	GetByType(t reflect.Type) (d Dot, err error)
	//GetByLiveID get by liveid
	//If no related object in current container, then will call parent to search
	//type container is seperate with liveid container
	GetByLiveID(id LiveID) (d Dot, err error)

	//ReplaceOrAddByType update
	//Cannot operate parent
	ReplaceOrAddByType(d Dot) error
	//Cannot operate parent
	ReplaceOrAddByParamType(d Dot, t reflect.Type) error
	//ReplaceOrAddByLiveID update
	//Cannot operate parent
	ReplaceOrAddByLiveID(d Dot, id LiveID) error
	//RemoveByType remove
	RemoveByType(t reflect.Type) error
	//RemoveByLiveID remove
	RemoveByLiveID(id LiveID) error

	//SetParent set parent injecter
	SetParent(p Injecter)
	//GetParent get parent injecter
	GetParent() Injecter
}

type Level = zapcore.Level

type Lifer interface {
	Creator
	Starter
	Stopper
	Destroyer
}

type Line interface {
	//Return unique Line name
	ID() string
	//Line API
	Config() *Config
	//SConfig general config API
	SConfig() SConfig

	SLogger() SLogger

	//order
	//1,Search liveid corresponding newer
	//2,Search typid corresponding newer
	//3,Search right newer in meta
	//AddNewerByLiveID add new for liveid
	AddNewerByLiveID(liveID LiveID, newDot Newer) error
	//AddNewerByTypeID add new for type
	AddNewerByTypeID(typeID TypeID, newDot Newer) error
	//RemoveNewerByLiveID remove
	RemoveNewerByLiveID(liveID LiveID)
	//RemoveNewerByTypeID remove
	RemoveNewerByTypeID(typeID TypeID)

	//PreAdd Add dot liveid and meta info, here no dot is created, it will be generated after Computing dependence
	//If it is the single sample, don't need to point sample info, sample id is typeid
	//If config file has config sample, then it will be added automatically, if sample id already existing, then config is prior
	PreAdd(typeLives ...*TypeLives) error
	//relyOrder  Check whether dependency existing
	//relyOrder() error
	////CreateDots create dots
	//CreateDots() error
	//ToLifer to lifer
	ToLifer() Lifer
	//ToInjecter to injecter
	ToInjecter() Injecter

	//ToDotEventer to Eventer
	ToDotEventer() Eventer

	//GetDotConfig get
	GetDotConfig(liveID LiveID) *LiveConfig

	GetLineBuilder() *Builder
	//InfoAllTypeAdnLives just for debug, log info all types and lives
	InfoAllTypeAdnLives()
	//EachLives for each Lives, if the func return false, break the loop
	EachLives(func(*Live, *Metadata) bool)
	//DestroyConfigLog destroy config and log
	DestroyConfigLog() error
}

type Live struct {
	TypeID    TypeID            `json:"typeId"`
	LiveID    LiveID            `json:"liveId"`
	RelyLives map[string]LiveID `json:"relyLives"`
	Dot       Dot               `json:"-"`
}

type LiveConfig struct {
	//LiveID
	LiveID LiveID `json:"liveId" toml:"liveId" yaml:"liveId"`
	//RelyLives rely lives， If cannot confirm key value then key value is livid value
	RelyLives map[string]LiveID `json:"relyLives" toml:"relyLives" yaml:"relyLives"`
	//dot config
	//todo tag
	Config interface{} `json:"json" toml:"json" yaml:"json" mapstructure:"json"`
}

type LiveEvents = Events

type LiveID string

type LogConfig struct {
	DirPath       string `json:"dirPath" toml:"dirPath" yaml:"dirPath"` // 文件夹路径
	File          string `json:"file" toml:"file" yaml:"file"`          // 日志文件名
	Level         string `json:"level" toml:"level" yaml:"level"`
	Time          string `json:"time" toml:"time" yaml:"time"`                            //hour,h,day,d,month,m,y,year
	MaxSize       int    `json:"maxSize" toml:"maxSize" yaml:"maxSize"`                   // 日志单文件,大小上限     最少：120M
	MaxBackups    int    `json:"maxBackups" toml:"maxBackups" yaml:"maxBackups"`          // 日志文件，最多有多少个   default：10
	MaxAge        int    `json:"maxAge" toml:"maxAge" yaml:"maxAge"`                      // 日志文件保存时长        最少：30days
	IsOpenConsole bool   `json:"isOpenConsole" toml:"isOpenConsole" yaml:"isOpenConsole"` // 是否输出到控制台
}

type MakeStringer func() string

type MetaLivesConfig struct {
	MetaData Metadata     `json:"metaData" toml:"metaData" yaml:"metaData"`
	Lives    []LiveConfig `json:"lives" toml:"lives" yaml:"lives"`
}

type Metadata struct {
	TypeID      TypeID       `json:"typeId"`
	Version     string       `json:"version"`
	Name        string       `json:"name"`
	ShowName    string       `json:"showName"`
	Single      bool         `json:"single"`
	RelyTypeIDs []TypeID     `json:"relyTypeIds"`
	NewDoter    Newer        `json:"-"`
	RefType     reflect.Type `json:"-"` //if the dot is interface, set the type of interface
}

type Newer = func(args []byte) (dot Dot, err error)

type SConfig interface {
	//RootPath root path
	RootPath()
	//Config file path
	ConfigPath() string
	//Without path, only file name
	ConfigFile() string
	//Whether key existing
	Key(key string) bool
	//If no config or config is empty, return nil
	Map() (m map[string]interface{}, err error)

	//Priorly bring data from RAM and operate, if RAM is nil then check whether original config file existing
	Unmarshal(s interface{}) error
	//Analyze key is corresponding type
	UnmarshalKey(key string, obj interface{}) error

	Marshal(data []byte) error

	//If no corresponding key or data type cannot be converted, must pay attention to default value,
	//so add "Def" before function to notify default value
	DefInterface(key string, def interface{}) interface{}
	DefArray(key string, def []interface{}) []interface{}
	DefMap(key string, def map[string]interface{}) map[string]interface{}
	DefString(key string, def string) string
	DefInt32(key string, def int32) int32
	DefUint32(key string, def uint32) uint32
	DefInt64(key string, def int64) int64
	DefUint64(key string, def uint64) uint64
	DefBool(key string, def bool) bool
	DefFloat32(key string, def float32) float32
	DefFloat64(key string, def float64) float64
}

type SLogger interface {
	//GetLevel get level
	GetLevel() Level
	//SetLevel set level
	SetLevel(level Level)
	//Debugln debug
	Debugln(msg string, fields ...zap.Field)
	//Debug debug
	Debug(mstr MakeStringer)
	//Infoln info
	Infoln(msg string, fields ...zap.Field)
	//Info info
	Info(mstr MakeStringer)
	//Warnln warn
	Warnln(msg string, fields ...zap.Field)
	//Warn warn
	Warn(mstr MakeStringer)
	//Errorln error
	Errorln(msg string, fields ...zap.Field)
	//Error error
	Error(mstr MakeStringer)
	//Fatalln fatal
	Fatalln(msg string, fields ...zap.Field)
	//Fatal fatal
	Fatal(mstr MakeStringer)
	//NewLogger return new logger
	NewLogger(callerSkip int) SLogger
}

type SetterLine interface {
	SetLine(l Line)
}

type SetterTypeAndLiveID interface {
	SetTypeID(typeID TypeID, liveID LiveID)
}

type Starter interface {
	//ignore When calling other Lifer, if true erred will continue, if false erred will return directly
	Start(ignore bool) error
}

type StatusType int

type Statuser interface {
	Status() StatusType
}

type Stopper interface {
	//ignore When calling other Lifer, if true erred will continue, if false erred will return directly
	Stop(ignore bool) error
}

type StringFromEnv string

type Tager interface {
	//SetTag set tag
	SetTag(tag interface{})
	//GetTag get tag
	GetTag() (tag interface{})
}

type TypeEvents = Events

type TypeID string

type TypeLives struct {
	Meta  Metadata
	Lives []Live
}