package cache

import (
	"sync"

	"github.com/zelenin/go-tdlib/client"
)

// Cache allows operating the chats and users cache in
// a thread-safe manner
type Cache struct {
	chats     map[int64]*client.Chat
	users     map[int32]*client.User
	chatsLock sync.Mutex
	usersLock sync.Mutex
}

// NewCache initializes a cache
func NewCache() *Cache {
	return &Cache{
		chats: map[int64]*client.Chat{},
		users: map[int32]*client.User{},
	}
}

// ChatsKeys grabs chat ids synchronously to avoid lockups
// while they are used
func (cache *Cache) ChatsKeys() []int64 {
	cache.chatsLock.Lock()
	defer cache.chatsLock.Unlock()

	var keys []int64
	for id := range cache.chats {
		keys = append(keys, id)
	}
	return keys
}

// UsersKeys grabs user ids synchronously to avoid lockups
// while they are used
func (cache *Cache) UsersKeys() []int32 {
	cache.usersLock.Lock()
	defer cache.usersLock.Unlock()

	var keys []int32
	for id := range cache.users {
		keys = append(keys, id)
	}
	return keys
}

// GetChat retrieves chat by id if it's present in the cache
func (cache *Cache) GetChat(id int64) (*client.Chat, bool) {
	cache.chatsLock.Lock()
	defer cache.chatsLock.Unlock()

	chat, ok := cache.chats[id]
	return chat, ok
}

// GetUser retrieves user by id if it's present in the cache
func (cache *Cache) GetUser(id int32) (*client.User, bool) {
	cache.usersLock.Lock()
	defer cache.usersLock.Unlock()

	user, ok := cache.users[id]
	return user, ok
}

// SetChat stores a chat in the cache
func (cache *Cache) SetChat(id int64, chat *client.Chat) {
	cache.chatsLock.Lock()
	defer cache.chatsLock.Unlock()

	cache.chats[id] = chat
}

// SetUser stores a user in the cache
func (cache *Cache) SetUser(id int32, user *client.User) {
	cache.usersLock.Lock()
	defer cache.usersLock.Unlock()

	cache.users[id] = user
}