package util

import (
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
)

// 排序 排序键必须为数字类型
type SortBy struct {
	Data    []map[string]interface{}
	Sortkey string
}

func (a SortBy) Len() int { return len(a.Data) }

func (a SortBy) Swap(i, j int) {
	a.Data[i], a.Data[j] = a.Data[j], a.Data[i]
}

func (a SortBy) Less(i, j int) bool {
	//return Float64(a.Data[i][a.Sortkey]) < Float64(a.Data[j][a.Sortkey])
	m := a.Data[i][a.Sortkey]
	n := a.Data[j][a.Sortkey]
	w := reflect.ValueOf(m)
	v := reflect.ValueOf(n)
	switch v.Kind() {
	case reflect.String:
		return w.String() < v.String()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return w.Int() < v.Int()
	case reflect.Float64, reflect.Float32:
		return w.Float() < v.Float()
	default:
		return fmt.Sprintf("%v", w) < fmt.Sprintf("%v", v)
	}
}

// data 转换成ret
func Bind(data interface{}, ret interface{}) error {
	v := reflect.ValueOf(ret)
	if v.Kind() != reflect.Ptr {
		return fmt.Errorf("ptr input ret needed as type as input type %s", v.Kind())
	}
	havdata := false
	var bk interface{}
	if v.Elem().Kind() == reflect.Slice {
		t := reflect.Zero(reflect.TypeOf(v.Elem().Interface()))
		bk = v.Elem().Interface()
		v.Elem().Set(t)
		havdata = true
	}
	_data, _ := json.MarshalIndent(data, "", "    ")
	err := json.Unmarshal(_data, ret)
	if err != nil {
		fmt.Println(err)
		if havdata {
			v.Elem().Set(reflect.ValueOf(bk))
		}
		return err
	}
	return nil
}

//根据指定字符排序
//m := []map[string]int{
//	{"k": 2},
//	{"k": 1},
//	{"k": 3},
//}
//
//customer.SortData(&m, "k", true)
// ture  倒序3, 2, 1
//fmt.Println(m)
func SortData(data interface{}, sortkey string, reverse bool) {
	//func SortData(data interface{}, sortkey string, reverse bool) {
	var db []map[string]interface{}
	err := Bind(data, &db)
	if err != nil {
		fmt.Println(err)
		return
	}
	stb := SortBy{db, sortkey}
	if !reverse {
		sort.Sort(stb)
	} else {
		sort.Sort(sort.Reverse(stb))
	}
	err = Bind(stb.Data, data)
	if err != nil {
		fmt.Println(err)
	}

}