contract

type Application interface {
	Container
	Pool
	SetMode(mode uint8)
	Version() string
	Mode() uint8
	IsDevelopment() bool
	IsProduction() bool
	IsTesting() bool
	Resolve(abstract interface{}, params ...interface{}) interface{}
	Boot()
	Register(provider Provider, force bool)
	RegisterMultiple(providers []Provider, force bool)
	HasProvider(name string) bool
	GetProvider(name string) Provider
	Reset()
}

type BaseCommand interface {
	Application() Application

	Providers() []Provider

	AddCommand(commands ...Command)

	Run() error

	Root() *cobra.Command

	Resolve(abstract interface{}, params ...interface{}) interface{}
}

type Binding interface {
	Protocol(protocol Protocol, v interface{}) error
}

type BindingFile interface {
	Files(key string) []*multipart.FileHeader

	File(key string) *multipart.FileHeader

	Save(key string, option *UploadOption) ([]*FileInfo, error)

	SaveAll(option *UploadOption) (map[string][]*FileInfo, error)
}

type Cache interface {
	Driver(driver string) CacheSerializable
	Register(driver string, store CacheStore)
	CacheStore
	CacheSerializable
}

type CacheSerializable interface {
	Store() CacheStore

	GetDefault(key string, defaultValue interface{}) (interface{}, error)

	Pull(key string) (interface{}, error)

	PullDefault(key string, defaultValue interface{}) (interface{}, error)

	GetDecode(key string, to interface{}) (interface{}, error)

	AddEncode(key string, value interface{}, expire time.Time) error

	ForeverEncode(key string, value interface{}) error

	PutEncode(key string, value interface{}, expire time.Time) error
}

type CacheStore interface {
	Get(key string) (interface{}, error)

	Add(key string, value interface{}, expire time.Time) error

	Put(key string, value interface{}, expire time.Time) error

	Forever(key string, value interface{}) error

	Forget(key string) error

	Increment(key string, steps ...int64) error

	Decrement(key string, steps ...int64) error

	Has(key string) bool

	Flush() error
}

type Command interface {
	CobraCmd() *cobra.Command

	Run(root BaseCommand, cmd *cobra.Command, args []string)
}

type Configuration interface {
	Bind(key string, val interface{}) error
	Get(key string) interface{}
	GetBool(key string) bool
	GetFloat(key string) float64
	GetInt(key string) int
	GetIntSlice(key string) []int
	GetString(key string) string
	GetStringMap(key string) map[string]interface{}
	GetStringMapString(key string) map[string]string
	GetStringSlice(key string) []string
	GetTime(key string) time.Time
	GetDuration(key string) time.Duration
	Exists(key string) bool
	Set(key string, value interface{})
	SetDefault(key string, value interface{})
	Clone() Configuration
}

type Container interface {
	Has(name string) bool
	Get(name string, params ...interface{}) interface{}
	Bind(name string, prototype interface{}, options ...support.Option)
	Make(abstract interface{}, params ...interface{}) interface{}
	Remove(name string)
	Flush()
}

type Context interface {
	context.Context

	Application() Application

	Protocol() Protocol

	Next()

	Handlers() []ContextHandler

	AddEntity(key string, value interface{})

	Entity(key string) *ContextEntity

	Abort()

	Current() int

	Error(status int, err ...interface{})

	Bind(v interface{}) error

	BindValidate(v interface{}) error

	BindWith(b Binding, v interface{}) error

	BindWithValidate(b Binding, v interface{}) error

	Get(key string) interface{}

	Render(status int, v interface{}) error

	RenderWith(status int, r Render, v interface{}) error

	Clone() Context

	// application make method
	Resolve(abstract interface{}, params ...interface{}) interface{}
}

type ContextEntity struct {
	Key   string
	Value interface{}
}

type ContextHandler func(c Context)

type ContextPool interface {
	New(application Application) Context

	Get() Context

	Release(Context)
}

