package service

import (
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/c_bhomebus.git/proto/source/bhome_msg"
	"basic.com/valib/licence.git"
	"basic.com/valib/logger.git"
	"basic.com/valib/version.git"
	"context"
	"crypto/md5"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/skip2/go-qrcode"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
	"path"
	"runtime"
	"strings"
	"sync"
	"time"
	"vamicro/config"
	"vamicro/extend/util"
	"vamicro/version-control/models"
	"vamicro/version-control/response"
	"vamicro/version-control/utils"
)

const (
	uriVersion  string = "/data/api-u/upgrade/findUpgradeVersion"
	uriDownload string = "/data/api-p/download"
	uriAuth     string = "/data/api-s/authorization"
	uriMobile   string = "/data/api-s/fromQrcode"
)

type (
	Payload struct {
		Arch     string            `json:"arch"`
		Programs []*models.Program `json:"programs"`
		Version  string            `json:"version"`
		Intro    string            `json:"intro"`
		PatchUrl string            `json:"patchUrl"`
	}

	UpdateInfo struct {
		response.ResponseHead
		Data []Payload `json:"data"`
	}

	VersionInfo struct {
		Build   string `json:"build"`
		Commit  string `json:"commit"`
		Name    string `json:"name"`
		Version string `json:"version"`
	}

	UpdateNotice struct {
		NoticeUser        map[string]int
		HaveNewVersion    int64 //是否有新版本，1有，0没有
		PkgDownloaded     int64 //是否下载完成，1有，0没有
		LastNoticeTime    int64
		NewVersionProgram []*models.Program
		NoticeStatus      bool
	}
)

var (
	updateNotice     UpdateNotice
	updateNoticeLock sync.Mutex
	LastDownFile     []string
	LastDownLock     sync.RWMutex
)

func Init() {
	backUpPath := GetBackupPath()
	if _, err := os.Stat(backUpPath); os.IsNotExist(err) {
		_ = os.MkdirAll(backUpPath, 0777)
	}
	preDownPath := GetPreDownPath()
	if _, err := os.Stat(preDownPath); os.IsNotExist(err) {
		_ = os.MkdirAll(preDownPath, 0777)
	}
	updateNotice.NoticeUser = make(map[string]int)
	LastDownFile = make([]string, 0)
}

func OnlineUpgrade() ([]*models.Program, error) {

	programMap := make(map[string]*models.Program)

	LastDownLock.Lock()
	defer LastDownLock.Unlock()
	//查找预下载升级包
	preDowns := GetLastDownFile()
	logger.Info("系统开始升级！")
	for _, preDown := range preDowns {
		logger.Info(preDowns)
		ps, err := UpgradeViaZip(preDown)
		if err != nil {
			return []*models.Program{}, err
		}
		for _, p := range ps {
			programMap[p.Name] = p
		}
	}
	logger.Info("系统升级完成！！")

	if len(programMap) > 0 { //使用预下载升级完成
		programs := make([]*models.Program, 0, len(programMap))
		for _, v := range programMap {
			programs = append(programs, v)
		}
		return programs, nil
	}

	info, err := getUpdateInfo()
	if nil != err {
		return []*models.Program{}, errors.New("系统没有更新可用")
	}

	logger.Info("系统升级开始！")
	//循环下载，解压，覆盖升级包
	for _, payload := range info.Data {
		ps, err := HandlerPatchPkg(payload)
		if err != nil {
			return []*models.Program{}, err
		}
		for _, p := range ps {
			programMap[p.Name] = p
		}
	}
	logger.Info("系统升级完成！！")

	if len(programMap) > 0 { //
		programs := make([]*models.Program, 0, len(programMap))
		for _, v := range programMap {
			programs = append(programs, v)
		}
		return programs, nil
	}

	return []*models.Program{}, err
}

