package util

import (
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"math/rand"
	"net/http"
	"os"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"

	"golang.org/x/crypto/bcrypt"
)

// 生成邀请码
func GenerateInviteCode() string {
	alphabet := []byte("123456789ABCDEFGHIJKLMNPQRSTUVWXYZ")
	codes := make([]byte, 0)
	for i := 0; i < 6; i++ {
		s := rand.NewSource(time.Now().UnixNano())
		r := rand.New(s)
		index := r.Intn(len(alphabet))
		codes = append(codes, alphabet[index])
	}

	return string(codes)
}

// 获取环境变量
func GetEnv(key, defaultValue string) string {
	value := os.Getenv(key)
	if value == "" {
		return defaultValue
	}
	return value
}

// 生成密码
func GeneratePwd(pwd string) string {
	hash, _ := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
	return string(hash)
}

// 校验密码
func ValidatePwd(encodePwd, pwd string) bool {
	err := bcrypt.CompareHashAndPassword([]byte(encodePwd), []byte(pwd))
	if err != nil {
		return false
	} else {
		return true
	}
}

// 校验手机号
func VerifyMobile(mobile string) bool {
	pattern := "^((13[0-9])|(14[0-9])|(15[0-9])|(17[0-9])|(18[0-9])|(16[0-9])|198|199)\\d{8}$"
	reg := regexp.MustCompile(pattern)
	return reg.MatchString(mobile)
}

// 校验邮箱
func VerifyEmail(email string) bool {
	pattern := `^[0-9a-z][_.0-9a-z-]{0,31}@([0-9a-z][0-9a-z-]{0,30}[0-9a-z]\.){1,4}[a-z]{2,4}$`
	reg := regexp.MustCompile(pattern)
	return reg.MatchString(email)
}

// 获取机器码
func GetMachineUUID() (uuid string, err error) {
	var (
		url     string
		resp    *http.Response
		body    []byte
		data    map[string]map[string]interface{}
		ok      bool
		cliHost string
		cliPort string
	)

	cliHost = GetEnv("CLI_HOST", "192.168.1.252")
	cliPort = GetEnv("CLI_PORT", "8686")

	url = fmt.Sprintf("http://%s:%s", cliHost, cliPort)
	log.Printf("获取机器特征码 url: %s", url)

	resp, err = http.Get(url)

	if err != nil {
		log.Printf("http.Get: %v", err)
		err = errors.New("获取服务器特征码失败")
		return
	}

	defer resp.Body.Close()

	if resp.StatusCode == 200 {
		body, err = ioutil.ReadAll(resp.Body)
		err = json.Unmarshal(body, &data)
		if err != nil {
			log.Printf("json.Unmarshal: %v", err)
			err = errors.New("获取服务器特征码失败")
			return
		}

		uuid, ok = data["machine"]["uuid"].(string)
		if !ok {
			log.Printf("assert err: %v", err)
			err = errors.New("获取服务器特征码失败")
			return
		}
	}

	return
}

func Md5(str string) string {
	hash := md5.New()
	hash.Write([]byte(str))
	return hex.EncodeToString(hash.Sum(nil))
}

func InArray(needle interface{}, haystack interface{}) bool {
	val := reflect.ValueOf(haystack)
	switch val.Kind() {
	case reflect.Slice, reflect.Array:
		for i := 0; i < val.Len(); i++ {
			if reflect.DeepEqual(needle, val.Index(i).Interface()) {
				return true
			}
		}
	case reflect.Map:
		for _, k := range val.MapKeys() {
			if reflect.DeepEqual(needle, val.MapIndex(k).Interface()) {
				return true
			}
		}
	}

	return false
}

func ArrayIntersect(array1, array2 []string) []string {
	var res []string
	for _, v := range array1 {
		if InArray(v, array2) {
			res = append(res, v)
		}
	}
	return res
}

//
func RegNumberInString(str string) (float64, error) {
	reg, _ := regexp.Compile(`^\d+`)
	if reg != nil {
		s := reg.FindAllString(str, -1)
		if len(s) == 0 {
			return 0, nil
		}
		info := strings.TrimSpace(s[0])
		//
		f, e := strconv.ParseFloat(info, 64)
		return f, e
	}
	return 0, errors.New("unknown param")
}