backends

type AuthBackend interface {
	Backend

	// Authentication middleware
	BasicAuth(accounts map[string]string) MiddlewareFunc
}

type Backend interface {
	// Factory methods
	NewEngine() Engine
	NewEngineWithDefaults() Engine
	NewServer(port int, engine Engine) Server
	NewServerWithAddr(addr string, engine Engine) Server

	// Backend-specific configuration
	SetMode(mode string)
	GetMode() string

	// Common middleware
	Logger() MiddlewareFunc
	Recovery() MiddlewareFunc
}

type CORSBackend interface {
	Backend

	// CORS middleware
	CORS() MiddlewareFunc
	CORSWithConfig(config CORSConfig) MiddlewareFunc
}

type CORSConfig struct {
	AllowOrigins     []string
	AllowMethods     []string
	AllowHeaders     []string
	ExposeHeaders    []string
	AllowCredentials bool
	MaxAge           time.Duration
}

type Context interface {
	// Request/Response handling
	String(code int, format string, values ...interface{})
	JSON(code int, obj interface{})
	XML(code int, obj interface{})
	Data(code int, contentType string, data []byte)
	Status(code int)

	// Request access
	Request() *http.Request
	ReadBody() ([]byte, error)

	// Headers
	GetHeader(key string) string
	Header(key, value string)

	// URL parameters and query strings
	Param(key string) string
	Query(key string) string
	DefaultQuery(key, defaultValue string) string

	// Form data
	PostForm(key string) string
	DefaultPostForm(key, defaultValue string) string

	// Data binding
	Bind(obj interface{}) error
	ShouldBind(obj interface{}) error
	BindJSON(obj interface{}) error
	ShouldBindJSON(obj interface{}) error

	// Context storage
	Set(key string, value interface{})
	Get(key string) (value interface{}, exists bool)
	GetString(key string) string
	GetBool(key string) bool
	GetInt(key string) int
	GetInt64(key string) int64
	GetFloat64(key string) float64

	// Flow control
	Abort()
	AbortWithStatus(code int)
	AbortWithStatusJSON(code int, jsonObj interface{})
	IsAborted() bool
	Next()
}

type Engine interface {
	// HTTP methods
	GET(relativePath string, handlers ...HandlerFunc)
	POST(relativePath string, handlers ...HandlerFunc)
	PUT(relativePath string, handlers ...HandlerFunc)
	DELETE(relativePath string, handlers ...HandlerFunc)
	PATCH(relativePath string, handlers ...HandlerFunc)

	// Middleware
	Use(middleware ...HandlerFunc)

	// HTTP Handler for integration with net/http
	Handler() http.Handler
}

type FullBackend interface {
	Backend
	RealtimeBackend
}

type HandlerFunc func(Context)

type LogFormatter func(params LogFormatterParams) string

type LogFormatterParams struct {
	Request      *http.Request
	TimeStamp    time.Time
	StatusCode   int
	Latency      time.Duration
	ClientIP     string
	Method       string
	Path         string
	ErrorMessage string
	BodySize     int
	Keys         map[string]interface{}
}

type LoggingBackend interface {
	Backend

	// Logging middleware with custom configuration
	LoggerWithFormatter(formatter LogFormatter) MiddlewareFunc
	LoggerWithWriter(out io.Writer, notlogged ...string) MiddlewareFunc
}

type MiddlewareFunc = HandlerFunc

type RealtimeBackend interface {
	// CreateConnection creates a connection from a raw connection (e.g., *websocket.Conn)
	CreateConnection(rawConn interface{}) (RealtimeConnection, error)
	// CreateEventHandler creates an event handler
	CreateEventHandler(relayServer interface{}) RealtimeEventHandler
	// CreateTestableEventHandler creates a testable event handler
	CreateTestableEventHandler(relayServer interface{}) TestableRealtimeEventHandler
	// CreateSubscriptionController creates a subscription controller
	CreateSubscriptionController(eventHandler RealtimeEventHandler) RealtimeSubscriptionController
}

type RealtimeConnection interface {
	// WriteMessage sends a message through the connection
	WriteMessage(msgType int, data []byte) error
	// Close closes the connection
	Close() error
	// IsOpen returns true if the connection is still open
	IsOpen() bool
}

type RealtimeEventHandler interface {
	// Signal sends a process event to all registered listeners
	Signal(process *core.Process)
	// Subscribe registers a subscription and returns channels for process events and errors
	Subscribe(executorType string, state int, processID string, ctx context.Context) (chan *core.Process, chan error)
	// WaitForProcess waits for a specific process state change
	WaitForProcess(executorType string, state int, processID string, ctx context.Context) (*core.Process, error)
	// Stop stops the event handler
	Stop()
}

type RealtimeSubscription struct {
	Connection   RealtimeConnection
	MsgType      int
	Timeout      int
	ExecutorType string
	State        int
	ProcessID    string
}

type RealtimeSubscriptionController interface {
	// AddProcessesSubscriber adds a subscription for all processes of a certain type
	AddProcessesSubscriber(executorID string, subscription *RealtimeSubscription) error
	// AddProcessSubscriber adds a subscription for a specific process
	AddProcessSubscriber(executorID string, process *core.Process, subscription *RealtimeSubscription) error
}

type ResponseWriter interface {
	http.ResponseWriter

	// Additional methods that some frameworks provide
	Size() int
	Status() int
	Written() bool
	WriteHeaderNow()
}

type Server interface {
	// Server lifecycle
	ListenAndServe() error
	ListenAndServeTLS(certFile, keyFile string) error
	Shutdown(ctx context.Context) error
	ShutdownWithTimeout(timeout time.Duration) error

	// Configuration
	SetAddr(addr string)
	GetAddr() string
	SetReadTimeout(timeout time.Duration)
	SetWriteTimeout(timeout time.Duration)
	SetIdleTimeout(timeout time.Duration)
	SetReadHeaderTimeout(timeout time.Duration)

	// Access to underlying components
	Engine() Engine
	HTTPServer() *http.Server
}

type TestableRealtimeEventHandler interface {
	RealtimeEventHandler
	// NumberOfListeners returns listener counts for testing
	NumberOfListeners(executorType string, state int) (int, int, int)
	// HasStopped returns whether the handler has stopped for testing
	HasStopped() bool
}