//循环下载，解压，覆盖升级包
func HandlerPatchPkg(payload Payload) ([]*models.Program, error) {
	if payload.PatchUrl == "" {
		return []*models.Program{}, errors.New("No dist file get")
	}

	//u, err := url.Parse("http://" + util.GetShopUrl() + uriDownload)
	u, err := url.Parse(payload.PatchUrl)
	if err != nil {
		logger.Error("parse url failed, url:", payload.PatchUrl, ", err:", err.Error())
		return []*models.Program{}, err
	}
	upgradePath := GetPreDownPath()
	upfile := upgradePath + "/" + GetMd5(payload.Version) + ".tgz"
	//tmpFile, err := ioutil.TempFile("", "dist-*.zip")
	tmpFile, err := os.OpenFile(upfile, os.O_CREATE|os.O_WRONLY, 0666)
	if nil != err {
		logger.Error("OnlineUpgrade create temp file failed, err:", err.Error())
		return []*models.Program{}, err
	}
	fmt.Println("OnlineUpgrade tmpFile.Name: ", tmpFile.Name())
	defer func() {
		tmpFile.Close()
		backupPath := GetBackupPath()
		//文件从upgrade目录移动到backup目录
		os.Rename(tmpFile.Name(), backupPath+"/"+tmpFile.Name())
		//os.Remove(tmpFile.Name())
	}()

	//query := u.Query()
	//query.Set("filename", info.Data.Archive)
	//u.RawQuery = query.Encode()
	resp, err := http.Get(u.String())
	if err != nil {
		logger.Error("OnlineUpgrade parse url failed, url:", u.String(), ", err:", err.Error())
		return []*models.Program{}, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		logger.Error("OnlineUpgrade incorrect status, url:", u.String(), ", status:", resp.StatusCode)
		return []*models.Program{}, errors.New("Status code not 200")
	}

	_, err = io.Copy(tmpFile, resp.Body)
	if err != nil {
		logger.Error("OnlineUpgrade save upgrade file failed, url:", u.String(), ", err:", err.Error())
		return []*models.Program{}, err
	}

	return UpgradeViaZip(tmpFile.Name())
}

//循环下载升级包
func DownloadPatchPkg(payload Payload) (string, error) {
	if payload.PatchUrl == "" {
		return "", errors.New("no dist file get")
	}

	//u, err := url.Parse("http://" + util.GetShopUrl() + uriDownload)
	u, err := url.Parse(payload.PatchUrl)
	if err != nil {
		logger.Error("parse url failed, url:", payload.PatchUrl, ", err:", err.Error())
		return "", err
	}

	upgradePath := GetPreDownPath()
	upfile := upgradePath + "/" + GetMd5(payload.Version) + ".tgz"
	_, err = os.Stat(upfile)
	if nil == err {
		//已下载过
		logger.Info("PreDownUpgrade predown upgrade file have down:", upfile)
		return upfile, nil
	}

	tmpFile, err := os.OpenFile(upfile, os.O_CREATE|os.O_WRONLY, 0666)
	if nil != err {
		logger.Error("OnlineUpgrade create temp file failed, err:", err.Error())
		return "", err
	}

	fmt.Println("OnlineUpgrade tmpFile.Name: ", tmpFile.Name())
	defer func() {
		tmpFile.Close()
	}()

	resp, err := http.Get(u.String())
	if err != nil {
		logger.Error("OnlineUpgrade parse url failed, url:", u.String(), ", err:", err.Error())
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		logger.Error("OnlineUpgrade incorrect status, url:", u.String(), ", status:", resp.StatusCode)
		return "", errors.New("status code not 200")
	}

	_, err = io.Copy(tmpFile, resp.Body)
	if err != nil {
		logger.Error("PreDownUpgrade parse url failed, url:", u.String(), ", err:", err.Error())
		tmpFile.Close()

		os.Remove(upfile)
		return "", err
	}

	return upfile, nil
}

//检查是否需要更新版本
func CheckVersion() (string, string, string) {
	//获取服务端所有程序最新版本信息。
	info, err := getUpdateInfo()
	if nil != err {
		return "", "", ""
	}

	if len(info.Data) <= 0 {
		logger.Error("checkVersion no programs get")
		return "", "", ""
	}

	//获取需要更新版本的程序列表
	//programs := needUpgrade(info.Data.Programs)
	last := len(info.Data) - 1
	return info.Data[last].PatchUrl, info.Data[last].Version, info.Data[last].Intro
}

