package handlers

import (
	"context"
	"encoding/json"
	"errors"
	"golias/models"
)

func createRoom(ctx context.Context, req *models.RoomReq) (*models.Room, error) {
	return nil, nil
}

func getRoomByID(roomID string) (*models.Room, error) {
	roomBytes, err := memcache.Get(models.CacheRoomPrefix + roomID)
	if err != nil {
		return nil, err
	}
	resp := &models.Room{}
	if err := json.Unmarshal(roomBytes, &resp); err != nil {
		return nil, err
	}
	return resp, nil
}

// context
func getRoomIDFromCtx(ctx context.Context) string {
	id, _ := ctx.Value(models.CtxRoomIDKey).(string)
	return id
}

func getStateByCtx(ctx context.Context) (*models.UserState, error) {
	username, ok := ctx.Value(models.CtxUsernameKey).(string)
	if !ok {
		log.Debug("no username in ctx")
		return &models.UserState{}, errors.New("no username in ctx")
	}
	us, err := loadState(username)
	if err != nil {
		return &models.UserState{}, err
	}
	return us, nil
}

// cache

func saveState(username string, state *models.UserState) error {
	key := models.CacheStatePrefix + username
	data, err := json.Marshal(state)
	if err != nil {
		return err
	}
	memcache.Set(key, data)
	return nil
}

func loadState(username string) (*models.UserState, error) {
	key := models.CacheStatePrefix + username
	data, err := memcache.Get(key)
	if err != nil {
		return nil, err
	}
	resp := &models.UserState{}
	if err := json.Unmarshal(data, &resp); err != nil {
		return nil, err
	}
	return resp, nil
}

func getAllNames() []string {
	names := []string{}
	// will not scale
	wholeMemStore := memcache.GetAll()
	session := &models.Session{}
	// filter by key size only sessions
	for k, v := range wholeMemStore {
		// xid is 20 in len
		if len(k) != 20 {
			continue
		}
		if err := json.Unmarshal(v, &session); err != nil {
			log.Error("failed to unmarshal", "error", err)
			continue
		}
		names = append(names, session.Username)
	}
	return names
}