package process

import (
	"bytes"
	"encoding/json"
	"fmt"
	"gitee.com/beijingxiugo/GolandAuto/utils"
	"github.com/bitly/go-simplejson"
	//"github.com/shopspring/decimal"
	"github.com/tidwall/gjson"
	"reflect"
)

// ToStandard transfer data into specific type
// float and int as float64
// string as string
// other do nothing
func ToStandard(val interface{}) (res interface{}) {
	defer func() {
		if e := recover(); e != nil {
			res = val
		}
	}()
	refVal := reflect.ValueOf(val)
	switch refVal.Kind() {
	case reflect.Ptr:
		if refVal.IsNil() {
			return nil
		}
		return ToStandard(refVal.Elem().Interface())
	case reflect.Float32, reflect.Float64:
		return refVal.Float()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return float64(refVal.Int())
	case reflect.Slice, reflect.Array:
		var arr []interface{}
		for i := 0; i < refVal.Len(); i++ {
			arr = append(arr, ToStandard(refVal.Index(i).Interface()))
		}
		return arr
	default:
		if num := val.(json.Number); num != "" {
			r, e := utils.String2Float64(num.String())
			if e == nil {
				return r
			} else {
				return num.String()
			}
		}
		return val
	}
}

func AsMap(got interface{}) (map[string]interface{}, error) {
	ret := make(map[string]interface{})
	_b, e := json.Marshal(got)
	if e != nil {
		return nil, e
	}

	//e = json.Unmarshal(_b, &ret)
	//if e != nil {
	//	return nil, e
	//}

	d := json.NewDecoder(bytes.NewReader(_b))
	d.UseNumber()

	e = d.Decode(&ret)
	return ret, nil
}

func MustToJsonString(val interface{}) string {
	s, e := ToJsonString(val)
	if e != nil {
		panic(e)
	}
	return s
}

func ToJsonString(val interface{}) (string, error) {
	_b, e := json.Marshal(val)
	if e != nil {
		return "", e
	}

	return fmt.Sprintf("%s", _b), nil
}

func MustAsMap(got interface{}) map[string]interface{} {
	ret, e := utils.InterfaceUnmarshalMap(got)
	if e != nil {
		panic(e)
	}
	return ret
}

func AsSimpleJson(val interface{}) (*simplejson.Json, error) {
	_b, e := json.Marshal(val)
	if e != nil {
		return nil, e
	}

	_obj, e := simplejson.NewJson(_b)
	if e != nil {
		return nil, e
	}

	return _obj, nil
}

func MustAsSimpleJson(val interface{}) *simplejson.Json {
	_obj, e := AsSimpleJson(val)
	if e != nil {
		panic(e)
	}
	return _obj
}

func ValueFromGJson(result gjson.Result) interface{} {
	// result is null
	if result.Type == gjson.Null {
		return nil
	}

	// result is array
	if result.IsArray() {
		var arr []interface{}
		for _, _eachResult := range result.Array() {
			arr = append(arr, ValueFromGJson(_eachResult))
		}
		return arr
	}

	// result is number or string
	switch result.Type {
	case gjson.Number:
		//return result.Float()
		return result.String()
	case gjson.String:
		return result.String()
	case gjson.True:
		return true
	case gjson.False:
		return false
	}

	// result is json
	m := make(map[string]interface{})
	for _key, _eachResult := range result.Map() {
		m[_key] = ValueFromGJson(_eachResult)
	}

	return m
}

func ValueFromSimpleJson(result *simplejson.Json) (res interface{}) {
	defer func() {
		if e := recover(); e != nil {
			res = result
		}
	}()
	m, e := result.Map()
	if e == nil {
		for _key, _eachResult := range m {
			sj := &simplejson.Json{}
			jsonUseNumber(_eachResult, sj)
			m[_key] = ValueFromSimpleJson(sj)
		}
	} else if arr, e := result.Array(); e == nil {
		arrNew := []interface{}{}
		for _, _eachResult := range arr {
			sj := &simplejson.Json{}
			jsonUseNumber(_eachResult, sj)
			arrNew = append(arrNew, ValueFromSimpleJson(sj))
		}
		return arrNew
	} else if b, e := result.Bool(); e == nil {
		return b
	} else {
		// result is number or string
		if s, e := result.String(); e == nil {
			return s
		}
		if num := result.Interface().(json.Number); num != "" {
			r, e := utils.String2Float64(num.String())
			if e != nil {
				return num.String()
			} else {
				return r
			}
		}
		return result
	}
	return m
}

func jsonUseNumber(source interface{}, target interface{}) {
	_b, _ := json.Marshal(source)
	d := json.NewDecoder(bytes.NewReader(_b))
	d.UseNumber()
	_ = d.Decode(target)
}