package common

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

	"91porn-server/common/constant"

	"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{})
	return m, json.Unmarshal(j, &m)
}

// 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)
	return m, bson.Unmarshal(data, &m)
}

func MapToJsonString(m map[string]string) (string, error) {
	data, err := json.Marshal(m)
	if err != nil {
		return "", err
	}
	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) {
	j, err := json.Marshal(obj)
	if err != nil {
		return nil, err
	}
	m := make(map[string]interface{})
	return m, json.Unmarshal(j, &m)
}

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

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

// 拼接https://
func BindHttpSch(path string) string {
	if strings.HasPrefix(path, "http") {
		return path
	}
	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 {
	if len(obj) == 0 {
		return []string{}
	}
	arr := make([]string, len(obj))
	for i, o := range obj {
		arr[i] = o.Hex()
	}
	return arr
}

func String2ObjectID(obj []string) []primitive.ObjectID {
	arr := make([]primitive.ObjectID, 0, len(obj))
	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
}

func HandleSysType(sysType string) string {
	if strings.Contains(strings.ToLower(sysType), constant.SysTypeIOS) {
		return constant.SysTypeIOS
	}
	if strings.Contains(strings.ToLower(sysType), constant.SysTypeH5) {
		return constant.SysTypeH5
	}
	return constant.SysTypeAndroid
}

func GetJsonTags(tags *[]string, t reflect.Type) {
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		if field.Type.Kind() == reflect.Struct {
			GetJsonTags(tags, field.Type)
			continue
		}
		tag := field.Tag.Get("json")
		*tags = append(*tags, tag)
	}
}

// NormalizeDate 将时间归一化为北京时间的当天 0 点
func NormalizeDate(t time.Time) time.Time {
	local, _ := time.LoadLocation("Asia/Shanghai")
	t = t.In(local)
	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, local)
}