interfaces

type AppConfigDecoder interface {
	DecodeApp() (*appv1.App, error)
}

type AppInfo struct {
	// ID is the unique identifier of the application instance.
	ID string `json:"id" yaml:"id" mapstructure:"id"`
	// Name is the name of the application.
	Name string `json:"name" yaml:"name" mapstructure:"name"`
	// Version is the version of the application.
	Version string `json:"version" yaml:"version" mapstructure:"version"`
	// Env is the environment the application is running in (e.g., "dev", "test", "prod").
	Env string `json:"env" yaml:"env" mapstructure:"env"`
	// StartTime is the time when the application started. This is a runtime generated value.
	StartTime time.Time `json:"-" yaml:"-" mapstructure:"-"` // Mark as non-configurable
	// Metadata is a collection of arbitrary key-value pairs.
	Metadata map[string]string `json:"metadata" yaml:"metadata" mapstructure:"metadata"`
}

type Client interface{}

type ComponentFactory func(cfg StructuredConfig, container Container) (interface{}, error)

type Config interface {
	// Load loads the configuration from its source.
	Load() error

	// Decode provides generic decoding of a configuration key into a target struct.
	// This is the fundamental method that MUST be implemented by any Config instance.
	Decode(key string, value any) error

	// Raw provides an "escape hatch" to the underlying Kratos config.Config instance.
	// Custom implementations can return nil if not applicable.
	Raw() any

	// Close releases any resources held by the configuration.
	// MUST be implemented; can be a no-op if no resources are held.
	Close() error
}

type Container interface {

	// Discoveries returns a map of all configured service discovery components.
	Discoveries() map[string]registry.Discovery

	// Discovery returns a discovery client by name.
	Discovery(name string) (registry.Discovery, bool)

	// Registrars returns a map of all configured service registrar components.
	Registrars() map[string]registry.Registrar

	// Registrar returns a registrar by name.
	Registrar(name string) (registry.Registrar, bool)

	// DefaultRegistrar returns the default service registrar, used for service self-registration.
	// It may be nil if no default registry is configured.
	DefaultRegistrar() registry.Registrar

	// ServerMiddlewares returns a map of all configured server middlewares.
	ServerMiddlewares() map[string]middleware.Middleware

	// ServerMiddleware returns a server middleware by name.
	ServerMiddleware(name string) (middleware.Middleware, bool)

	// ClientMiddlewares returns a map of all configured client middlewares.
	ClientMiddlewares() map[string]middleware.Middleware

	// ClientMiddleware returns a client middleware by name.
	ClientMiddleware(name string) (middleware.Middleware, bool)

	// StorageProvider returns the configured storage provider.
	StorageProvider() storage.Provider

	// Component retrieves a generic component by its registered name.
	// This allows for future components to be added without changing the interface.
	Component(name string) (component interface{}, ok bool)
}

type DataConfigDecoder interface {
	DecodeData() (*datav1.Data, error)
}

type DiscoveriesConfigDecoder interface {
	DecodeDefaultDiscovery() (string, error)
	DecodeDiscoveries() (*discoveryv1.Discoveries, error)
}

type Encoder func(v any) ([]byte, error)

type KMiddleware = middleware.Middleware

type LoggerConfigDecoder interface {
	DecodeLogger() (*loggerv1.Logger, error)
}

type Mailer interface {
	Send(msg *Message) error
}

type Message struct {
	From    string
	To      []string
	Cc      []string
	Bcc     []string
	Subject string
	Body    string
	HTML    bool
}

type MiddlewareBuilder interface {
	factory.Registry[MiddlewareFactory]
	BuildClientMiddlewares(*middlewarev1.Middlewares, ...options.Option) []KMiddleware
	BuildServerMiddlewares(*middlewarev1.Middlewares, ...options.Option) []KMiddleware
}

type MiddlewareConfigDecoder interface {
	DecodeMiddlewares() (*middlewarev1.Middlewares, error)
}

type MiddlewareFactory interface {
	// NewMiddlewareClient builds a client-side middleware.
	NewMiddlewareClient(*middlewarev1.Middleware, ...options.Option) (KMiddleware, bool)
	// NewMiddlewareServer builds a server-side middleware.
	NewMiddlewareServer(*middlewarev1.Middleware, ...options.Option) (KMiddleware, bool)
}

type Server interface {
	transport.Server // <-- 核心：确保与 Kratos App 的完全兼容
}

type ServiceConfigDecoder interface {
	DecodeServers() (*transportv1.Servers, error)
	DecodeClients() (*transportv1.Clients, error)
}

type StructuredConfig interface {
	AppConfigDecoder
	DataConfigDecoder
	DiscoveriesConfigDecoder
	LoggerConfigDecoder
	MiddlewareConfigDecoder
	ServiceConfigDecoder
}