// Package streamoffsets implements the Redis-backed adapter for
// `ports.StreamOffsetStore`.
//
// In v1 the only consumer that calls Load/Save is the
// runtime:health_events worker (PLAN stage 18). Keys are produced by
// `redisstate.Keyspace.StreamOffset`, mirroring the lobby and rtmanager
// patterns.
package streamoffsets

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

	"galaxy/gamemaster/internal/adapters/redisstate"
	"galaxy/gamemaster/internal/ports"

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

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

// Store persists Game Master 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 gamemaster 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 gamemaster stream offset: nil store")
	}
	if ctx == nil {
		return "", false, errors.New("load gamemaster stream offset: nil context")
	}
	if strings.TrimSpace(streamLabel) == "" {
		return "", false, errors.New("load gamemaster 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 gamemaster 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 gamemaster stream offset: nil store")
	}
	if ctx == nil {
		return errors.New("save gamemaster stream offset: nil context")
	}
	if strings.TrimSpace(streamLabel) == "" {
		return errors.New("save gamemaster stream offset: stream label must not be empty")
	}
	if strings.TrimSpace(entryID) == "" {
		return errors.New("save gamemaster 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 gamemaster stream offset: %w", err)
	}
	return nil
}

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