// Package streamoffsets implements the Redis-backed adapter for
// `ports.StreamOffsetStore`.
//
// The start-jobs and stop-jobs consumers call Load on startup to
// resume from the persisted offset and Save after every successful
// message handling. Keys are produced by
// `redisstate.Keyspace.StreamOffset`, mirroring the lobby pattern.
package streamoffsets

import (
	"context"
	"errors"
	"fmt"
	"strings"

	"galaxy/rtmanager/internal/adapters/redisstate"
	"galaxy/rtmanager/internal/ports"

	"github.com/redis/go-redis/v9"
)

// Config configures one Redis-backed stream-offset store instance. The
// store does not own the redis client lifecycle; the caller (typically
// the service runtime) opens and closes it.
type Config struct {
	// Client stores the Redis client the store uses for every command.
	Client *redis.Client
}

// Store persists Runtime Manager stream consumer offsets in Redis.
type Store struct {
	client *redis.Client
	keys   redisstate.Keyspace
}

// New constructs one Redis-backed stream-offset store from cfg.
func New(cfg Config) (*Store, error) {
	if cfg.Client == nil {
		return nil, errors.New("new rtmanager stream offset store: nil redis client")
	}
	return &Store{
		client: cfg.Client,
		keys:   redisstate.Keyspace{},
	}, nil
}

// Load returns the last processed entry id for streamLabel when one is
// stored. A missing key returns ("", false, nil).
func (store *Store) Load(ctx context.Context, streamLabel string) (string, bool, error) {
	if store == nil || store.client == nil {
		return "", false, errors.New("load rtmanager stream offset: nil store")
	}
	if ctx == nil {
		return "", false, errors.New("load rtmanager stream offset: nil context")
	}
	if strings.TrimSpace(streamLabel) == "" {
		return "", false, errors.New("load rtmanager stream offset: stream label must not be empty")
	}

	value, err := store.client.Get(ctx, store.keys.StreamOffset(streamLabel)).Result()
	switch {
	case errors.Is(err, redis.Nil):
		return "", false, nil
	case err != nil:
		return "", false, fmt.Errorf("load rtmanager stream offset: %w", err)
	}
	return value, true, nil
}

// Save stores entryID as the new offset for streamLabel. The key has no
// TTL — offsets are durable and only overwritten by subsequent Saves.
func (store *Store) Save(ctx context.Context, streamLabel, entryID string) error {
	if store == nil || store.client == nil {
		return errors.New("save rtmanager stream offset: nil store")
	}
	if ctx == nil {
		return errors.New("save rtmanager stream offset: nil context")
	}
	if strings.TrimSpace(streamLabel) == "" {
		return errors.New("save rtmanager stream offset: stream label must not be empty")
	}
	if strings.TrimSpace(entryID) == "" {
		return errors.New("save rtmanager stream offset: entry id must not be empty")
	}

	if err := store.client.Set(ctx, store.keys.StreamOffset(streamLabel), entryID, 0).Err(); err != nil {
		return fmt.Errorf("save rtmanager stream offset: %w", err)
	}
	return nil
}

// Ensure Store satisfies the ports.StreamOffsetStore interface at
// compile time.
var _ ports.StreamOffsetStore = (*Store)(nil)