r

type CORSConfig struct {
	Origins          []string
	AllowMethods     []string
	AllowHeaders     []string
	AllowCredentials bool
	MaxAge           int
}

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

type CircuitBreakerConfig struct {
	Threshold        int64
	ResetTimeout     time.Duration
	Timeout          time.Duration
	HalfOpenRequests int64
}

type CircuitBreakerOption func(*CircuitBreakerConfig)

type CircuitBreakerStatus struct {
	State           string    `json:"state"`
	Failures        int64     `json:"failures"`
	LastFailure     time.Time `json:"last_failure"`
	SuccessStreak   int64     `json:"success_streak"`
	TotalRequests   int64     `json:"total_requests"`
	ErrorPercentage float64   `json:"error_percentage"`
}

type Config struct {
	ReadTimeout        time.Duration
	WriteTimeout       time.Duration
	IdleTimeout        time.Duration
	MaxRequestBodySize int
	CertFile           string
	KeyFile            string
	TLSConfig          *tls.Config
	WSConfig           WSConfig
	Handler            Router // Add this field
}

type ConfigProvider interface {
	GetConfig() Config
	SetConfig(Config) error
	LoadFromFile(path string) error
	LoadFromEnv() error
}

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

type Context interface {
	context.Context
	RequestCtx() *fasthttp.RequestCtx
	Param(name string) string
	QueryParam(name string) string
	JSON(code int, v interface{}) error
	String(code int, s string) error
	Stream(code int, contentType string, reader io.Reader) error
	Redirect(code int, url string) error
	SetHeader(key, value string)
	GetHeader(key string) string
	Cookie(name string) string
	SetCookie(cookie *fasthttp.Cookie)
	RequestID() string
	RealIP() string
	Path() string
	Method() string
	IsWebSocket() bool
	Next()
	Abort()
	AbortWithError(code int, err error)
	Error() error
	Set(key string, value interface{})
	Get(key string) (interface{}, bool)
	SetStatus(code int)
	ErrorResponse(code int, msg string)
}

type ContextFactory interface {
	CreateContext(*fasthttp.RequestCtx) Context
	WithStore(store Store) ContextFactory
}

type ContextImpl struct {
	*routing.Context
	// contains filtered or unexported fields
}

type ErrorContext struct {
	Error     error
	Stack     string
	RequestID string
	Timestamp time.Time
	Path      string
	Method    string
	ClientIP  string
	UserAgent string
}

type ErrorHandler interface {
	HandleError(Context, error)
	HandlePanic(Context, interface{})
	WithLogger(Logger) ErrorHandler
}

type HandlerFunc = MiddlewareFunc

type HealthCheck struct {
	Name     string
	Check    func() error
	Interval time.Duration
}

type HealthChecker interface {
	Check() error
	RegisterCheck(name string, check func() error)
	Start(context.Context) error
	Stop() error
}

type LogConfig struct {
	Output      io.Writer
	FilePath    string
	JsonFormat  bool
	AsyncWrite  bool
	BufferSize  int
	MaxFileSize int
	MaxBackups  int
	AddSource   bool
	Metrics     bool
	Level       LogLevel
}

type LogEntry struct {
	Level      LogLevel       `json:"level"`
	Message    string         `json:"message"`
	Time       time.Time      `json:"time"`
	Fields     map[string]any `json:"fields,omitempty"`
	Method     string         `json:"method,omitempty"`
	Status     int            `json:"status,omitempty"`
	Latency    time.Duration  `json:"latency,omitempty"`
	IP         string         `json:"ip,omitempty"`
	Path       string         `json:"path,omitempty"`
	StackTrace string         `json:"stack_trace,omitempty"`
}

type LogLevel int

