core

type Api struct {
	Endpoint
}

type Config struct {
	// App name
	//
	// Default app name is used if left blank.
	AppName string

	// Server name for sending in response headers.
	//
	// Default server name is used if left blank.
	Name string

	// The maximum number of concurrent connections the server may serve.
	//
	// DefaultConcurrency is used if not set.
	//
	// Concurrency only works if you either call Serve once, or only ServeConn multiple times.
	// It works with ListenAndServe as well.
	Concurrency int

	// ReadTimeout is the amount of time allowed to read
	// the full request including body. The connection's read
	// deadline is reset when the connection opens, or for
	// keep-alive connections after the first byte has been read.
	//
	// By default request read timeout is unlimited.
	ReadTimeout time.Duration

	// WriteTimeout is the maximum duration before timing out
	// writes of the response. It is reset after the request handler
	// has returned.
	//
	// By default response write timeout is unlimited.
	WriteTimeout time.Duration

	// IdleTimeout is the maximum amount of time to wait for the
	// next request when keep-alive is enabled. If IdleTimeout
	// is zero, the value of ReadTimeout is used.
	IdleTimeout time.Duration

	// Per-connection buffer size for requests' reading.
	// This also limits the maximum header size.
	//
	// Increase this buffer if your clients send multi-KB RequestURIs
	// and/or multi-KB headers (for example, BIG cookies).
	//
	// Default buffer size is used if not set.
	ReadBufferSize int

	// Per-connection buffer size for responses' writing.
	//
	// Default buffer size is used if not set.
	WriteBufferSize int

	// NoDefaultDate, when set to true, causes the default Date
	// header to be excluded from the Response.
	//
	// The default Date header value is the current date value. When
	// set to true, the Date will not be present.
	NoDefaultDate bool

	// NoDefaultContentType, when set to true, causes the default Content-Type
	// header to be excluded from the Response.
	//
	// The default Content-Type header value is the internal default value. When
	// set to true, the Content-Type will not be present.
	NoDefaultContentType bool

	// Header names are passed as-is without normalization
	// if this option is set.
	//
	// Disabled header names' normalization may be useful only for proxying
	// incoming requests to other servers expecting case-sensitive
	// header names. See https://github.com/valyala/fasthttp/issues/57
	// for details.
	//
	// By default request and response header names are normalized, i.e.
	// The first letter and the first letters following dashes
	// are uppercased, while all the other letters are lowercased.
	// Examples:
	//
	//     * HOST -> Host
	//     * content-type -> Content-Type
	//     * cONTENT-lenGTH -> Content-Length
	DisableHeaderNamesNormalizing bool

	// Whether to disable keep-alive connections.
	//
	// The server will close all the incoming connections after sending
	// the first response to client if this option is set to true.
	//
	// By default keep-alive connections are enabled.
	DisableKeepalive bool

	// Maximum request body size.
	// a zero value means that default values will be honored
	MaxRequestBodySize int

	// NoDefaultServerHeader, when set to true, causes the default Server header
	// to be excluded from the Response.
	//
	// The default Server header value is the value of the Name field or an
	// internal default value in its absence. With this option set to true,
	// the only time a Server header will be sent is if a non-zero length
	// value is explicitly provided during a request.
	NoDefaultServerHeader bool

	// Rejects all non-GET requests if set to true.
	//
	// This option is useful as anti-DoS protection for servers
	// accepting only GET requests and HEAD requests. The request size is limited
	// by ReadBufferSize if GetOnly is set.
	//
	// Server accepts all the requests by default.
	GetOnly bool

	// Aggressively reduces memory usage at the cost of higher CPU usage
	// if set to true.
	//
	// Try enabling this option only if the server consumes too much memory
	// serving mostly idle keep-alive connections. This may reduce memory
	// usage by more than 50%.
	//
	// Aggressive memory usage reduction is disabled by default.
	ReduceMemoryUsage bool

	// StreamRequestBody enables request body streaming,
	// and calls the handler sooner when given body is
	// larger than the current limit.
	StreamRequestBody bool

	// Will not pre parse Multipart Form data if set to true.
	//
	// This option is useful for servers that desire to treat
	// multipart form data as a binary blob, or choose when to parse the data.
	//
	// Server pre parses multipart form data by default.
	DisablePreParseMultipartForm bool

	// When set to true, it will not print out the «gFly» ASCII art and listening address.
	//
	// Default: false
	DisableStartupMessage bool

	// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only)
	// WARNING: When prefork is set to true, only "tcp4" and "tcp6" can be chose.
	//
	// Default: NetworkTCP4
	Network string

	// When set to true, this will spawn multiple Go processes listening on the same port.
	//
	// Default: false
	Prefork bool

	// CompressedFileSuffix adds suffix to the original file name and
	// tries saving the resulting compressed file under the new file name.
	//
	// Default: ".gz"
	CompressedFileSuffix string
}

