package repo

import (
	"sort"

	"browser.local/platform/domain"
)

type memoryGameClientBridgeCommandRepository struct {
	*memoryRepository[domain.GameClientBridgeCommand, domain.GameClientBridgeCommandFilter]
}

func newMemoryGameClientBridgeCommandRepository() *memoryGameClientBridgeCommandRepository {
	return &memoryGameClientBridgeCommandRepository{memoryRepository: newMemoryRepository(
		func(command domain.GameClientBridgeCommand) string { return command.ID },
		domain.CopyGameClientBridgeCommand,
		matchGameClientBridgeCommand,
	)}
}

func (repository *memoryGameClientBridgeCommandRepository) GetByIdempotency(serverInstanceID, requesterID, commandType, idempotencyKey string) (domain.GameClientBridgeCommand, error) {
	values, err := repository.List(domain.GameClientBridgeCommandFilter{ServerInstanceID: serverInstanceID, RequesterID: requesterID, CommandType: commandType, IdempotencyKey: idempotencyKey})
	if err != nil {
		return domain.GameClientBridgeCommand{}, err
	}
	if len(values) == 0 {
		return domain.GameClientBridgeCommand{}, ErrNotFound
	}
	return values[0], nil
}

type persistentGameClientBridgeCommandRepository struct {
	*persistentRepository[domain.GameClientBridgeCommand, domain.GameClientBridgeCommandFilter]
	repository GameClientBridgeCommandRepository
}

func (repository *persistentGameClientBridgeCommandRepository) GetByIdempotency(serverInstanceID, requesterID, commandType, idempotencyKey string) (domain.GameClientBridgeCommand, error) {
	return repository.repository.GetByIdempotency(serverInstanceID, requesterID, commandType, idempotencyKey)
}

type memoryGameClientBridgeSnapshotRepository struct {
	*memoryRepository[domain.GameClientBridgeSnapshot, domain.GameClientBridgeSnapshotFilter]
}

func newMemoryGameClientBridgeSnapshotRepository() *memoryGameClientBridgeSnapshotRepository {
	return &memoryGameClientBridgeSnapshotRepository{memoryRepository: newMemoryRepository(
		func(snapshot domain.GameClientBridgeSnapshot) string { return snapshot.ID },
		domain.CopyGameClientBridgeSnapshot,
		matchGameClientBridgeSnapshot,
	)}
}

func (repository *memoryGameClientBridgeSnapshotRepository) List(filter domain.GameClientBridgeSnapshotFilter) ([]domain.GameClientBridgeSnapshot, error) {
	limit := filter.Limit
	filter.Limit = 0
	values, err := repository.memoryRepository.List(filter)
	if err != nil {
		return nil, err
	}
	sort.SliceStable(values, func(left, right int) bool {
		if !values[left].ObservedAt.Equal(values[right].ObservedAt) {
			return values[left].ObservedAt.After(values[right].ObservedAt)
		}
		if values[left].Sequence != values[right].Sequence {
			return values[left].Sequence > values[right].Sequence
		}
		return values[left].ID < values[right].ID
	})
	if limit > 0 && len(values) > limit {
		values = values[:limit]
	}
	return values, nil
}