type Logger interface {
	WithField(key string, value interface{}) Logger
	WithFields(fields map[string]interface{}) Logger
	WithError(err error) Logger
	With(key string, value interface{}) Logger
	Configure(config LogConfig) error
	Log(method string, status int, latency time.Duration, ip, path string)
	Info(msg string, args ...interface{})
	Error(msg string, args ...interface{})
	Debug(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
}

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

type MetricsCollector interface {
	IncrementCounter(name string, tags map[string]string)
	RecordTiming(name string, duration time.Duration, tags map[string]string)
	RecordValue(name string, value float64, tags map[string]string)
	GetMetrics() map[string]interface{}
	Close() error
}

type MiddlewareFunc func(Context)

type MiddlewareOption func(*standardMiddleware)

type MiddlewareProvider interface {
	Logger(format string) MiddlewareFunc
	RateLimit(reqs int, per time.Duration) MiddlewareFunc
	Timeout(duration time.Duration) MiddlewareFunc
	Security() MiddlewareFunc
	Recovery(handler func(Context, interface{})) MiddlewareFunc
	Compression() MiddlewareFunc
	RequestID() MiddlewareFunc
	CORS(origins []string) MiddlewareFunc
	CircuitBreaker(opts ...CircuitBreakerOption) MiddlewareFunc
}

type PanicHandlerFunc func(Context, interface{})

type RateLimiter interface {
	Allow(key string) bool
	Reset(key string)
	SetDistributedClient(client RedisClient)
	GetQuota(key string) (remaining int, reset time.Time)
	GetDebugStats(key string) map[string]interface{} // Add this method

}

type RateLimiterOption func(*defaultRateLimiter)

type RedisClient interface {
	Get(key string) (string, error)
	Set(key string, value string, expiration time.Duration) error
	IncrBy(key string, value int64) (int64, error)
	// Add new methods for rate limiting
	ZRemRangeByScore(key string, min, max string) error
	ZAdd(key string, score float64, member string) error
	ZCount(key string, min, max string) (int64, error)
}

type Route struct {
	Path        string
	Method      string
	Handler     string
	Description string
	Params      []RouteParam
	Added       time.Time
	Tags        []string
	// contains filtered or unexported fields
}

type RouteParam struct {
	Name        string
	Type        string
	Required    bool
	Description string
	Validation  string // regex or validation rules
}

type RouteValidator interface {
	ValidateRoute(path, method string) error
	ValidateParams(params []RouteParam) error
}

type Router interface {
	GET(path string, handlers ...HandlerFunc) Router
	POST(path string, handlers ...HandlerFunc) Router
	PUT(path string, handlers ...HandlerFunc) Router
	DELETE(path string, handlers ...HandlerFunc) Router
	PATCH(path string, handlers ...HandlerFunc) Router
	HEAD(path string, handlers ...HandlerFunc) Router
	OPTIONS(path string, handlers ...HandlerFunc) Router
	WS(path string, handler WSHandler) Router
	Group(prefix string) Router
	Use(middleware ...MiddlewareFunc) Router
	Static(prefix, root string) Router
	FileServer(path, root string) Router
	NotFound(handler HandlerFunc)
	MethodNotAllowed(handler HandlerFunc)
	PanicHandler(handler PanicHandlerFunc)
	ServeHTTP(ctx *fasthttp.RequestCtx)
}

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

type RouterProvider interface {
	Router
	WithMiddlewareProvider(provider MiddlewareProvider) RouterProvider
	WithErrorHandler(handler ErrorHandler) RouterProvider
	WithWSUpgrader(upgrader WSUpgrader) RouterProvider
}

type SecurityProvider interface {
	SetHeaders(c Context)
}

type Server interface {
	Start(address string) error
	Stop() error
	WithConfig(config Config) Server
	WithRouter(router Router) Server
	WithMiddleware(middleware ...MiddlewareFunc) Server
	ServeHTTP(ctx *fasthttp.RequestCtx)
}

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

type Store interface {
	Get(key string) (interface{}, bool)
	Set(key string, value interface{})
	Delete(key string)
	Clear()
}

type WSConfig struct {
	HandshakeTimeout  time.Duration
	ReadBufferSize    int
	WriteBufferSize   int
	EnableCompression bool
	Origins           []string
	Path              string
}

type WSConnection interface {
	WriteMessage(messageType int, data []byte) error
	Close() error
	ReadMessage() (messageType int, p []byte, err error)
	SetReadDeadline(t time.Time) error
	SetWriteDeadline(t time.Time) error
	ID() string
	RemoteAddr() string
	CloseCode() (int, string)
}

type WSErrorHandler interface {
	OnError(conn WSConnection, err error)
}

type WSHandler interface {
	OnConnect(conn WSConnection)
	OnMessage(conn WSConnection, msg []byte)
	OnClose(conn WSConnection)
}

type WSUpgrader interface {
	Upgrade(*fasthttp.RequestCtx, WSHandler) (WSConnection, error)
	WithConfig(WSConfig) WSUpgrader
}