func GetCurVersion() string {
	curEnv, err := GetRunVersionEnv()
	if err != nil {
		return ""
	}
	return curEnv
}

//获取服务端最新程序及其版本
func getUpdateInfo() (*UpdateInfo, error) {
	//const PrtSize = 32 << uintptr(^uintptr(0)>>63)
	//wordSize := strconv.Itoa(PrtSize)

	u, err := url.Parse("http://" + util.GetShopUrl() + uriVersion)
	if err != nil {
		logger.Error("parse url failed, url:", "http://"+util.GetShopUrl()+uriVersion, ", err:", err.Error())
		return nil, err
	}

	query := u.Query()
	//query.Set("os", runtime.GOOS)
	query.Set("arch", runtime.GOARCH)
	query.Set("versionNum", GetCurVersion())
	//query.Set("wordSize", wordSize)

	u.RawQuery = query.Encode()
	resp, err := http.Get(u.String())
	if err != nil {
		logger.Error("checkVersion parse url failed, url:", u.String(), ", err:", err.Error())
		return nil, err
	}

	if resp.StatusCode != 200 {
		logger.Error("checkVersion incorrect status, url:", u.String(), ", status:", resp.StatusCode)
		return nil, errors.New("Status code not 200")
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		logger.Error("checkVersion read body failed, url:", u.String(), ", err:", err.Error())
		return nil, err
	}

	logger.Info("checkVersion dump body:", string(body))
	var info UpdateInfo
	err = json.Unmarshal(body, &info)
	if err != nil {
		logger.Error("checkVersion json.Unmarshal failed, url:", u.String(), ", err:", err.Error())
		return nil, err
	}

	//b, err := json.Marshal(&info)
	//if err != nil {
	//	logger.Error("checkVersion json.Marshal failed, url:", u.String(), ", err:", err.Error())
	//} else {
	//	logger.Info("checkVersion get response, url:", u.String(), ", response:", string(b))
	//}

	return &info, nil
}

//需要升级的程序
func needUpgrade(programs []*models.Program) []*models.Program {
	//获取当前运行版本目录
	//dir := utils.GetExePath()
	dir := util.GetVamicroPath()

	newPrograms := []*models.Program{}
	for _, p := range programs {
		exe := path.Join(dir, p.Name)
		if !utils.PathExists(exe) {
			newPrograms = append(newPrograms, p)
			continue
		}

		lVersion, err := dynamicGetVersion(dir, exe)
		if err != nil {
			logger.Error("exe:", exe, "get local version failed, err:", err.Error())
			continue
		}

		//版本名称转换为版本号
		rVersion, err := vaversion.VersionName2VaVersion(p.Version)
		if err != nil {
			logger.Error("exe:", exe, "get remote version failed:", p.Version, ", err:", err.Error())
			continue
		}

		c, err := lVersion.Compare(rVersion)
		if err != nil {
			logger.Error("exe:", exe, "version compare failed, remote:", p.Version, ", err:", err.Error())
			continue
		}

		if c > 0 {
			logger.Error("exe:", exe, "local version greater, local:", lVersion, "remote:", p.Version)
			continue
		}

		if c < 0 {
			newPrograms = append(newPrograms, p)
		}
	}

	return newPrograms
}

func NoticeTick(c context.Context) {
	// tick := time.Tick(1 * time.Second)
	tick := time.Tick(24 * time.Hour)
	for {
		select {
		case <-c.Done():
			logger.Info("proc close, self update exit")
			return
		case <-tick:
			//logger.Info("NoticeTick !!!")
			updateNoticeLock.Lock()
			for key, _ := range updateNotice.NoticeUser {
				if 0 < updateNotice.NoticeUser[key] {
					updateNotice.NoticeUser[key]--
				}
			}
			updateNoticeLock.Unlock()
		}
	}
}

