package licence

import (
	"encoding/json"
	"strings"
	"time"

	"github.com/shirou/gopsutil/cpu"
	// "github.com/shirou/gopsutil/disk"
	"github.com/shirou/gopsutil/host"
)

const key = "flzxsqc,ysyhljt."

type Licence struct {
	MachineCode string
	Expires     int64
}

const (
	ValidationErrorMalformed        uint32 = iota + 1 // Licence is malformed
	ValidationErrorUnverifiableHost                   // Licence could not be verified because of signing problems
	ValidationErrorExpired                            // Signature validation failed
)

func GetMachineCode() string {
	var machineCode string

	// CPU
	if cpu, err := cpu.Info(); err == nil {
		for _, c := range cpu {
			strings.Join([]string{machineCode, c.String()}, "-")
		}
	}

	// // Disk
	// if diskInfo, err := disk.Partitions(false); err == nil {
	// 	for _, d := range diskInfo {
	// 		diskSerialNumber := disk.GetDiskSerialNumber(d.Device)
	// 		strings.Join([]string{machineCode, diskSerialNumber}, "-")
	// 	}
	// }

	// Host
	if host, err := host.Info(); err == nil {
		strings.Join([]string{machineCode, host.HostID}, "-")
	}

	return GetMd5String(machineCode, true, false)
}

func GenerateLicence(machineCode, timeOut, key string) string {
	timeLayout := "2006-01-02 15:04:05"  //转化所需模板
	loc, _ := time.LoadLocation("Local") //获取时区
	tmp, _ := time.ParseInLocation(timeLayout, timeOut, loc)
	timestamp := tmp.Unix()

	licence := Licence{machineCode, timestamp}

	json, _ := json.Marshal(licence)
	return AESEncodeStr(json, key)
}

func VerifyLicence(licenceCode string) uint32 {
	decodeData := AESDecodeStr(licenceCode, key)
	if decodeData == nil {
		return ValidationErrorMalformed
	}

	var licence Licence

	if err := json.Unmarshal(decodeData, &licence); err != nil {
		return ValidationErrorMalformed
	}

	code := GetMachineCode()
	if licence.MachineCode != code {
		return ValidationErrorUnverifiableHost
	}

	now := time.Now().Unix()
	if now > licence.Expires {
		return ValidationErrorExpired
	}

	return 0
}