plugins

type Backend interface {
	// Write writes a log entry to the backend
	Write(entry []byte) (int, error)

	// Flush ensures all buffered data is written
	Flush() error

	// Close closes the backend
	Close() error

	// SupportsAtomic returns whether the backend supports atomic writes
	SupportsAtomic() bool

	// Name returns the plugin name
	Name() string

	// Version returns the plugin version
	Version() string

	// Configure configures the plugin with options
	Configure(options map[string]interface{}) error
}

type BackendFactory func(config map[string]interface{}) (Backend, error)

type BackendPlugin interface {
	Plugin
	Backend

	// CreateBackend creates a new backend instance
	CreateBackend(uri string, config map[string]interface{}) (Backend, error)

	// SupportedSchemes returns URI schemes this plugin supports
	SupportedSchemes() []string
}

type DestinationOption func(map[string]interface{})

type Discovery interface {
	// DiscoverPlugins discovers plugins in the specified paths
	DiscoverPlugins(paths []string) ([]PluginInfo, error)

	// LoadPlugin loads a plugin from a file
	LoadPlugin(path string) (Plugin, error)

	// ValidatePlugin validates a plugin before loading
	ValidatePlugin(path string) error
}

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

type Filter interface {
	// ShouldLog determines if a message should be logged
	ShouldLog(level int, message string, fields map[string]interface{}) bool

	// Name returns the filter name
	Name() string

	// Configure configures the filter with options
	Configure(options map[string]interface{}) error
}

type FilterFactory func(config map[string]interface{}) (Filter, error)

type FilterPlugin interface {
	Plugin
	Filter

	// CreateFilter creates a new filter instance
	CreateFilter(config map[string]interface{}) (types.FilterFunc, error)

	// FilterType returns the filter type name
	FilterType() string
}

type Formatter interface {
	// Format formats a log message
	Format(msg types.LogMessage) ([]byte, error)

	// Name returns the formatter name
	Name() string

	// Configure configures the formatter with options
	Configure(options map[string]interface{}) error
}

type FormatterFactory func(config map[string]interface{}) (Formatter, error)

type FormatterPlugin interface {
	Plugin
	Formatter

	// CreateFormatter creates a new formatter instance
	CreateFormatter(config map[string]interface{}) (Formatter, error)

	// FormatName returns the format name (e.g., "xml", "protobuf")
	FormatName() string
}

type HealthStatus struct {
	Healthy bool
	Message string
	Details map[string]interface{}
}

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

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

type ManagerInterface interface {
	// RegisterBackend registers a backend plugin
	RegisterBackend(name string, factory BackendFactory) error

	// RegisterFilter registers a filter plugin
	RegisterFilter(name string, factory FilterFactory) error

	// RegisterFormatter registers a formatter plugin
	RegisterFormatter(name string, factory FormatterFactory) error

	// GetBackend gets a backend plugin by name
	GetBackend(name string) (Backend, error)

	// GetFilter gets a filter plugin by name
	GetFilter(name string) (Filter, error)

	// GetFormatter gets a formatter plugin by name
	GetFormatter(name string) (Formatter, error)

	// ListPlugins returns a list of all registered plugins
	ListPlugins() []PluginInfo

	// LoadFromDirectory loads plugins from a directory
	LoadFromDirectory(dir string) error

	// UnloadPlugin unloads a plugin by name
	UnloadPlugin(name string) error
}

type Plugin interface {
	// Name returns the plugin name
	Name() string

	// Version returns the plugin version
	Version() string

	// Description returns a description of what the plugin does
	Description() string

	// Initialize initializes the plugin
	Initialize(config map[string]interface{}) error

	// Shutdown gracefully shuts down the plugin
	Shutdown(ctx context.Context) error

	// Health returns the health status of the plugin
	Health() HealthStatus
}

type PluginCapabilities struct {
	BackendSchemes []string `json:"backend_schemes"`
	FormatNames    []string `json:"format_names"`
	FilterTypes    []string `json:"filter_types"`
	PluginCount    int      `json:"plugin_count"`
}

type PluginInfo struct {
	Name        string                 `json:"name"`
	Version     string                 `json:"version"`
	Type        string                 `json:"type"` // "backend", "filter", "formatter"
	Description string                 `json:"description"`
	Status      string                 `json:"status"` // "loaded", "unloaded", "error"
	Details     map[string]interface{} `json:"details,omitempty"`
}

type PluginMetadata struct {
	Name         string   `json:"name"`
	Version      string   `json:"version"`
	Description  string   `json:"description"`
	Author       string   `json:"author"`
	License      string   `json:"license"`
	Homepage     string   `json:"homepage"`
	Type         string   `json:"type"`                  // backend, formatter, filter
	Schemes      []string `json:"schemes,omitempty"`     // For backend plugins
	FormatName   string   `json:"format_name,omitempty"` // For formatter plugins
	FilterType   string   `json:"filter_type,omitempty"` // For filter plugins
	Dependencies []string `json:"dependencies,omitempty"`
}

type PluginSpec struct {
	Name   string                 `json:"name"`
	Path   string                 `json:"path,omitempty"`
	URL    string                 `json:"url,omitempty"`
	Config map[string]interface{} `json:"config,omitempty"`
}