package mod

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

var (
	r   *redis.Client
	lsm *rds.LuaScriptManager
)

// 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) {
	r = client
	lsm = rds.NewLuaScriptManager(r)
}

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

func LoadUser(userId uint64) (*pb.User, error) {
	mp, err := r.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 := r.HSet(kh_user(userId), field, val).Result()
	return err
}

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

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

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

func SaveOffline(userId, logicId uint64) error {
	_, err := r.HSet(kh_offlines, strconv.FormatUint(userId, 10), logicId).Result()
	return err
}

func LoadOffline(userId uint64) (uint64, error) {
	sid, err := r.HGet(kh_offlines, strconv.FormatUint(userId, 10)).Result()
	if err != nil {
		return 0, err
	}
	return strconv.ParseUint(sid, 10, 64)
}

func SaveUserLogin(userId, agentId uint64) error {
	_, err := lsm.Exec("user_login", []string{}, userId, agentId).Result()
	return err
}

func SaveUserLogout(userId uint64) error {
	_, err := lsm.Exec("user_logout", []string{}, userId).Result()
	return err
}

func SaveUserChangeLogic(userId, logicId uint64) error {
	_, err := lsm.Exec("user_change_logic", []string{}, userId, logicId).Result()
	return err
}

func LoadUserLogic(userId uint64) (uint64, error) {
	sid, err := r.HGet(kh_user_logic, strconv.FormatUint(userId, 10)).Result()
	if err != nil {
		return 0, err
	}
	return strconv.ParseUint(sid, 10, 64)
}

func LoadUserAgent(userId uint64) (uint64, error) {
	sid, err := r.HGet(kh_user_agent, strconv.FormatUint(userId, 10)).Result()
	if err != nil {
		return 0, err
	}
	return strconv.ParseUint(sid, 10, 64)
}