//升级配置处理
func SelfUpdateStart(c context.Context, ms *bhomeclient.MicroNode) {
	//三十秒检查一次配置并更新
	// tick := time.Tick(30 * time.Second)
	tick := time.Tick(24 * time.Hour)

	var setting models.SysSetting
	for {
		select {
		case <-c.Done():
			logger.Info("proc close, self update exit")
			return
		case <-tick:
			settings, err := setting.GetAllSetting()
			if nil != err {
				logger.Error("fetch setting failed")
				continue
			}

			for _, set := range settings {
				data, _ := json.Marshal(set)
				var nodes []bhome_msg.BHAddress
				nodes = append(nodes, bhome_msg.BHAddress{})

				go ms.PublishNetTimeout(nodes, SysUpdateConfigTopic, data, 10)

				switch set.Name {
				case "sys_auto_clean":
					if "1" == set.Value {
						err := os.RemoveAll(GetBackupPath())
						if nil != err {
							logger.Error("clean update package failed:", err.Error())
						}
						_ = os.MkdirAll(GetBackupPath(), 0777)
					}
				case "sys_update_notice":
					{
						// 判断有新版本, 不再重复检测
						if updateNotice.HaveNewVersion == 1 {
							continue
						}

						// 设备更新提醒
						updateNoticeLock.Lock()

						//获取需要更新版本的程序列表
						_, version, _ := CheckVersion()
						curVersion := GetCurVersion()
						IsLastUpdate := true
						if version != curVersion {
							// 设置更新提醒, 重新下载升级包
							updateNotice.HaveNewVersion = 1
							updateNotice.PkgDownloaded = 0
							IsLastUpdate = true
						} else {
							IsLastUpdate = false
						}

						if !IsLastUpdate { //如果没有更新，设置用户延迟时间为0
							for key, _ := range updateNotice.NoticeUser {
								if 0 > updateNotice.NoticeUser[key] {
									updateNotice.NoticeUser[key] = 0
								}
							}
						}

						if "1" == set.Value {
							updateNotice.NoticeStatus = true
						} else {
							updateNotice.NoticeStatus = false
						}

						updateNoticeLock.Unlock()
					}
				case "sys_auto_update":
					{
						if "1" == set.Value && updateNotice.HaveNewVersion > 0 && updateNotice.PkgDownloaded == 0 {
							err := PreDownUpdateFile()
							if nil != err {
								logger.Error("pre download update file failed:", err.Error())
							} else {
								updateNotice.PkgDownloaded = 1
							}
						}
					}
				}
			}
		}
	}
}

//检查是否距上次比较有更新
func IsLastUpdate(programs []*models.Program, NewVersionProgram []*models.Program) bool {
	for _, program := range programs {
		for _, program2 := range NewVersionProgram {
			if program.Name == program2.Name {
				if program.Version != program2.Version {
					return true
				}
			}
		}
	}
	return true
}

//获取更新提醒
func GetUpdateNotice() UpdateNotice {
	return updateNotice
}

//延迟提醒
func DelayNotice(uid string, second int) UpdateNotice {
	updateNoticeLock.Lock()
	updateNotice.NoticeUser[uid] = second
	updateNoticeLock.Unlock()
	return updateNotice
}

//获取代码备份位置
func GetBackupPath() string {
	dir := util.GetVamicroPath() + "/backup"
	_, err := os.Stat(dir)
	if nil != err {
		if os.IsNotExist(err) {
			os.Mkdir(dir, 0744)
		} else {
			return "./backup"
		}
	}

	return dir
}

//获取解压后的补丁包位置
func GetPatchPath() string {
	dir := util.GetVamicroPath() + "/patch"
	_, err := os.Stat(dir)
	if nil != err {
		if os.IsNotExist(err) {
			os.Mkdir(dir, 0744)
		} else {
			return "./patch"
		}
	}

	return dir
}

//获取预下载升级包目录
func GetPreDownPath() string {
	dir := util.GetVamicroPath() + "/upgrade"
	_, err := os.Stat(dir)
	if nil != err {
		if os.IsNotExist(err) {
			os.Mkdir(dir, 0744)
		} else {
			return "./upgrade"
		}
	}

	return dir
}

//获取上传升级包目录
func GetPreUploadPath() string {
	dir := util.GetVamicroPath() + "/upgrade_manual"
	_, err := os.Stat(dir)
	if nil != err {
		if os.IsNotExist(err) {
			os.Mkdir(dir, 0744)
		} else {
			return "./upgrade_manual"
		}
	}

	return dir
}