type Ctx struct {
	// contains filtered or unexported fields
}

type Data Map

type DefaultSession struct {
}

type DefaultView struct {
}

type Endpoint struct{}

type FnHookMiddleware func(fly IFlyMiddleware)

type FnHookRoute func(fly IFlyRouter)

type GFly struct {
	// contains filtered or unexported fields
}

type Group struct {
	// contains filtered or unexported fields
}

type IData interface {
	// SetData Keep data in request context Ctx.
	SetData(key string, data interface{})
	// GetData Get data from request context Ctx.
	GetData(key string) interface{}
	// SetSession Keep data in request context Ctx.
	SetSession(key string, data interface{})
	// GetSession Get data from request context Ctx.
	GetSession(key string) interface{}
}

type IFly interface {
	IFlyRouter
	IFlyMiddleware
	// Run start application
	Run()
	// Router web router
	Router() *Router
	// RegisterMiddleware register middlewares
	RegisterMiddleware(fn ...FnHookMiddleware)
	// RegisterRouter register router
	RegisterRouter(fn ...FnHookRoute)
}

type IFlyMiddleware interface {
	// Use middleware to global (All requests)
	Use(middlewares ...MiddlewareHandler)
	// Middleware is a shortcut for Middleware.Group(middlewares ...MiddlewareHandler)
	Middleware(middleware ...MiddlewareHandler) func(IHandler) IHandler
}

type IFlyRouter interface {
	// GET Http GET method
	GET(path string, handler IHandler)
	// HEAD Http HEAD method
	HEAD(path string, handler IHandler)
	// POST Http POST method
	POST(path string, handler IHandler)
	// PUT Http PUT method
	PUT(path string, handler IHandler)
	// PATCH Http PATCH method
	PATCH(path string, handler IHandler)
	// DELETE Http DELETE method
	DELETE(path string, handler IHandler)
	// CONNECT Http CONNECT method
	CONNECT(path string, handler IHandler)
	// OPTIONS Http OPTIONS method
	OPTIONS(path string, handler IHandler)
	// TRACE Http TRACE method
	TRACE(path string, handler IHandler)
	// Group multi routers
	Group(path string, groupFunc func(*Group))
}

type IGroupMiddleware interface {
	// Use apply middleware for all router group.
	// Important: Should put the code at the top of group router.
	Use(middlewares ...MiddlewareHandler)
}

type IGroupRouter interface {
	// GET Http GET method
	GET(path string, handler IHandler)
	// HEAD Http HEAD method
	HEAD(path string, handler IHandler)
	// POST Http POST method
	POST(path string, handler IHandler)
	// PUT Http PUT method
	PUT(path string, handler IHandler)
	// PATCH Http PATCH method
	PATCH(path string, handler IHandler)
	// DELETE Http DELETE method
	DELETE(path string, handler IHandler)
	// CONNECT Http CONNECT method
	CONNECT(path string, handler IHandler)
	// OPTIONS Http OPTIONS method
	OPTIONS(path string, handler IHandler)
	// TRACE Http TRACE method
	TRACE(path string, handler IHandler)
	// Group multi routers
	Group(path string, groupFunc func(*Group))
}

type IHandler interface {
	Validate(c *Ctx) error
	Handle(c *Ctx) error
}

type IHeader interface {
	// Status sets the response's HTTP code.
	Status(code int) *Ctx
	// ContentType sets the response's HTTP content type.
	ContentType(mime string) *Ctx
	// SetHeader sets the response's HTTP header field to the specified key, value.
	SetHeader(key, val string) *Ctx
	// SetCookie set cookie to the response's HTTP header.
	SetCookie(key, value string) *Ctx
	// GetCookie get cookie from the request's HTTP header.
	GetCookie(key string) string
	// GetReqHeaders returns the HTTP request headers.
	GetReqHeaders() map[string][]string
	// Path returns path URI
	Path() string
}

type IMiddleware interface {
	Group(middlewares ...MiddlewareHandler) func(IHandler) IHandler
}

type IRequestData interface {
	// ParseBody Parse body to struct data type.
	ParseBody(data any) error
	// ParseQuery Parse query string to struct data type.
	ParseQuery(data any) error
	// FormVal Get data from POST|PUT request.
	FormVal(key string) []byte
	// FormInt Get int from POST|PUT request.
	FormInt(key string) (int, error)
	// FormBool Get bool from POST|PUT request.
	FormBool(key string) (bool, error)
	// FormFloat Get float from POST|PUT request.
	FormFloat(key string) (float64, error)
	// FormUpload Process and get uploaded files from POST|PUT request.
	FormUpload(files ...string) ([]UploadedFile, error)
	// Queries Get data from Query string.
	Queries() map[string]string
	// QueryStr Get data from Query string.
	QueryStr(key string) string
	// QueryInt Get int from Query string.
	QueryInt(key string) (int, error)
	// QueryBool Get bool from Query string.
	QueryBool(key string) (bool, error)
	// QueryFloat Get float from Query string.
	QueryFloat(key string) (float64, error)
	// PathVal Get data from Path request.
	PathVal(key string) string
	// OriginalURL Original URL.
	OriginalURL() string
}

