package mod

import (
	pb "git.wanbits.io/joe/franklin/protos"
	"git.wanbits.io/joe/kettle/utl"
	"github.com/go-redis/redis"
	"github.com/mitchellh/mapstructure"
	"reflect"
	"strings"
	"time"
)

var (
	rds *redis.Client
)

// convert ANY struct( or its pointer) to map[string]interface{}
// opt: bool. if true convert keys of struct to their lowercase
func StructToMap(stru interface{}, lowerCase ...bool) (map[string]interface{}, error) {
	conf := func(v string) string {
		return v
	}
	if len(lowerCase) > 0 && lowerCase[0] {
		conf = strings.ToLower
	}

	t := reflect.TypeOf(stru)
	vals := reflect.ValueOf(stru)
	switch t.Kind() {
	case reflect.Ptr:
		t = t.Elem()
		vals = vals.Elem()
		if t.Kind() != reflect.Struct {
			return nil, utl.ErrParameters
		}
	case reflect.Struct:
	default:
		return nil, utl.ErrParameters
	}
	rt := make(map[string]interface{})
	for i := 0; i < t.NumField(); i++ {
		fn := conf(t.Field(i).Name)
		val := vals.Field(i).Interface()
		rt[fn] = val
	}
	return rt, nil
}

func Install(client *redis.Client) {
	rds = client
}

func ExistUser(userId uint64) bool {
	ival, err := rds.Exists(kh_user(userId)).Result()
	return err == nil && ival != 0
}

func LoadUser(userId uint64) (*pb.User, error) {
	mp, err := rds.HGetAll(kh_user(userId)).Result()
	if err != nil {
		return nil, err
	}
	//mpsi := make(map[string]interface{})
	//for k, v := range mp {
	//	mpsi[k] = v
	//}
	user := &pb.User{}
	err = mapstructure.Decode(mp, user)
	return user, err
}

func UpdateUserAttr(userId uint64, field string, val interface{}) error {
	_, err := rds.HSet(kh_user(userId), field, val).Result()
	return err
}

func UpdateUserAttrs(userId uint64, fields map[string]interface{}) error {
	_, err := rds.HMSet(kh_user(userId), fields).Result()
	return err
}

func SaveKick(userId uint64, secs int) error {
	_, err := rds.Set(ks_kick(userId), 1, time.Duration(secs)*time.Second).Result()
	return err
}

func LoadKick(userId uint64) bool {
	_, err := rds.Get(ks_kick(userId)).Result()
	return err == nil
}