package service

import (
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/licence.git"
	"basic.com/valib/logger.git"
	"encoding/json"
	"errors"
	"strconv"
	"time"
	"vamicro/appcenter-service/models"
	"vamicro/config"
	"vamicro/extend/util"
)

type AppWithShop struct {
	models.App
	RemoteVersion string `json:"remoteVersion"` //商城仓库版本号
	Installed     bool   `json:"installed"`     //是否已安装
	IsUpgrade     bool   `json:"isUpgrade"`     //是否需要升级
	ProgressMsg   string `json:"progressMsg"`   //安装或升级进度
}

type ProtoApps struct {
	List []models.App `json:"list"`
}

func GetAppList(appName string) []AppWithShop {
	var api models.App
	insList, err := api.FindAll(appName) //本地已安装所有应用,带顺序
	if err != nil {
		logger.Debug("findall err:", err.Error())
	}
	installedApps := make([]AppWithShop, len(insList))
	localAppIdArr := make([]string, 0)
	iv := make(map[string]string)
	localAppM := make(map[string]AppWithShop)
	for idx, ls := range insList {
		siou := AppWithShop{
			Installed: true,
		}

		siou.App = ls
		localAppM[siou.Package] = siou
		installedApps[idx] = siou
		iv[ls.Id] = ls.Version

		localAppIdArr = append(localAppIdArr, siou.Id)
	}

	nInsApps := make([]AppWithShop, 0)

	//远端可用的应用
	remoteApps := findAllMyApp(localAppIdArr, iv, appName)
	if remoteApps != nil {
		//logger.Debug("len(remoteApps):", len(remoteApps))

		for _, ap := range remoteApps {
			if v, ok := localAppM[ap.Package]; ok { //本地已安装
				ls := v
				ls.Name = ap.Name //以商城上的名称为准

				ls.Installed = true

				if ap.CanUpOrIns { //判断版本号是否需要升级
					ls.ProgressMsg = ""
					ls.IsUpgrade = shouldVersionBeUpgrade(ls.Version, ap.Version)
					ls.RemoteVersion = ap.Version //远端的版本号

					if ip, insB := insIngMap.Load(ap.Id); insB {
						iPgs := ip.(*InsProgress)
						ls.ProgressMsg = iPgs.Status + strconv.Itoa(iPgs.Progress) + "%"
					}
				}
				localAppM[ap.Package] = ls
				for index, es := range installedApps {
					if es.Package == ap.Package {
						installedApps[index] = ls
						break
					}
				}
			} else { //本地未安装，需要安装
				if ap.CanUpOrIns {
					bIns := AppWithShop{
						RemoteVersion: ap.Version,
						IsUpgrade:     false,
						Installed:     false,
						ProgressMsg:   "",
					}
					if ip, insB := insIngMap.Load(ap.Id); insB {
						iPgs := ip.(*InsProgress)
						bIns.ProgressMsg = iPgs.Status + strconv.Itoa(iPgs.Progress) + "%"
					}
					bIns.App = ap
					nInsApps = append(nInsApps, bIns)
				}
			}
		}
	}

	return append(installedApps, nInsApps...)
}

func findAllMyApp(localAppIdArr []string, iv map[string]string, inputTxt string) []models.App {
	url := "http://" + util.GetShopUrl() + "/data/api-s/app/myApp"
	machineCode := licence.GetMachineCode()
	//logger.Debug("url:", url, "machineCode:", machineCode)
	paramBody := map[string]interface{}{
		"serverId":      config.Server.AnalyServerId,
		"machineCode":   machineCode,
		"localAppIdArr": localAppIdArr,
		"iv":            iv,
		"inputTxt":      inputTxt,
	}
	header := map[string]string{
		"Authorization": token,
	}
	respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*20)
	if err != nil {
		logger.Debug("DoPostRequest err:", err)
		return nil
	}
	var res bhomedbapi.Result
	if err = json.Unmarshal(respBody, &res); err != nil {
		logger.Debug("unmarshal err:", err)
		return nil
	}
	bytes, _ := json.Marshal(res.Data)
	var pa ProtoApps
	if err := json.Unmarshal(bytes, &pa); err != nil {
		logger.Debug("unmarshal err:", err)
		return nil
	}

	return pa.List
}