func GetMd5(in string) string {
	data := md5.Sum([]byte(in))
	return fmt.Sprintf("%x", data)
}

//预下载升级文件
func PreDownUpdateFile() error {
	info, err := getUpdateInfo()
	if nil != err {
		return err
	}

	LastDownLock.Lock()
	defer LastDownLock.Unlock()

	LastDownFile = make([]string, 0)

	//循环下载升级包
	for _, payload := range info.Data {
		logger.Info("正在下载版本补丁【" + payload.Version + "】")
		upfile, err := DownloadPatchPkg(payload)
		logger.Info("下载版本补丁完成【" + payload.Version + "】")
		if err != nil {
			return err
		}

		LastDownFile = append(LastDownFile, upfile)
	}

	return nil
}

//获取预下载升级包
func GetLastDownFile() []string {
	var res = make([]string, 0)
	if len(LastDownFile) > 0 {
		for _, file := range LastDownFile {
			_, err := os.Stat(file)
			if nil == err {
				res = append(res, file)
			}
		}
	}
	return res
}

//回滚版本
func Rollback(version string) error {
	dir := util.GetVamicroPath() + "/" + version
	_, err := os.Stat(dir)
	if nil != err {
		return err
	}
	SetRunVersionEnv(version)
	versionEnv = version
	return nil
}

type RegUserInfo struct {
	UserType   string `json:"userType"`   //个人:personal  公司: company
	PhoneNum   string `json:"phoneNum"`   //手机号码
	Name       string `json:"name"`       //姓名或公司名称
	ProvinceId string `json:"provinceId"` //省
	CityId     string `json:"cityId"`     //市
	CountyId   string `json:"countyId"`   //县
	Email      string `json:"email"`      //邮箱
}

//获取授权
func Authorization(code string, isManual bool) (authinfo util.AuthorizationInfo, err error) {
	sn := util.GetVamicroPath() + "/sn.txt"
	authorization := util.GetVamicroPath() + "/auth.txt"

	activateCode := ""
	if len(code) == 29 && code[5:6] == "-" { //25位激活码激活
		activateCode = code
	}

	if "" != code && len(code) != 29 && code[5:6] != "-" {
		authinfo, err := util.GetAuthorizationInfo(code)
		if nil == err {
			activateCode = authinfo.ActivateCode
			logger.Debug("code found:" + code)
			if isManual { //手动操作更新授权文件，则立即返回，不用再次访问商城
				ioutil.WriteFile(sn, []byte(authinfo.ActivateCode), os.ModePerm)
				ioutil.WriteFile(authorization, []byte(code), os.ModePerm)
				return authinfo, nil
			} else {
				//否则以商城为准
				defer func() {
					if nil != err {
						//ioutil.WriteFile(sn, []byte(authinfo.ActivateCode), os.ModePerm)
						//ioutil.WriteFile(authorization, []byte(code), os.ModePerm)
					}
				}()
			}
		} else {
			return authinfo, errors.New("非法的授权!!")
		}
	}
	devId := config.Server.AnalyServerId
	machineCode := licence.GetMachineCode()

	authinfo, authcode, err := postAuthReq(util.GetSn(), activateCode, devId, machineCode, "")
	if nil != err {
		logger.Error("Authorization err:", err.Error(), authcode)
		//ioutil.WriteFile(authorization, []byte(authcode), os.ModePerm)  //bug:局域网会把授权清除
		return authinfo, err
	}

	if authinfo.MachineCode != machineCode {
		logger.Error("GetAuthorization machineCode not match, local:", machineCode, " remote:", authinfo.MachineCode)
		return authinfo, errors.New("授权不匹配")
	}

	ioutil.WriteFile(sn, []byte(authinfo.ActivateCode), os.ModePerm)
	ioutil.WriteFile(authorization, []byte(authcode), os.ModePerm)

	return authinfo, nil
}

