package store

import (
	"sync"

	"git.flowmade.one/flowmade-one/aether"
)

// InMemoryEventStore provides a simple in-memory event store for testing
type InMemoryEventStore struct {
	mu     sync.RWMutex
	events map[string][]*aether.Event // actorID -> events
}

// NewInMemoryEventStore creates a new in-memory event store
func NewInMemoryEventStore() *InMemoryEventStore {
	return &InMemoryEventStore{
		events: make(map[string][]*aether.Event),
	}
}

// SaveEvent saves an event to the in-memory store
func (es *InMemoryEventStore) SaveEvent(event *aether.Event) error {
	es.mu.Lock()
	defer es.mu.Unlock()

	if _, exists := es.events[event.ActorID]; !exists {
		es.events[event.ActorID] = make([]*aether.Event, 0)
	}
	es.events[event.ActorID] = append(es.events[event.ActorID], event)
	return nil
}

// GetEvents retrieves events for an actor from a specific version
func (es *InMemoryEventStore) GetEvents(actorID string, fromVersion int64) ([]*aether.Event, error) {
	es.mu.RLock()
	defer es.mu.RUnlock()

	events, exists := es.events[actorID]
	if !exists {
		return []*aether.Event{}, nil
	}

	var filteredEvents []*aether.Event
	for _, event := range events {
		if event.Version >= fromVersion {
			filteredEvents = append(filteredEvents, event)
		}
	}

	return filteredEvents, nil
}

// GetLatestVersion returns the latest version for an actor
func (es *InMemoryEventStore) GetLatestVersion(actorID string) (int64, error) {
	es.mu.RLock()
	defer es.mu.RUnlock()

	events, exists := es.events[actorID]
	if !exists || len(events) == 0 {
		return 0, nil
	}

	latestVersion := int64(0)
	for _, event := range events {
		if event.Version > latestVersion {
			latestVersion = event.Version
		}
	}

	return latestVersion, nil
}