type Cron interface {
	Start()

	Stop()

	// Perform tasks at a custom time
	RunWithFunc(spec string, job func())
	RunWithJob(spec string, job CronJob)

	// Execute task in specified seconds
	SecondsWithFunc(seconds int, job func())
	SecondsWithJob(seconds int, job CronJob)

	// Perform a task every second
	EverySecondWithFunc(job func())
	EverySecondWithJob(job CronJob)

	// Execute task in specified minutes
	MinutesWithFunc(minutes int, job func())
	MinutesWithJob(minutes int, job CronJob)

	// Perform a task every minute
	EveryMinuteWithFunc(job func())
	EveryMinuteWithJob(job CronJob)

	// Execute task in specified hours
	HoursWithFunc(hours int, job func())
	HoursWithJob(hours int, job CronJob)

	// Perform a task every hour
	EveryHourWithFunc(job func())
	EveryHourWithJob(job CronJob)

	// Run at a specified time every day
	DayAtWithFunc(hour int, job func())
	DayAtWithJob(hour int, job CronJob)

	// Every day at 0 o'clock
	EveryDayWithFunc(job func())
	EveryDayWithJob(job CronJob)

	// Perform the task at 0:00 every Sunday
	EveryWeeklyWithFunc(job func())
	EveryWeeklyWithJob(job CronJob)

	// Perform a task at N points of N every week
	WeeklyOnWithFunc(week, hour int, job func())
	WeeklyOnWithJob(week, hour int, job CronJob)
}

type CronJob interface {
	cron.Job
}

type Error interface {
	fmt.Stringer

	error

	Equal(err error) bool

	Unwrap() error

	Meta() map[string]interface{}

	SetMeta(key string, value interface{}) Error

	Code() int

	SetCode(code int) Error

	Stack() []uintptr

	StackString() string

	Prev() error
}

type ErrorRender interface {
	Render(status int, ctx Context) error
}

type ErrorStack interface {
	Stack() []uintptr

	StackString() string
}

type Event interface {
	Listen(name string, handlers ...EventHandler)
	Dispatch(name string, params ...interface{}) []interface{}
	Has(name string) bool
}

type EventHandler interface {
	Handle(application Application, params ...interface{}) (interface{}, error)
}

type FileInfo struct {
	Name         string
	OriginalName string
	Mime         string
	Extension    string
	Size         int64
	Path         string
	FullPath     string
	MD5          string
}

type GORMQueryMagic interface {
	Query(db *gorm.DB) *gorm.DB
}

type HttpProtocol interface {
	Protocol

	Request() *http.Request

	ResponseWriter() HttpWrapResponseWriter

	SetHeader(key, value string)

	SetParams(params []httprouter.Param)

	Params() []httprouter.Param

	Param(key string) httprouter.Param

	SetRoute(route HttpRoute)

	Route() HttpRoute

	Header(key string) string

	SetSession(session Session)

	Session() Session

	SessionValue(key string) interface{}

	IsContentType(key string) bool

	IsAccept(key string) bool

	IsMethod(key string) bool

	ContentType() string

	Accept() []string

	SetStatus(status int)

	SetCookie(cookie *http.Cookie)

	Cookie(name string) (string, error)

	Redirect(status int, location string)

	ClientIP() string
}

type HttpRoute interface {
	Name(name string) HttpRoute

	Use(handlers ...ContextHandler) HttpRoute

	Handlers() []ContextHandler
}

type HttpRouteGroup interface {
	Prefix(prefix string) HttpRouteGroup

	Use(handlers ...ContextHandler) HttpRouteGroup

	GET(path string, handler ContextHandler) HttpRoute

	POST(path string, handler ContextHandler) HttpRoute

	PUT(path string, handler ContextHandler) HttpRoute

	PATCH(path string, handler ContextHandler) HttpRoute

	DELETE(path string, handler ContextHandler) HttpRoute

	OPTIONS(path string, handler ContextHandler) HttpRoute

	Group(prefix string) HttpRouteGroup

	Handler(method, path string, handler http.HandlerFunc)
}

type HttpRouter interface {
	GET(path string, handler ContextHandler) HttpRoute

	POST(path string, handler ContextHandler) HttpRoute

	PUT(path string, handler ContextHandler) HttpRoute

	PATCH(path string, handler ContextHandler) HttpRoute

	DELETE(path string, handler ContextHandler) HttpRoute

	OPTIONS(path string, handler ContextHandler) HttpRoute

	// serve static files
	Static(path string, root string) HttpRouter

	Handler(method, path string, handler http.HandlerFunc)

	HttpRouter() *httprouter.Router

	Group(prefix string) HttpRouteGroup

	ServeHTTP(w http.ResponseWriter, req *http.Request)
}

