package utils

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"reflect"
	"strconv"
	"strings"
	"time"

	"git.rosy.net.cn/baseapi"

	"github.com/satori/go.uuid"
)

func GetConcretValue(value reflect.Value) reflect.Value {
	for {
		if value.Kind() == reflect.Interface || value.Kind() == reflect.Ptr {
			value = value.Elem()
		} else {
			break
		}
	}
	return value
}

func DictKeysMan(data interface{}, keysToRemove []string, keysToKeep []string) interface{} {
	if data == nil || (keysToKeep == nil && keysToRemove == nil) {
		return data
	}

	var keysToRemoveMap map[string]int
	var keysToKeepMap map[string]int
	if keysToKeep != nil {
		keysToKeepMap = make(map[string]int)
		for _, v := range keysToKeep {
			keysToKeepMap[v] = 1
		}
	} else if keysToRemove != nil {
		keysToRemoveMap = make(map[string]int)
		for _, v := range keysToRemove {
			keysToRemoveMap[v] = 1
		}
	}

	dataIsSlice := true
	valueOfData := reflect.ValueOf(data)
	if valueOfData.Kind() != reflect.Slice {
		dataIsSlice = false
		valueOfData = reflect.ValueOf([]interface{}{data})
	} else if valueOfData.Len() == 0 {
		return data
	}

	retVal := make([]interface{}, valueOfData.Len())

	for index := 0; index < valueOfData.Len(); index++ {
		realV := GetConcretValue(valueOfData.Index(index))
		if keysToRemoveMap != nil || keysToKeepMap != nil {
			mapV := make(map[string]interface{})
			for _, key := range realV.MapKeys() {
				fieldName := key.String()
				wantThisField := true
				if keysToKeepMap != nil {
					if _, ok := keysToKeepMap[fieldName]; !ok {
						wantThisField = false
					}
				} else if keysToRemoveMap != nil {
					if _, ok := keysToRemoveMap[fieldName]; ok {
						wantThisField = false
					}
				}
				if wantThisField {
					mapV[fieldName] = GetConcretValue(realV.MapIndex(key)).Interface()
				}
			}
			retVal[index] = mapV
		} else {
			retVal[index] = realV.Interface()
		}
	}

	if !dataIsSlice {
		return retVal[0]
	}
	return retVal
}

func UnmarshalUseNumber(data []byte, result interface{}) error {
	d := json.NewDecoder(bytes.NewReader(data))
	d.UseNumber()
	return d.Decode(result)
}

func MustMarshal(obj interface{}) []byte {
	byteArr, err := json.Marshal(obj)
	if err != nil {
		panic(fmt.Sprintf("err when Marshal obj:%v", obj))
	}

	return byteArr
}

func Bool2String(value bool) string {
	if value {
		return "true"
	}
	return "false"
}

func Str2Int(str string) int {
	retVal, _ := strconv.Atoi(str)
	return retVal
}

func Str2Int64(str string) int64 {
	retVal, _ := strconv.ParseInt(str, 10, 64)
	return retVal
}

func Int64ToStr(value int64) string {
	return strconv.FormatInt(value, 10)
}

func Int2Str(value int) string {
	return strconv.Itoa(value)
}

// 去除-号，全部大写，比如：929ADB626EB911E893E452540009DAB3
func GetUUID() string {
	return strings.ToUpper(strings.Replace(uuid.Must(uuid.NewV1()).String(), "-", "", -1))
}

func GetCurTimeStr() string {
	return time.Now().Format("2006-01-02 15:04:05")
}

func GetCurTimestamp() int64 {
	return time.Now().Unix()
}

func GetAPIOperator() string {
	return time.Now().Format("2006-01-02_15:04:05")
}

func Timestamp2Str(timestamp int64) string {
	return time.Unix(timestamp/1000, 0).Format("2006-01-02 15:04:05")
}

func HttpResponse2Json(response *http.Response) (map[string]interface{}, error) {
	var jsonResult map[string]interface{}
	bodyData, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}

	err = UnmarshalUseNumber(bodyData, &jsonResult)
	if err != nil {
		return nil, err
	}
	return jsonResult, nil
}

func MustInterface2Int64(data interface{}) int64 {
	dataNumber, ok := data.(json.Number)
	if !ok {
		panic(fmt.Sprintf("error when convert:%v", data))
	}
	retVal, err := dataNumber.Int64()
	if err != nil {
		panic(err.Error())
	}
	return retVal
}

func MergeMaps(firstMap map[string]interface{}, otherMaps ...map[string]interface{}) (retVal map[string]interface{}) {
	retVal = make(map[string]interface{})
	allMaps := append(otherMaps, firstMap)
	for _, oneMap := range allMaps {
		for k, v := range oneMap {
			retVal[k] = v
		}
	}

	return retVal
}

func CallFuncLogError(funcToCall func() error, msg string) {
	err := funcToCall()
	if err != nil {
		baseapi.SugarLogger.Warnf("%s, error:%v", err.Error())
	}
}