package session

import (
	"context"
	"sync"
	"time"
)

// MemManager : Manager en mémoire (dev/tests), avec expiration paresseuse.
type MemManager struct {
	mu    sync.RWMutex
	items map[string]entry
	ttl   time.Duration
}

type entry struct {
	s       Session
	expires time.Time
}

func NewMemManager(ttl time.Duration) *MemManager {
	return &MemManager{items: make(map[string]entry), ttl: ttl}
}

func (m *MemManager) TTL() time.Duration { return m.ttl }

func (m *MemManager) Create(_ context.Context, s Session) (string, error) {
	token, err := newToken()
	if err != nil {
		return "", err
	}
	s.CreatedAt = time.Now().UTC()
	m.mu.Lock()
	m.items[token] = entry{s: s, expires: time.Now().Add(m.ttl)}
	m.mu.Unlock()
	return token, nil
}

func (m *MemManager) Get(_ context.Context, token string) (Session, bool, error) {
	m.mu.RLock()
	e, ok := m.items[token]
	m.mu.RUnlock()
	if !ok || time.Now().After(e.expires) {
		return Session{}, false, nil
	}
	return e.s, true, nil
}

func (m *MemManager) Delete(_ context.Context, token string) error {
	m.mu.Lock()
	delete(m.items, token)
	m.mu.Unlock()
	return nil
}