// inputTxt过滤条件
func GetAppBuyList(inputTxt string) []models.App {
	url := "http://" + util.GetShopUrl() + "/data/api-s/app/buyList"
	machineCode := licence.GetMachineCode()
	logger.Debug("url:", url, "machineCode:", machineCode)

	var api models.App
	localApps, _ := api.FindAll("") //本地已安装所有应用,带顺序
	if localApps == nil {
		localApps = make([]models.App, 0)
	}

	localAppIdArr := make([]string, 0)
	iv := make(map[string]string)
	for _, ls := range localApps {
		iv[ls.Id] = ls.Version

		localAppIdArr = append(localAppIdArr, ls.Id)
	}
	paramBody := map[string]interface{}{
		"serverId":      config.Server.AnalyServerId,
		"machineCode":   machineCode,
		"localAppIdArr": localAppIdArr,
		"iv":            iv,
		"inputTxt":      inputTxt,
	}
	header := map[string]string{
		"Authorization": token,
	}
	respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*20)
	if err != nil {
		logger.Debug("DoPostRequest err:", err)
		return nil
	}
	var res bhomedbapi.Result
	if err = json.Unmarshal(respBody, &res); err != nil {
		logger.Debug("unmarshal err:", err)
		return nil
	}
	bytes, _ := json.Marshal(res.Data)
	var ss shopApps
	if err := json.Unmarshal(bytes, &ss); err != nil {
		logger.Debug("unmarshal err:", err)
		return nil
	}

	var resultArr []models.App
	installAppM := make(map[string]models.App)

	for _, ia := range localApps {
		installAppM[ia.Package] = ia
	}

	if ss.Apps != nil {
		for _, rs := range ss.Apps {
			if _, ok := installAppM[rs.Package]; !ok {
				resultArr = append(resultArr, rs)
			}
		}
	}

	return resultArr
}

type shopApps struct {
	Apps []models.App `json:"apps"`
}

func ActiveApp(cod string, appId string) (interface{}, error) {
	//使用激活码激活应用
	url := "http://" + util.GetShopUrl() + "/data/api-s/app/activeByAINode"
	machineCode := licence.GetMachineCode()
	if machineCode == "" {
		logger.Debug("获取机器码失败")
		return nil, errors.New("获取机器码失败")
	}
	paramBody := map[string]interface{}{
		"code":        cod,
		"appId":       appId,
		"machineCode": machineCode,
		"serverId":    config.Server.AnalyServerId,
	}
	header := map[string]string{
		"Authorization": token,
	}
	respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*60)
	if err != nil {
		logger.Debug("DoPostRequest err:", err)
		return nil, err
	}
	var res bhomedbapi.Result
	if err = json.Unmarshal(respBody, &res); err != nil {
		logger.Debug("unmarshal err:", err)
		return nil, err
	}
	if !res.Success {
		logger.Debug("res.Data:", res.Data)
		return nil, errors.New(res.Msg)
	}

	return res.Data, nil
}

func SaveApp(reqBody models.App) bool {
	if reqBody.Id == "" {
		return false
	}
	reqBody.CreateTime = time.Now().Format("2006-01-02 15:04:05")
	reqBody.CreateBy = "basic"
	reqBody.UpdateBy = ""
	reqBody.UpdateTime = ""
	if err := reqBody.Save(); err == nil {
		return true
	} else {
		logger.Error("注册应用失败:", err.Error())
	}

	return false
}

func DetailByAppOrSdkId(id string) (interface{}, error) {
	url := "http://" + util.GetShopUrl() + "/data/api-s/product/detailByAppOrSdkId"
	machineCode := licence.GetMachineCode()
	if machineCode == "" {
		return nil, errors.New("获取机器码失败")
	}
	paramBody := map[string]interface{}{
		"id":          id,
		"machineCode": machineCode,
		"serverId":    config.Server.AnalyServerId,
	}
	header := map[string]string{
		"Authorization": token,
	}
	respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*10)
	if err != nil {
		logger.Debug("DoPostRequest err:", err)
		return nil, errors.New("请求商城失败")
	}
	var res bhomedbapi.Result
	if err = json.Unmarshal(respBody, &res); err != nil {
		logger.Debug("unmarshal err:", err)
		return nil, err
	}
	if !res.Success {
		logger.Debug("res.Data:", res.Data)
		return nil, errors.New(res.Msg)
	}
	var app models.App
	row, err := app.SelectById(id)
	var mapData = res.Data.(map[string]interface{})
	detail := mapData["detail"].(map[string]interface{})
	detail["installed"] = false
	detail["isUpgrade"] = false                                 //需要升级
	detail["remoteVersion"] = detail["productVersion"].(string) //需要升级
	detail["version"] = ""
	if row > 0 {
		detail["installed"] = true
		if shouldVersionBeUpgrade(app.Version, detail["productVersion"].(string)) { //判断版本号是否需要升级
			detail["isUpgrade"] = true                                  //需要升级
			detail["remoteVersion"] = detail["productVersion"].(string) //需要升级
		}
		detail["version"] = app.Version
	} else {
		var sdk models.Sdk
		row, err = sdk.SelectById(id)
		if row > 0 {
			var mapData = res.Data.(map[string]interface{})
			detail["installed"] = true
			detail := mapData["detail"].(map[string]interface{})
			if shouldVersionBeUpgrade(sdk.Version, detail["productVersion"].(string)) { //判断版本号是否需要升级
				detail["isUpgrade"] = true                                  //需要升级
				detail["remoteVersion"] = detail["productVersion"].(string) //需要升级
			}
			detail["version"] = sdk.Version
		}
	}

	return res.Data, nil
}