func postAuthReq(sn string, activateCode string, deviceId string, machineCode string, oldDeviceId string) (authinfo util.AuthorizationInfo, authcode string, err error) {
	u, err := url.Parse("http://" + util.GetShopUrl() + uriAuth)
	if err != nil {
		logger.Error("parse url failed, url:", "http://"+util.GetShopUrl()+uriAuth, ", err:", err.Error())
		return authinfo, "", err
	}
	query := u.Query()
	query.Set("sn", sn)
	query.Set("activateCode", activateCode)
	query.Set("deviceId", deviceId)
	query.Set("machineCode", machineCode)
	query.Set("oldDeviceId", oldDeviceId)
	query.Set("deviceType", config.Server.DeviceType)
	query.Set("deviceMode", config.Server.DeviceModel)
	query.Set("vGpu", util.GetVGpu())

	var sysInitApi bhomedbapi.SysInitApi
	b, rInfo := sysInitApi.GetRegInfo()
	if b {
		rbd, e := json.Marshal(rInfo)
		if e == nil {
			var sysRI RegUserInfo
			if e = json.Unmarshal(rbd, &sysRI); e == nil {
				query.Set("userType", sysRI.UserType)
				query.Set("name", sysRI.Name)
				query.Set("phoneNum", sysRI.PhoneNum)
				query.Set("provinceId", sysRI.ProvinceId)
				query.Set("cityId", sysRI.CityId)
				query.Set("countyId", sysRI.CountyId)
				query.Set("email", sysRI.Email)
			} else {
				logger.Error("json.Unmarshal sysRI e:", e)
			}
		} else {
			logger.Error("json.Marshal rInfo e:", e)
		}
	}

	u.RawQuery = query.Encode()
	resp, err := http.Get(u.String())
	if err != nil {
		logger.Error("GetAuthorization parse url failed, url:", u.String(), ", err:", err.Error())
		return authinfo, "", err
	}

	if resp.StatusCode != 200 {
		logger.Error("GetAuthorization incorrect status, url:", u.String(), ", status:", resp.StatusCode)
		return authinfo, "", errors.New("Status code not 200")
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		logger.Error("GetAuthorization read body failed, url:", u.String(), ", err:", err.Error())
		return authinfo, "", err
	}

	logger.Info("postAuthReq body:", string(body))
	var info map[string]interface{}
	err = json.Unmarshal(body, &info)
	if err != nil {
		logger.Error("GetAuthorization json.Unmarshal failed, url:", u.String(), ", err:", err.Error())
		return authinfo, "", err
	}

	authinfo, err = util.GetAuthorizationInfo(info["data"].(string))
	if nil == err {
		logger.Error("err:", err)
		return authinfo, info["data"].(string), nil
	}

	if 500 == int(info["code"].(float64)) {
		logger.Error("ret 500")
		return authinfo, "", errors.New(info["msg"].(string))
	}

	if true != info["success"].(bool) {
		logger.Error("not success")
		return authinfo, "", errors.New(info["msg"].(string))
	}

	return authinfo, info["data"].(string), nil
}

func GenQRCode() ([]byte, string, error) {
	sn := util.GetSn()
	var authInfo util.AuthorizationInfo
	authInfo.Sn = sn
	authInfo.DevId = config.Server.AnalyServerId
	authInfo.MachineCode = licence.GetMachineCode()
	authInfo.DeviceType = config.Server.DeviceType
	authInfo.DeviceMode = config.Server.DeviceModel
	authInfo.VGpu = util.GetVGpu()

	var sysInitApi bhomedbapi.SysInitApi
	if bsi, rInfo := sysInitApi.GetRegInfo(); bsi {
		rbd, e := json.Marshal(rInfo)
		if e == nil {
			var sysRI RegUserInfo
			if e = json.Unmarshal(rbd, &sysRI); e == nil {
				authInfo.UserType = sysRI.UserType
				authInfo.Name = sysRI.Name
				authInfo.PhoneNum = sysRI.PhoneNum
				authInfo.ProvinceId = sysRI.ProvinceId
				authInfo.CityId = sysRI.CityId
				authInfo.CountyId = sysRI.CountyId
				authInfo.Email = sysRI.Email
			} else {
				logger.Error("json.Unmarshal sysRI e:", e)
			}
		} else {
			logger.Error("json.Marshal rInfo e:", e)
		}
	}

	hackQ, _ := HackAuthorizationInfo(authInfo)

	url := "http://" + util.GetShopUrl() + uriMobile + "?q=" + hackQ

	logger.Info("qrcode len:", len(url), " content:", url)

	// 生成二维码
	q, err := qrcode.New(url, qrcode.Highest)
	if err != nil {
		return nil, url, err
	}

	png, err1 := q.PNG(350)

	return png, url, err1
}

