package service

import (
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/licence.git"
	"basic.com/valib/logger.git"
	"encoding/json"
	"errors"
	"github.com/satori/go.uuid"
	"time"
	"vamicro/appcenter-service/models"
	"vamicro/appcenter-service/vo"
	"vamicro/config"
	"vamicro/extend/util"
)

type SdkService struct {
	bk bhomeclient.Broker
}

func NewSdkService(broker bhomeclient.Broker) *SdkService {
	return &SdkService{
		bk: broker,
	}
}

type res struct {
	Code    int         `json:"code"`
	Success bool        `json:"success"`
	Msg     string      `json:"msg"`
	Data    interface{} `json:"data"`
}

func GetLicenseFromShopCenter(sdkId string) (string, error) {
	url := "http://" + util.GetShopUrl() + "/data/api-s/sdk/dev/license"
	machineCode := licence.GetMachineCode()
	logger.Debug("url:", url, "machineCode:", machineCode)
	paramBody := map[string]interface{}{
		"devId": config.Server.AnalyServerId,
		"sdkId": sdkId,
	}
	header := map[string]string{
		"Authorization": token,
	}
	respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*2)
	if err != nil {
		logger.Debug("DoPostRequest err:", err)
		return "", nil
	}
	var r res
	if err = json.Unmarshal(respBody, &r); err != nil {
		logger.Debug("unmarshal err:", err)
		return "", nil
	}
	bts, _ := json.Marshal(r.Data)
	var m map[string]interface{}
	if err := json.Unmarshal(bts, &m); err != nil {
		return "", err
	}
	if lce, ok := m["license"]; ok {
		return lce.(string), nil
	}
	return "", errors.New("未获取到授权信息")
}

//实时监视本机算法是否已授权
func (sv SdkService) WatchLicense() {
	for {
		var sdkE models.Sdk
		sdks, err := sdkE.FindAll("")
		if err == nil && sdks != nil {
			for _, s := range sdks {
				if s.AuthState3rd == models.AuthState3rd_UnAuth || s.AuthState3rd == models.AuthState3rd_expired {
					//查看商城中此算法是否已更新授权信息
					if lceStr, err := GetLicenseFromShopCenter(s.Id); err == nil {
						sdkE.Update3rdLicense(s.Id, lceStr, models.AuthState3rd_Authed)
					}
				}
			}
		}
		time.Sleep(10 * time.Second)
	}
}

func (sv SdkService) Register(argBody *vo.SdkRegisterVo) bool {
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()

	var sdkE models.Sdk
	rows, _ := sdkE.SelectById(argBody.Id)
	registerSdk := argBody.Copy2Sdk()
	if rows > 0 {
		//update
		if err = tx.Table(sdkE.TableName()).Save(&registerSdk).Error; err != nil {
			return false
		}
	} else {
		if err = tx.Table(sdkE.TableName()).Create(&registerSdk).Error; err != nil {
			logger.Debug("register create sdk err:", err)
			return false
		}
	}
	//deal args
	if err = tx.Exec("delete from sdk_arg where sdk_id=?", sdkE.Id).Error; err != nil {
		logger.Debug("register del sdkarg err:", err)
		return false
	}
	if argBody.Args != nil {
		for _, argVo := range argBody.Args {
			if argVo.Name == "" || argVo.Alias == "" || argVo.Type == "" {
				err = errors.New("sdk arg error")
				logger.Debug("register sdk err:", err)
				return false
			}
			sdkArgE := models.SdkArgEntity{
				Id:    uuid.NewV4().String(),
				SdkId: argBody.Id,
				Scope: argVo.Scope,
			}
			sdkArgE.SdkArg = argVo.Copy2SdkArg()
			if sdkArgE.ArgType == "" {
				sdkArgE.ArgType = "target" //如果为空，认为是目标
			}
			if err = tx.Table(sdkArgE.TableName()).Create(&sdkArgE).Error; err != nil {
				logger.Debug("register sdk err:", err)
				return false
			}

			//处理算法参数枚举值
			if err = tx.Exec("delete from dictionary where type=?", argVo.Alias).Error; err != nil {
				logger.Debug("register sdk err:", err)
				return false
			}
			if argVo.Dics != nil && len(argVo.Dics) > 0 {
				for _, argValEle := range argVo.Dics {
					argValDic := models.Dictionary{
						Id:       uuid.NewV4().String(),
						Value:    argValEle.Value,
						Name:     argValEle.Name,
						Type:     argVo.Alias,
						Sort:     argValEle.Sort,
						ParentId: argBody.Id, //属于哪个算法
					}
					if err = tx.Table(argValDic.TableName()).Create(&argValDic).Error; err != nil {
						logger.Debug("register sdk err:", err)
						return false
					}
				}
			}
		}
	}
	tx.Commit()
	sv.AddDbChangeMsg(protomsg.DbAction_Insert)
	return true
}

func (sv SdkService) AddDbChangeMsg(action protomsg.DbAction) {
	pMsg := protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_Sdk,
		Action: action,
	}
	pb, _ := json.Marshal(pMsg)
	sv.bk.Publish(ProcName, pb)
}