store

type BackendInfo struct {
	ID   string `json:"id"`
	Name string `json:"name"`
	Type string `json:"type"`
}

type DeleteBackendTestCase struct {
	Name        string
	Identifier  string
	BackendKey  string
	SetupFunc   func(t *testing.T, store EntityStoreInterface)
	VerifyFunc  func(t *testing.T, store EntityStoreInterface)
	WantErr     bool
	ErrContains string
}

type DeleteTestCase struct {
	Name       string
	Identifier string
	SetupFunc  func(t *testing.T, store EntityStoreInterface)
	WantErr    bool
}

type EntityStoreInterface interface {
	GetBackends(ctx context.Context, identifier string) (map[string]string, error)
	SetBackend(ctx context.Context, identifier, backendKey, backendID string) error
	DeleteBackend(ctx context.Context, identifier, backendKey string) error
	Delete(ctx context.Context, identifier string) error
	Exists(ctx context.Context, identifier string) (bool, error)
}

type ExistsTestCase struct {
	Name       string
	Identifier string
	SetupFunc  func(t *testing.T, store EntityStoreInterface)
	WantExist  bool
}

type GetBackendsTestCase struct {
	Name        string
	Identifier  string
	SetupFunc   func(t *testing.T, store EntityStoreInterface, c cache.Cache)
	Want        map[string]string
	WantErr     bool
	ErrContains string
}

type GroupData struct {
	Members  []string               `json:"members"`
	Backends map[string]BackendInfo `json:"backends"` // key: "backendName_backendType"
}

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

type GroupStoreInterface interface {
	// Get retrieves the full group data from cache
	// Returns empty GroupData if the group is not found in cache
	Get(ctx context.Context, groupName string) (*GroupData, error)

	// Set stores the full group data in cache
	Set(ctx context.Context, groupName string, data *GroupData) error

	// Delete removes a group entirely from cache
	Delete(ctx context.Context, groupName string) error

	// Exists checks if a group exists in cache
	Exists(ctx context.Context, groupName string) (bool, error)

	// GetMembers returns the list of user emails for a group
	// Returns an empty slice if the group is not found in cache
	GetMembers(ctx context.Context, groupName string) ([]string, error)

	// SetMembers sets the complete list of user emails for a group
	// This replaces any existing members while preserving backends
	SetMembers(ctx context.Context, groupName string, members []string) error

	// GetBackends returns a map of backend info for a group
	// Returns an empty map if the group is not found in cache
	// Map format: {"backend_name_type": BackendInfo{ID, Name, Type}}
	GetBackends(ctx context.Context, groupName string) (map[string]BackendInfo, error)

	// GetBackendID returns the backend ID for a specific backend
	// Returns empty string if the backend is not found
	GetBackendID(ctx context.Context, groupName, backendName, backendType string) (string, error)

	// SetBackend sets a backend for a group
	// If the group doesn't exist, it will be created
	// If the backend exists, it will be updated
	SetBackend(ctx context.Context, groupName, backendName, backendType, backendID string) error

	// DeleteBackend removes a specific backend from a group's record
	DeleteBackend(ctx context.Context, groupName, backendName, backendType string) error

	// BackendExists checks if a specific backend exists for a group
	BackendExists(ctx context.Context, groupName, backendName, backendType string) (bool, error)
}

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

type MetaStoreInterface interface {
	// GetUserList retrieves the list of user IDs from cache
	// Returns empty slice if not found
	GetUserList(ctx context.Context) ([]string, error)

	// SetUserList stores the list of user IDs in cache
	SetUserList(ctx context.Context, users []string) error
}

type SetBackendTestCase struct {
	Name        string
	Identifier  string // email for users, name for teams
	BackendKey  string
	BackendID   string
	SetupFunc   func(t *testing.T, store EntityStoreInterface)
	VerifyFunc  func(t *testing.T, store EntityStoreInterface)
	WantErr     bool
	ErrContains string
}

type Store struct {
	User       UserStoreInterface
	Team       TeamStoreInterface  // For preload with transformed team names
	Group      GroupStoreInterface // For reconciliation with original group names
	Meta       MetaStoreInterface
	UserGroups UserGroupsStoreInterface
}

type StoreInterface interface {
	// GetUserStore returns the user store operations
	GetUserStore() UserStoreInterface

	// GetTeamStore returns the team store operations (for preload with transformed names)
	GetTeamStore() TeamStoreInterface

	// GetGroupStore returns the group store operations (for reconciliation with original names)
	GetGroupStore() GroupStoreInterface

	// GetMetaStore returns the metadata store operations
	GetMetaStore() MetaStoreInterface

	// GetUserGroupsStore returns the user groups store operations
	GetUserGroupsStore() UserGroupsStoreInterface
}

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

type TeamStoreInterface interface {
	// GetBackends returns a map of backend IDs for a team
	// Returns an empty map if the team is not found in cache
	// Map format: {"backend_name_type": "backend_team_id"}
	GetBackends(ctx context.Context, teamName string) (map[string]string, error)

	// SetBackend sets a backend ID for a team
	// If the team doesn't exist, it will be created
	// If the team exists, the backend ID will be added/updated in the map
	SetBackend(ctx context.Context, teamName, backendKey, teamID string) error

	// DeleteBackend removes a specific backend ID from a team's record
	// If this was the last backend, the entire team entry is deleted
	DeleteBackend(ctx context.Context, teamName, backendKey string) error

	// Delete removes a team entirely from cache
	Delete(ctx context.Context, teamName string) error

	// Exists checks if a team exists in cache
	Exists(ctx context.Context, teamName string) (bool, error)
}

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

type UserGroupsStoreInterface interface {
	// GetGroups returns the list of groups for a user
	// Returns an empty slice if the user is not found in cache
	GetGroups(ctx context.Context, email string) ([]string, error)

	// AddGroup adds a group to a user's group list if not already present
	AddGroup(ctx context.Context, email, groupName string) error

	// SetGroups sets the complete list of groups for a user
	// This replaces any existing groups
	SetGroups(ctx context.Context, email string, groups []string) error

	// RemoveGroup removes a specific group from a user's group list
	// If this was the last group, the entry is deleted
	RemoveGroup(ctx context.Context, email, groupName string) error

	// Delete removes the user's groups entry entirely
	Delete(ctx context.Context, email string) error

	// Exists checks if a user has any groups in cache
	Exists(ctx context.Context, email string) (bool, error)
}

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

type UserStoreInterface interface {
	// GetBackends returns a map of backend IDs for a user
	// Returns an empty map if the user is not found in cache
	// Map format: {"backend_name_type": "backend_user_id"}
	GetBackends(ctx context.Context, email string) (map[string]string, error)

	// SetBackend sets a backend ID for a user
	// If the user doesn't exist, it will be created
	// If the user exists, the backend ID will be added/updated in the map
	SetBackend(ctx context.Context, email, backendKey, backendID string) error

	// DeleteBackend removes a specific backend ID from a user's record
	// If this was the last backend, the entire user entry is deleted
	DeleteBackend(ctx context.Context, email, backendKey string) error

	// Delete removes a user entirely from cache
	Delete(ctx context.Context, email string) error

	// Exists checks if a user exists in cache
	Exists(ctx context.Context, email string) (bool, error)

	// GetByPattern searches for users matching a pattern and returns their data
	// Pattern should NOT include the "user:" prefix - it will be added automatically
	// Example: pattern "*@example.com" searches for "user:*@example.com"
	// Returns: map[email]backends where backends is map[backendKey]backendID
	GetByPattern(ctx context.Context, pattern string) (map[string]map[string]string, error)
}