type HttpWrapResponseWriter interface {
	http.ResponseWriter

	StatusCode() int
}

type Jwt interface {
	Create(audience JwtAudience) (*Token, error)

	Parse(token string) (*jwt.StandardClaims, error)

	Refresh(token string) (*Token, error)

	Invalidate(token string) error

	Valid(token string) (bool, error)
}

type JwtAudience interface {
	Audience() string
}

type JwtStore interface {
	Has(id string) bool

	Put(id string, audience JwtAudience, lifetime time.Time) error

	Forget(audience JwtAudience) error
}

type Loggable interface {
	Writer(channel string) io.Writer
	With(...interface{}) Loggable
	Debug(...interface{})
	Info(...interface{})
	Warn(...interface{})
	Error(...interface{})
	Fatal(...interface{})
	Panic(...interface{})
}

type Notify func(blockCount int, info *NotifyInfo, err error)

type NotifyInfo struct {
	Block int
	Size  int
	Extra interface{}
}

type Pool interface {
	RegisterPool(name string, poolNew PoolFunc) error

	PoolValue(name string) (interface{}, bool)

	ReleasePool(name string, value func() interface{})
}

type PoolFunc func(application Application) interface{}

type Protocol interface {
	io.Reader
	io.Writer

	Application() Application

	Name() string

	// Protocol metadata
	Metadata() map[string][]string

	// Full protocol message
	Message() ([]byte, error)

	Values() map[string][]string

	Clone() Protocol
}

type Provider interface {
	Name() string
	Register()
	Boot()
}

type Render interface {
	Render(protocol Protocol, status int, v interface{}) error
}

type ResourceCollectionData interface {
	CollectionData() ResourceDataCollection
}

type ResourceData map[string]interface{}

type ResourceDataCollection []ResourceData

type ResourceDatable interface {
	Data() ResourceData
}

type ResourceFields []string

type ResourceLink interface {
	SetLink(links ResourceLinkData)
	Link() ResourceLinkData
}

type ResourceLinkData map[string]string

type ResourceMeta interface {
	SetMeta(meta ResourceMetaData)
	Meta() ResourceMetaData
}

type ResourceMetaData map[string]interface{}

type ResourceResolveData map[string]interface{}

type ResourceResolver interface {
	Resolve() interface{}
}

type ResourceTransformer interface {
	Resource() interface{}
	SetResource(resource interface{})
}

type Scheduler interface {
	Send(message *SchedulerMessage) error
	Run() error
	Close() error
	Decrement(workerNum int32)
	Increment(workerNum int32) error
	RegisterHandler(name string, handler SchedulerHandler)
}

type SchedulerFailed interface {
	Failed(err error)
}

type SchedulerHandler interface {
	Handle(message *SchedulerMessage) error
}

type SchedulerMessage struct {
	Worker  int32
	Handler string
	Message interface{}
}

type Server interface {
	Start(ctx context.Context) error
	Stop(ctx context.Context) error
	Restart(ctx context.Context) error
}

type Session interface {
	Id() string

	Get(key string) interface{}

	GetString(key string) string
	GetInt(key string) int
	GetBool(key string) bool
	GetFloat(key string) float64

	Put(key string, value interface{}) error

	Flush()

	Delete(key string)
}

type Storage interface {
	Url(key string, params url.Values) string

	FormUpload(ctx context.Context, metadata *StorageMetadata) (*StorageInfo, error)

	PartUpload(ctx context.Context, metadata *StorageMetadata, notify Notify) (*StorageInfo, error)

	Token() string

	Callback(req *http.Request) (*StorageInfo, error)
}

type StorageInfo struct {
	Driver       string
	Hash         string
	Name         string
	OriginalName string
	Mime         string
	Extension    string
	Size         int64
	Path         string
	Extra        map[string]interface{}
}

type StorageMetadata struct {
	Path string
	Name string
	Mime string
	Data []byte
	Size int64
	File io.Reader
}

type Token struct {
	Lifetime int64  `json:"lifetime"`
	Token    string `json:"token"`
	Type     string `json:"type"`
}

type UploadOption struct {
	Path            string
	AllowMimes      []string
	AllowExtensions []string
	MaxSize         int64
	MinSize         int64
	Grading         bool //多层级
	Rename          bool
}

type Validator interface {
	Validate(val interface{}) error
}