sdk

type ConnectionEvent struct {
	// Type is the type of change that happened to the connection data
	// TODO: change to enum
	Type string // 'SYNC', 'CREATE', 'DELETE'

	// Data is the series of connection data associated with the update event
	Data []pkgtypes.Connection
}

type ConnectionManager interface {
	// ListConnections should list all of the connections available from the plugin
	ListConnections(ctx pkgtypes.PluginContext) ([]pkgtypes.Connection, error)

	// GetConnection should take a unique ID and return the connection data for that connection
	GetConnection(ctx pkgtypes.PluginContext, id string) (pkgtypes.Connection, error)

	// UpdateConnections should take a map of change data, with the keys being unique IDs of connetion and the values being new connection
	// data, and return the map of new, full data
	UpdateConnections(
		ctx pkgtypes.PluginContext,
		data map[string]pkgtypes.Connection,
	) (map[string]pkgtypes.Connection, error)

	// DeleteConnections should take an array of connection ID's to delete, and return a map of connection ID to states.
	DeleteConnections(ctx pkgtypes.PluginContext, ids []string) map[string]error

	// SubscribeConnections should stream changes to underlying connection data so that the IDE can respond in real time to changes
	// to connections. This function should initiate any watchers (such as a inotify watcher on credential files) to submit to the passed
	// in channel.
	SubscribeConnections(ctx pkgtypes.PluginContext, reciever chan []ConnectionEvent) error
}

type DevInfo struct {
	PID             int       `json:"pid"`
	Protocol        string    `json:"protocol"`
	ProtocolVersion int       `json:"protocolVersion"`
	Addr            string    `json:"addr"`
	VitePort        int       `json:"vitePort,omitempty"`
	PluginID        string    `json:"pluginId"`
	Version         string    `json:"version"`
	StartedAt       time.Time `json:"startedAt"`
}

type Plugin struct {
	// settingsProvider is the settings provider for the plugin.
	SettingsProvider pkgsettings.Provider

	Logger    *zap.SugaredLogger
	HCLLogger hclog.Logger
	// contains filtered or unexported fields
}

type PluginOpts struct {
	// ID is the unique identifier for the plugin
	ID string

	// Settings is a list of settings to be used by the plugin
	Settings []pkgsettings.Setting

	// Debug is the debug mode for the plugin
	Debug bool
}

type ResourcePluginOpts[ClientT any] struct {
	// LoadConnectionFunc is a function that will be called to load the possible connections
	// for the resource plugin.
	LoadConnectionFunc           func(*pkgtypes.PluginContext) ([]pkgtypes.Connection, error)
	LoadConnectionNamespacesFunc func(*pkgtypes.PluginContext, *ClientT) ([]string, error)
	CheckConnectionFunc          func(*pkgtypes.PluginContext, *pkgtypes.Connection, *ClientT) (pkgtypes.ConnectionStatus, error)
	WatchConnectionsFunc         func(*pkgtypes.PluginContext) (chan []pkgtypes.Connection, error)

	// CreateClient creates a new client for a connection. Required.
	CreateClient func(*pkgtypes.PluginContext) (*ClientT, error)
	// RefreshClient refreshes an existing client (e.g., rotate credentials). Optional; if nil, not called.
	RefreshClient func(*pkgtypes.PluginContext, *ClientT) error
	// StartClient is called when a connection starts. Optional; if nil, no-op.
	StartClient func(*pkgtypes.PluginContext, *ClientT) error
	// StopClient is called when a connection stops. Optional; if nil, no-op.
	StopClient func(*pkgtypes.PluginContext, *ClientT) error

	// DiscoveryProvider handles dynamic resource type discovery. If nil, a static type manager is used.
	DiscoveryProvider types.DiscoveryProvider

	// Resourcers is a map of resource metadata to resourcers that the plugin will manage.
	Resourcers map[types.ResourceMeta]types.Resourcer[ClientT]

	// PatternResourcers is a map of pattern resourcers to use as fallbacks when a registered resourcer is not available.
	PatternResourcers map[string]types.Resourcer[ClientT]

	// ResourceGroups is an optional array of resource groups to provide more details about the groups.
	ResourceGroups []types.ResourceGroup

	// ResourceDefinitions is a map of resource names to their definitions.
	ResourceDefinitions map[string]types.ResourceDefinition

	// DefaultResourceDefinition is the default resource definition to use for resources that do not have
	// a specific definition.
	DefaultResourceDefinition types.ResourceDefinition

	// SyncPolicies maps resource keys to their sync policy.
	// Resources not in this map default to SyncOnConnect.
	SyncPolicies map[string]types.InformerSyncPolicy

	// CreateInformerFunc creates an InformerHandle for a given connection client. If nil, informers are disabled.
	CreateInformerFunc types.CreateInformerHandleFunc[ClientT]

	// SchemaFunc is an optional connection-level schema provider. When set, it is called
	// with the connection client to return editor schemas (e.g., OpenAPI specs from a K8s cluster).
	// These are merged with any per-resourcer schemas from SchemaResourcer implementations.
	SchemaFunc func(*pkgtypes.PluginContext, *ClientT) ([]types.EditorSchema, error)

	// ErrorClassifier is an optional function that classifies raw errors from
	// resource operations into structured ResourceOperationError values.
	// When set, the gRPC server calls it before falling back to a generic INTERNAL error.
	ErrorClassifier func(error) error

	// LayoutOpts allows for customizing the layout within the UI
	LayoutOpts *types.LayoutOpts
}