backends

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 HandlerFunc func(Context)

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, location string, ctx context.Context) (chan *core.Process, chan error)
	// WaitForProcess waits for a specific process state change
	WaitForProcess(executorType string, state int, processID string, location 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
	Location     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 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, location string) (int, int, int)
	// HasStopped returns whether the handler has stopped for testing
	HasStopped() bool
}