package session

import (
	"sync"
	"time"

	sessionpkg "github.com/noahlann/nnet/pkg/session"
)

// SessionImpl Session实现
type SessionImpl struct {
	id         string
	data       map[string]interface{}
	mu         sync.RWMutex
	createdAt  time.Time
	accessedAt time.Time
	isNew      bool
}

// NewSession 创建新Session
func NewSession(id string) sessionpkg.Session {
	now := time.Now()
	return &SessionImpl{
		id:         id,
		data:       make(map[string]interface{}),
		createdAt:  now,
		accessedAt: now,
		isNew:      true,
	}
}

// ID 获取Session ID
func (s *SessionImpl) ID() string {
	return s.id
}

// Get 获取值
func (s *SessionImpl) Get(key string) (interface{}, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	s.accessedAt = time.Now()
	return s.data[key], nil
}

// Set 设置值
func (s *SessionImpl) Set(key string, value interface{}) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.accessedAt = time.Now()
	if s.data == nil {
		s.data = make(map[string]interface{})
	}
	s.data[key] = value
	return nil
}

// Delete 删除值
func (s *SessionImpl) Delete(key string) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.accessedAt = time.Now()
	delete(s.data, key)
	return nil
}

// Clear 清空所有值
func (s *SessionImpl) Clear() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.accessedAt = time.Now()
	s.data = make(map[string]interface{})
	return nil
}

// IsNew 检查是否是新的Session
func (s *SessionImpl) IsNew() bool {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.isNew
}

// SetNew 设置是否为新Session
func (s *SessionImpl) SetNew(isNew bool) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.isNew = isNew
}

// Data 获取所有数据（内部使用）
func (s *SessionImpl) Data() map[string]interface{} {
	s.mu.RLock()
	defer s.mu.RUnlock()
	result := make(map[string]interface{})
	for k, v := range s.data {
		result[k] = v
	}
	return result
}

// SetData 设置所有数据（内部使用）
func (s *SessionImpl) SetData(data map[string]interface{}) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.data = data
	s.accessedAt = time.Now()
}

// AccessedAt 获取最后访问时间
func (s *SessionImpl) AccessedAt() time.Time {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.accessedAt
}

// CreatedAt 获取创建时间
func (s *SessionImpl) CreatedAt() time.Time {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.createdAt
}

// SetCreatedAt 设置创建时间（内部使用）
func (s *SessionImpl) SetCreatedAt(t time.Time) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.createdAt = t
}