type IResponse interface {
	// Success Response success JSON data.
	Success(data interface{}) error
	// Error Response error JSON data.
	Error(data interface{}) error
	// NoContent Response no content.
	NoContent() error
	// View Load template page.
	View(template string, data Data) error
	// JSON sets the HTTP response body for JSON type.
	JSON(data JsonData) error
	// HTML sets the HTTP response body for HTML type.
	HTML(body string) error
	// String sets the HTTP response body for String type.
	String(body string) error
	// Raw sets the HTTP response body without copying it.
	Raw(body []byte) error
	// Stream sets response body stream and optional body size.
	Stream(stream io.Reader, size ...int) error
	// Redirect Send redirect.
	Redirect(path string) error
	// Download transfers the file from path as an attachment.
	Download(file string, filename ...string) error
	// File transfers the file from the given path.
	File(file string, compress ...bool) error
}

type ISession interface {
	Set(c *Ctx, key string, value interface{})
	Get(c *Ctx, key string) interface{}
}

type IView interface {
	// Parse build string from template `tpl` and data `data`
	Parse(tpl string, data Data) string
	// Writer set writer `w` from template `tpl` and data `data`
	Writer(tpl string, data Data, writer io.Writer) error
}

type JsonData interface{}

type Map map[string]any

type Middleware struct{}

type MiddlewareHandler func(ctx *Ctx) error

type Page struct {
	Endpoint
}

type RequestHandler func(ctx *Ctx) error

type Router struct {

	// If enabled, adds the matched route path onto the ctx.UserValue context
	// before invoking the handler.
	// The matched route path is only added to handlers of routes that were
	// registered when this option was enabled.
	SaveMatchedRoutePath bool

	// Enables automatic redirection if the current route can't be matched but a
	// handler for the path with (without) the trailing slash exists.
	// For example if /foo/ is requested but a route only exists for /foo, the
	// client is redirected to /foo with http status code 301 for GET requests
	// and 308 for all other request methods.
	RedirectTrailingSlash bool

	// If enabled, the router tries to fix the current request path, if no
	// handle is registered for it.
	// First superfluous path elements like ../ or // are removed.
	// Afterwards the router does a case-insensitive lookup of the cleaned path.
	// If a handle can be found for this route, the router makes a redirection
	// to the corrected path with status code 301 for GET requests and 308 for
	// all other request methods.
	// For example /FOO and /..//Foo could be redirected to /foo.
	// RedirectTrailingSlash is independent of this option.
	RedirectFixedPath bool

	// If enabled, the router checks if another method is allowed for the
	// current route, if the current request can not be routed.
	// If this is the case, the request is answered with 'Method Not Allowed'
	// and HTTP status code 405.
	// If no other Method is allowed, the request is delegated to the NotFound
	// handler.
	HandleMethodNotAllowed bool

	// If enabled, the router automatically replies to OPTIONS requests.
	// Custom OPTIONS handlers take priority over automatic replies.
	HandleOPTIONS bool

	// An optional RequestHandler that is called on automatic OPTIONS requests.
	// The handler is only called if HandleOPTIONS is true and no OPTIONS
	// handler for the specific path was set.
	// The "Allowed" header is set before calling the handler.
	GlobalOPTIONS RequestHandler

	// Configurable RequestHandler which is called when no matching route is
	// found. If it is not set, default NotFound is used.
	NotFound RequestHandler

	// Configurable RequestHandler which is called when a request
	// cannot be routed and HandleMethodNotAllowed is true.
	// If it is not set, ctx.Error with fasthttp.StatusMethodNotAllowed is used.
	// The "Allow" header with allowed request methods is set before the handler
	// is called.
	MethodNotAllowed RequestHandler

	// Function to handle panics recovered from http handlers.
	// It should be used to generate a error page and return the http error code
	// 500 (Internal Server Error).
	// The handler can be used to keep your server from crashing because of
	// unrecovered panics.
	PanicHandler func(*Ctx, interface{})
	// contains filtered or unexported fields
}

type Tree struct {

	// If enabled, the node handler could be updated
	Mutable bool
	// contains filtered or unexported fields
}

type UploadedFile struct {
	Field string // Field File name in form
	Name  string // Name Uploaded file name
	Path  string // Path Uploaded file path
	Size  int64  // Size Uploaded file size
}