package logic

import (
	"SciencesServer/utils"
	"strings"
	"sync"
)

type Memory struct {
	cache       map[string]interface{}
	cacheList   []interface{}
	cacheSorted map[string][]*ScoreParams
	locker      *sync.RWMutex
}

func (this *Memory) Set(key string, value interface{}, expiration int) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	this.cache[key] = value
	return nil
}

// Get
func (this *Memory) Get(key string) (string, error) {
	this.locker.RLock()
	defer this.locker.RUnlock()
	data, has := this.cache[key]

	if !has {
		return "", nil
	}
	return utils.AnyToJSON(data), nil
}

// Del
func (this *Memory) Del(key string) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	delete(this.cache, key)
	return nil
}

func (this *Memory) ZAdd(key string, members ...*ScoreParams) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	if _, has := this.cacheSorted[key]; !has {
		this.cacheSorted[key] = members
	} else {
		this.cacheSorted[key] = append(this.cacheSorted[key], members...)
	}
	return nil
}

func (this *Memory) ZRangebyscore(key string, opt *ScoreRangeBy) ([]string, error) {
	this.locker.Lock()
	defer this.locker.Unlock()
	if _, has := this.cacheSorted[key]; !has {
		return []string{}, nil
	}
	out := make([]string, 0)

	function := func(src string) (float64, bool) {
		contain := false

		if strings.Contains(opt.Min, "(") {
			src = strings.Replace(src, "(", "", 1)
			contain = true
		}
		f, _ := utils.StringToFloat(src)
		return f, contain
	}
	min, minContain := function(opt.Min)
	max, maxContain := function(opt.Max)

	for _, v := range this.cacheSorted[key] {
		if ((v.Score >= min && minContain) || v.Score > min) &&
			((v.Score <= max && maxContain) || v.Score < max) {
			out = append(out, utils.AnyToJSON(v.Member))

			if opt.Count > 0 && int64(len(out)) > opt.Count {
				return out, nil
			}
		}
	}
	return out, nil
}

func (this *Memory) ZRem(key string, members ...interface{}) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	if _, has := this.cacheSorted[key]; !has {
		return nil
	}
	for k, v := range this.cacheSorted[key] {
		for _, member := range members {
			if v.Member == member {
				this.cacheSorted[key] = append(this.cacheSorted[key][:k], this.cacheSorted[key][k+1:]...)
				break
			}
		}
	}
	return nil
}

// HExists HASH Exist
func (this *Memory) HExists(key, field string) (bool, error) {
	return this.cache[key] != nil, nil
}

// HSet HASH Set
func (this *Memory) HSet(key, field string, value interface{}) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	this.cache[key] = value
	return nil
}

// HGet Hash Get
func (this *Memory) HGet(key, field string) (string, error) {
	this.locker.RLock()
	defer this.locker.RUnlock()
	data, has := this.cache[key]

	if !has {
		return "", nil
	}
	return utils.AnyToJSON(data), nil
}

// HDel HASH Del
func (this *Memory) HDel(key string, fields ...string) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	delete(this.cache, key)
	return nil
}

// SAdd
func (this *Memory) SAdd(key string, members ...interface{}) error {
	this.locker.Lock()
	defer this.locker.Unlock()
	this.cacheList = append(this.cacheList, members...)
	return nil
}

// SIsMember
func (this *Memory) SIsMember(key string, members interface{}) (bool, error) {
	this.locker.RLock()
	defer this.locker.RUnlock()
	return utils.InArray(members, this.cacheList), nil
}

// SRem
func (this *Memory) SRem(key string, members ...interface{}) error {
	this.locker.Lock()
	defer this.locker.Unlock()

	for k, v := range this.cacheList {
		if utils.InArray(v, members) {
			this.cacheList = append(this.cacheList[:k], this.cacheList[k+1:]...)
		}
	}
	return nil
}

func (this *Memory) Run() error {
	return nil
}

func NewMemory() *Memory {
	return &Memory{
		cache:       make(map[string]interface{}, 0),
		cacheList:   make([]interface{}, 0),
		cacheSorted: make(map[string][]*ScoreParams, 0),
		locker:      new(sync.RWMutex),
	}
}