//刷新授权到其他进程
func AuthorizationUpdate(c context.Context, ms *bhomeclient.MicroNode) {
	//三十秒检查一次配置并更新
	// tick := time.Tick(30 * time.Second)
	tick := time.Tick(24 * time.Hour)

	var authInfo util.AuthorizationInfo
	var err error
	for {
		select {
		case <-c.Done():
			logger.Info("proc close, self update exit")
			return
		case <-tick:
			author := util.GetAuthorization()
			sn := util.GetSn()

			authInfo, err = Authorization(sn, false)
			if nil != err && !strings.Contains(err.Error(), "成功") {
				logger.Error("GetAuthorization error:", err.Error())
				if "" != author {
					authInfo, err = util.GetAuthorizationInfo(author)
				}
			}

			logger.Debug("authInfo:", authInfo)
			data, _ := json.Marshal(authInfo)
			var nodes []bhome_msg.BHAddress
			nodes = append(nodes, bhome_msg.BHAddress{})
			go ms.PublishNetTimeout(nodes, AuthorizationUpdateTopic, data, 10)
		}
	}
}

func HackAuthorizationInfo(authorizationInfo util.AuthorizationInfo) (string, error) {
	b, err := json.Marshal(authorizationInfo)
	if nil != err {
		return "", err
	}
	logger.Debug("authorInfo", authorizationInfo)

	info, err := util.RsaEncrypt(b)
	if nil != err {
		logger.Error("HackAuthorizationInfo utils.RsaEncrypt failed, err:", err.Error())
		return "", err
	}

	return base64.StdEncoding.EncodeToString(info), nil
}

func GetQ() string {
	sn := util.GetSn()
	var authinfo util.AuthorizationInfo
	authinfo.Sn = sn
	authinfo.DevId = config.Server.AnalyServerId
	authinfo.MachineCode = licence.GetMachineCode()
	authinfo.VGpu = util.GetVGpu()
	q, err := HackAuthorizationInfo(authinfo)
	if nil == err {
		return q
	}
	return err.Error()
}

func CancelAuthorization(passwd string, q string) (error, string) {
	uApi := bhomedbapi.UserApi{}
	ok, _ := uApi.Login("basic", passwd)
	if !ok {
		return errors.New("密码不正确!"), ""
	}
	//获取请求码里的devId
	qInfo, err := util.GetAuthorizationInfo(q)
	if nil != err {
		return errors.New("请求码格式不正确"), ""
	}

	curAuthInfo := util.GetAuthorization()

	//获取当前授权码
	authInfo, err := util.GetAuthorizationInfo(curAuthInfo)
	if nil != err {
		return errors.New("当前服务器授权信息不完整"), ""
	}
	authInfo.OldDeviceId = authInfo.DevId
	authInfo.DevId = qInfo.DevId
	authInfo.VGpu = util.GetVGpu()
	sn := util.GetVamicroPath() + "/sn.txt"
	authorization := util.GetVamicroPath() + "/auth.txt"
	authCode, err := HackAuthorizationInfo(authInfo)
	if nil != err {
		return errors.New("产品密钥导出失败"), ""
	}
	ioutil.WriteFile(sn, []byte(""), os.ModePerm)
	time.Sleep(100 * time.Microsecond)
	ioutil.WriteFile(authorization, []byte(""), os.ModePerm)

	_, _, err = postAuthReq(authInfo.Sn, authInfo.ActivateCode, qInfo.DevId, licence.GetMachineCode(), authInfo.OldDeviceId)

	if nil != err {
		return err, ""
	}

	return nil, authCode
}