package utils

import (
	"encoding/json"
	"path/filepath"
	"strings"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type ID = primitive.ObjectID

// ToJsonM 将struct转换为 Json Map
func ToJsonM(obj interface{}) (map[string]interface{}, error) {
	j, err := json.Marshal(obj)
	if err != nil {
		return nil, err
	}
	m := make(map[string]interface{})
	if err := json.Unmarshal(j, &m); err != nil {
		return nil, err
	}
	return m, err
}

// ToBsonM 将struct转换为 Bson Map
func ToBsonM(s interface{}) (bson.M, error) {
	data, err := bson.Marshal(s)
	if err != nil {
		return nil, err
	}
	m := make(bson.M)
	if err := bson.Unmarshal(data, &m); err != nil {
		return nil, err
	}
	return m, nil
}

func MapToJsonString(m map[string]string) (string, error) {
	if data, err := json.Marshal(m); err != nil {
		return "", err
	} else {
		return string(data), nil
	}
}

func StructToJsonString(s interface{}) (string, error) {
	j, err := json.Marshal(s)
	if err != nil {
		return "", err
	}
	m := make(map[string]interface{})
	if err := json.Unmarshal(j, &m); err != nil {
		return "", err
	}
	if data, err := json.Marshal(m); err != nil {
		return "", err
	} else {
		return string(data), nil
	}
}

// BMapToStruct s is struct ptr
func BMapToStruct(s interface{}, m map[string]interface{}) error {
	bsonBytes, err := bson.Marshal(m)
	if err != nil {
		return err
	}
	return bson.Unmarshal(bsonBytes, s)
}

// JMapToStruct s is struct ptr
func JMapToStruct(s interface{}, m map[string]interface{}) error {
	bsonBytes, err := json.Marshal(m)
	if err != nil {
		return err
	}
	return json.Unmarshal(bsonBytes, s)
}

// JSONStruct2Map  将struct转换为Map
func JSONStruct2Map(obj interface{}) (map[string]interface{}, error) {
	m := make(map[string]interface{})
	j, err := json.Marshal(obj)
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(j, &m); err != nil {
		return nil, err
	}
	return m, err
}

// Map2JSONStruct  将map转换为Json struct
func Map2JSONStruct(v interface{}, m map[string]interface{}) error {
	j, err := json.Marshal(m)
	if err != nil {
		return err
	}
	if err := json.Unmarshal(j, v); err != nil {
		return err
	}
	return err
}

func IDArray(ids []string) ([]ID, error) {
	var idArray []ID
	for _, id := range ids {
		_id, err := primitive.ObjectIDFromHex(id)
		if err != nil {
			return nil, err
		}
		idArray = append(idArray, _id)
	}

	return idArray, nil
}

// 拼接https://
func BindHttpSch(path string) string {
	if strings.HasPrefix(path, "http") {
		return path
	} else {
		return "https://" + path
	}
}

func BindUrl(hostname string, path ...string) string {
	if hostname == "" {
		return strings.TrimLeft(filepath.Join(path...), "/")
	}
	if len(path) == 0 {
		return hostname
	}
	su := strings.TrimLeft(filepath.Join(path...), "/")
	pr := strings.TrimRight(hostname, "/")
	return pr + "/" + su
}

func ObjectIDs2String(obj []primitive.ObjectID) []string {
	arr := []string{}
	if len(obj) == 0 {
		return arr
	}
	for _, o := range obj {
		arr = append(arr, o.Hex())
	}
	return arr
}

func String2ObjectID(obj []string) []primitive.ObjectID {
	arr := []primitive.ObjectID{}
	for _, o := range obj {
		oid, err := primitive.ObjectIDFromHex(o)
		if err != nil {
			continue
		}
		arr = append(arr, oid)
	}
	return arr
}

// PercentOf - calculate what percent [number1] is of [number2].
// ex. 300 is 12.5% of 2400
func PercentOf(part int, total int) float64 {
	return (float64(part) * float64(100)) / float64(total)
}

func MergeMap(src, dest map[string]interface{}) map[string]interface{} {
	if len(src) == 0 {
		return dest
	}
	if len(dest) == 0 {
		return src
	}
	if len(src) == 0 && len(dest) == 0 {
		return make(map[string]interface{})
	}
	for k, v := range dest {
		src[k] = v
	}
	return src
}