package service

import (
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/licence.git"
	"basic.com/valib/logger.git"
	"bufio"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/mitchellh/mapstructure"
	"io/ioutil"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"strings"
	"sync"
	"time"
	"vamicro/config"
	"vamicro/extend/util"
	versionControlM "vamicro/version-control/models"
)

var (
	/**
	"app_auto_clean" : "0",
	"app_update_notice": "0",
	"app_auto_update": "0",
	*/
	VersionUpdateSetting = map[string]string{"app_auto_clean": "0", "app_update_notice": "0", "app_auto_update": "0"}

	updateNoticeInfo UpdateNoticeInfo
	NoticeLock       sync.Mutex
	PreDownloading   bool
)

type SysService struct {
}

type FileChunkCheckVo struct {
	UserId           string
	ChunkNumber      int    //当前分片下标,从1开始
	ChunkSize        int    //每一块的大小
	CurrentChunkSize int    //当前分块的大小
	FileName         string //文件名称
	Identifier       string //整个文件唯一标识,md5
	RelativePath     string //文件客户端路径
	TotalSize        int64  //文件总大小
	TotalChunks      int    //总分片数量
}

type FileUploadVo struct {
	Id               string
	UserId           string
	ChunkNumber      int                  //当前分片下标,从1开始
	ChunkSize        int                  //每一块的大小
	CurrentChunkSize int                  //当前分块的大小
	FileName         string               //文件名称
	Identifier       string               //整个文件唯一标识,md5
	RelativePath     string               //文件客户端路径
	TotalSize        int64                //文件总大小
	TotalChunks      int                  //总分片数量
	File             *bhomeclient.FileArg //当前分片的文件内容
}

type UpdateNoticeInfo struct {
	NoticeUser     map[string]int
	NeedUpdate     bool
	PreDownUpgrade bool
	NoticeStatus   bool
	AutoClean      bool
	SdkNeedUpgrade []SdkInsOrUpgrade
	AppNeedUpgrade []AppWithShop
	LastNoticeTime int
}

func init() {
	updateNoticeInfo.NoticeUser = make(map[string]int)
}

func (sv SysService) CheckUpdateFile(arg *FileChunkCheckVo) bool {
	configPatchPath := ""
	if config.Server.PatchPath != "" {
		configPatchPath = config.Server.PatchPath
	} else {
		configPatchPath = "/opt/vasystem/patch"
	}
	fileTmpPath := configPatchPath + "/" + arg.Identifier
	if !util.Exists(fileTmpPath) {
		return false
	}
	//判断合成的文件是否存在
	index := strings.LastIndex(arg.FileName, ".")
	subfix := ""
	if index > -1 { //有后缀
		subfix = arg.FileName[index:]
	}
	mergedFilePath := fileTmpPath + subfix
	if util.Exists(mergedFilePath) {
		return true
	}
	//判断分块文件是否存在
	chunkAlignNum := util.FormatNum(arg.TotalChunks, arg.ChunkNumber)
	chunkFilePath := fileTmpPath + "/" + arg.Identifier + "_" + chunkAlignNum
	if !util.Exists(chunkFilePath) {
		return false
	}
	if arg.ChunkNumber == arg.TotalChunks {
		dirFiles, _ := ioutil.ReadDir(fileTmpPath)
		if dirFiles != nil && len(dirFiles) == arg.TotalChunks {
			//表示所有分块都上传了，需要merge
			if b, _ := MergeChunks(fileTmpPath, mergedFilePath); !b {
				return false
			}
		}
	}
	return true
}

func (sv SysService) PatchUpload(arg *FileUploadVo) (bool, bool, string) {
	configPatchPath := ""
	if config.Server.PatchPath != "" {
		configPatchPath = config.Server.PatchPath
	} else {
		configPatchPath = "/opt/vasystem/patch"
	}

	if !util.CreateDirectory(configPatchPath) {
		return false, false, "创建文件夹失败"
	}

	filenameWithSuffix := path.Base(arg.FileName)
	subfix := path.Ext(filenameWithSuffix)
	MD5Str := arg.Identifier
	logger.Debug("Identifier:", MD5Str)
	fileTmpPath := configPatchPath + "/" + MD5Str
	if !util.Exists(fileTmpPath) {
		if !util.CreateDirectory(fileTmpPath) {
			return false, false, "创建补丁文件夹失败"
		}
	}
	chunkAlignNum := util.FormatNum(arg.TotalChunks, arg.ChunkNumber)
	fileSavePath := fileTmpPath + "/" + MD5Str + "_" + chunkAlignNum
	if util.Exists(fileSavePath) {
		rmErr := os.Remove(fileSavePath)
		if rmErr != nil {
			logger.Debug("rmErr:", rmErr)
			return false, false, rmErr.Error()
		}
	}
	file, e := os.Create(fileSavePath)
	if e != nil {
		logger.Debug("os.Create err:", e, "fileSavePath:", fileSavePath)
		return false, false, e.Error()
	}
	defer file.Close()
	writer := bufio.NewWriter(file)

	nn, err2 := writer.Write(arg.File.Bytes)
	if nn == 0 || err2 != nil {
		logger.Debug("write chunkData err:", err2, "nn:", nn)
		return false, false, "写入补丁包失败"
	}
	if err2 = writer.Flush(); err2 != nil {
		logger.Debug("write flush err:", err2)
		return false, false, err2.Error()
	}
	isComplete := false
	dirFiles, _ := ioutil.ReadDir(fileTmpPath)
	if dirFiles != nil && len(dirFiles) == arg.TotalChunks {
		isComplete = true
	}
	if isComplete {
		if mergeB, mergeE := MergeChunks(fileTmpPath, fileTmpPath+subfix); mergeB {
			logger.Debug("merge all chunks success,identifier:", MD5Str, "fileName:", arg.FileName)
			unPackB, unPackErr := unPackPatchPackage(MD5Str, subfix)
			logger.Debug("unPackB:", unPackB, "unPackErr:", unPackErr)
			if unPackB {
				return true, isComplete, "解压补丁包失败,错误的补丁包格式"
			}
		} else {
			return false, isComplete, mergeE.Error()
		}
	}
	return true, isComplete, ""
}

//upgrade
//func (sv SysService) Upgrade(identifier string,filename string) (bool,error) {
//	if !bakBeforeUpgrade() {
//		return false,errors.New("更新前备份失败")
//	}
//	configPatchPath := ""
//	if config.Server.PatchPath != "" {
//		configPatchPath = config.Server.PatchPath
//	} else {
//		configPatchPath = "/opt/vasystem/patch"
//	}
//
//	filenameWithSuffix := path.Base(filename)
//	ext := path.Ext(filenameWithSuffix)
//
//	zipFilePath := configPatchPath + "/"+identifier+ext
//	if util.Exists(zipFilePath) {
//		//校验md5
//		strMd5, e := util.FileMd5(zipFilePath)
//		if e !=nil || strMd5 == "" {
//			return false,errors.New("获取升级压缩包md5失败")
//		}
//		if strMd5 == identifier {
//			if !updatePatch(identifier, ext) {
//				return false,errors.New("执行升级过程异常,请确定上传的补丁是tar.gz格式")
//			}
//			return true,nil
//
//		} else {
//			logger.Debug("strMd5 is", strMd5,"identifier is",identifier,"not equal")
//			return false,errors.New("校验升级文件失败")
//		}
//	} else {
//		return false,errors.New("升级文件已丢失，请重新上传")
//	}
//}
//
//func bakBeforeUpgrade() bool {
//	configBakPath := ""
//	if config.Server.BakPath != "" {
//		configBakPath = config.Server.BakPath
//	} else {
//		configBakPath = "/opt/vasystem/bak"
//	}
//	if util.Exists(configBakPath) {
//		//只保留最新的版本
//		if err := os.RemoveAll(configBakPath);err != nil {
//			return false
//		}
//	}
//	if !util.CreateDirectory(configBakPath) {
//		return false
//	}
//	b, err := ExecCmd("cp -r /opt/vasystem/bin /opt/vasystem/bak")
//	if err != nil {
//		logger.Debug("bakBeforeUpgrade result:",string(b),"err:",err)
//		return false
//	}
//	return true
//}

//更新系统程序
//func updatePatch(identifier string, ext string) bool {
//	configPatchPath := ""
//	if config.Server.PatchPath != "" {
//		configPatchPath = config.Server.PatchPath
//	} else {
//		configPatchPath = "/opt/vasystem/patch"
//	}
//	//1.解压缩更新包
//	unPackPath := configPatchPath+"/"+identifier+"_basic/"
//	if util.Exists(unPackPath) {
//		//此版本已经更新过
//		rmErr := os.RemoveAll(unPackPath)
//		if rmErr !=nil {
//			return false
//		}
//	}
//	if !util.CreateDirectory(unPackPath) {
//		return false
//	}
//
//	unPackFilePath := configPatchPath+"/"+identifier+ext
//	err := util.UnTarGz(unPackFilePath, unPackPath)
//	if err !=nil {
//		logger.Debug("UnPack err:",err,"unPackFile:",unPackFilePath)
//		return false
//	}
//
//	//如果通用脚本有更新，则更新通用脚本
//	if util.Exists(unPackPath+"updatePatch.sh") {
//		cpStr := fmt.Sprintf("cp %s /opt/vasystem/bin",unPackPath+"updatePatch.sh")
//		b, err := ExecCmd(cpStr)
//		if err != nil {
//			logger.Debug("cp updatePatch.sh to bin err:",err,"result:",string(b))
//			return false
//		}
//	}
//
//	//判断更新包里是否有补丁脚本，如果有则执行，否则执行updatePatch.sh
//	updateCmd := fmt.Sprintf("./updatePatch.sh %s %s %s &",unPackPath,unPackFilePath,configPatchPath+"/"+identifier)
//	if util.Exists(unPackPath+"upgrade.sh") {
//		updateCmd = fmt.Sprintf("%supgrade.sh %s %s %s &",unPackPath,unPackPath,unPackFilePath,configPatchPath+"/"+identifier)
//	}
//	//2.更新系统
//	b,err := ExecCmd(updateCmd)
//	if err != nil {
//		logger.Debug("upgrade err:",err,"result:",string(b),"cmd:",updateCmd)
//		return false
//	} else {
//		logger.Debug("upgrade result:",string(b),"cmd:",updateCmd)
//	}
//	return true
//}

func MergeChunks(chunkPath string, storePath string) (bool, error) {
	var cmd *exec.Cmd
	cmd = exec.Command("/bin/sh", "-c", fmt.Sprintf(`
		filepath=%s
		filestore=%s
		echo "filepath: " $filepath
		echo "filestorepath: "  $filestore
		if [ ! -f $filestore ]; then
			echo "$filestore not exist"
		else
			rm -f $filestore
		fi
		
		for item in $(ls $filepath | sort -n)
		do
			$(cat ${filepath}/${item} >> ${filestore})
			echo "merge ${filepath}/${item}  to $filestore ok"
		done

		echo "file store ok"`, chunkPath, storePath))

	if b, err := cmd.Output(); err != nil {
		logger.Debug("mergeChunks err:", err, "result:", string(b))
		return false, errors.New("合成压缩包失败")
	} else {
		logger.Debug("mergeChunks result:", string(b))
		return true, nil
	}

}

func ExecCmd(cmdStr string) ([]byte, error) {
	var cmd *exec.Cmd
	cmd = exec.Command("/bin/sh", "-c", cmdStr)
	return cmd.Output()
}

func NoticeTick(c context.Context) {
	tick := time.Tick(1 * time.Second)
	for {
		select {
		case <-c.Done():
			logger.Info("proc close, self update exit")
			return
		case <-tick:
			NoticeLock.Lock()
			for uid, _ := range updateNoticeInfo.NoticeUser {
				if updateNoticeInfo.NoticeUser[uid] > 0 {
					updateNoticeInfo.NoticeUser[uid]--
				}
			}
			NoticeLock.Unlock()
		}
	}
}

//更新检查
func SelfUpdateStart(c context.Context) {
	tick := time.Tick(30 * time.Second)
	for {
		select {
		case <-c.Done():
			logger.Info("proc close, self update exit")
			return
		case <-tick:
			NoticeLock.Lock()
			//清理升级文件
			appAutoClean, ok := VersionUpdateSetting["app_auto_clean"]
			if ok && appAutoClean == "1" {
				updateNoticeInfo.AutoClean = true
				//configPatchPath := ""
				//if config.Server.PatchPath != "" {
				//	configPatchPath = config.Server.PatchPath
				//} else {
				//	configPatchPath = "/opt/vasystem/patch"
				//}
				//err := os.RemoveAll(configPatchPath)
				//if nil != err {
				//	logger.Error("clean update package failed:", err.Error())
				//}
				//_ = os.MkdirAll(configPatchPath, 0777)
			} else {
				updateNoticeInfo.AutoClean = false
			}
			//更新升级提醒
			appUpdateNotice, ok := VersionUpdateSetting["app_update_notice"]
			var sdkNeedUp []SdkInsOrUpgrade
			var appNeedUp []AppWithShop
			if ok && appUpdateNotice == "1" {
				sdkNeedUp, appNeedUp = CheckNeedUpgrade()
				updateNoticeInfo.NeedUpdate = len(sdkNeedUp) > 0 || len(appNeedUp) > 0
				updateNoticeInfo.NoticeStatus = true
				SdkHasModify := SdkNewModify(updateNoticeInfo.SdkNeedUpgrade, sdkNeedUp)
				AppHasModify := AppNewModify(updateNoticeInfo.AppNeedUpgrade, appNeedUp)
				if SdkHasModify || AppHasModify {
					for uid, _ := range updateNoticeInfo.NoticeUser {
						if updateNoticeInfo.NoticeUser[uid] <= 0 {
							updateNoticeInfo.NoticeUser[uid] = 0
						}
					}
				}
				updateNoticeInfo.SdkNeedUpgrade = sdkNeedUp
				updateNoticeInfo.AppNeedUpgrade = appNeedUp
			} else {
				updateNoticeInfo.NeedUpdate = false
				updateNoticeInfo.NoticeStatus = false
			}
			//预下载
			appAutoUpdate, ok := VersionUpdateSetting["app_auto_update"]
			if ok && appAutoUpdate == "1" {
				updateNoticeInfo.PreDownUpgrade = true
				if appUpdateNotice == "0" {
					sdkNeedUp, appNeedUp = CheckNeedUpgrade()
				}

				if len(sdkNeedUp) > 0 {
					for _, item := range sdkNeedUp {
						haveDown := CheckPreDown(item.RemoteVersion, item.SdkType)
						if !haveDown {
							PreDownSdkAndAppUpgradeFile(item.Id)
						}
					}
				}
				if len(appNeedUp) > 0 {
					for _, item := range appNeedUp {
						haveDown := CheckPreDown(item.RemoteVersion, item.Package)
						if !haveDown {
							PreDownSdkAndAppUpgradeFile(item.Id)
						}
					}
				}

			} else {
				updateNoticeInfo.PreDownUpgrade = false
			}
			NoticeLock.Unlock()
		default:
			time.Sleep(time.Second)
		}
	}
}

//是否和上次比较有新的更新
func SdkNewModify(SdkNeedUpgrade []SdkInsOrUpgrade, sdkNeedUp []SdkInsOrUpgrade) bool {
	for _, item := range SdkNeedUpgrade {
		for _, item2 := range sdkNeedUp {
			if item.Id == item2.Id {
				if strings.Compare(item.RemoteVersion, item2.RemoteVersion) == 1 {
					return true
				}
			}
		}
	}
	return false
}

//是否和上次比较有新的更新
func AppNewModify(AppNeedUpgrade []AppWithShop, appNeedUp []AppWithShop) bool {
	for _, item := range AppNeedUpgrade {
		for _, item2 := range appNeedUp {
			if item.Id == item2.Id {
				if strings.Compare(item.RemoteVersion, item2.RemoteVersion) == 1 {
					return true
				}
			}
		}
	}
	return false
}

/**
预下载SDK升级包
*/
func PreDownSdkAndAppUpgradeFile(id string) {
	if IsInstalling(id) {
		logger.Debug("系统正在升级")
		return
	}
	PreDownloading = true
	ip := &InsProgress{
		Status:   InsStatus_Downloading,
		Progress: 0,
	}
	insIngMap.Store(id, ip) //放到正在安装列表中
	defer func() {
		insIngMap.Delete(id)
		PreDownloading = false
	}()
	url := "http://" + util.GetShopUrl() + "/data/api-s/sdk/downloadOrUpgrade"
	machineCode := licence.GetMachineCode()
	if machineCode == "" {
		logger.Debug("获取机器码失败")
		return
	}
	paramBody := map[string]interface{}{
		"modId":       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*60)
	if err != nil {
		logger.Debug("DoPostRequest err:", err)
		return
	}
	var res bhomedbapi.Result
	if err = json.Unmarshal(respBody, &res); err != nil {
		logger.Debug("unmarshal err:", err)
		return
	}
	if !res.Success {
		logger.Debug("res.Data:", res.Data)
		return
	}
	logger.Debug("res.Data:", res.Data)
	var resp downOrUpResp
	if err := mapstructure.Decode(res.Data.(map[string]interface{}), &resp); err != nil {
		logger.Debug("mapstructure.Decode err:", err)
		return
	}
	logger.Debug("resp:", resp)
	if resp.Url == "" || resp.Md5 == "" {
		return
	}

	ip.Size = resp.Size
	//下载安装包
	configPatchPath := ""
	if config.Server.PatchPath != "" {
		configPatchPath = config.Server.PatchPath
	} else {
		configPatchPath = "../patch"
	}
	if !util.DirExists(configPatchPath) {
		os.Mkdir(configPatchPath, 0777)
	}
	filenameWithSuffix := path.Base(resp.Url)
	//ext := path.Ext(filenameWithSuffix)
	downUrl := "http://" + util.GetShopUrl() + "/files/" + resp.Url

	gzFilePath := configPatchPath + "/" + filenameWithSuffix
	_, err = os.Stat(gzFilePath)
	if nil != err {
		if os.IsNotExist(err) {
			err := DownloadFile(gzFilePath, downUrl, ip)
			if err != nil {
				logger.Debug("DownloadFile err:", err, " gzFilePath:", gzFilePath, " downUrl:", downUrl)
				return
			}
		} else {
			return
		}
	}
}

//检查是否需要更新
func CheckNeedUpgrade() ([]SdkInsOrUpgrade, []AppWithShop) {
	sdkNeedUp := make([]SdkInsOrUpgrade, 0)
	// userId := c.Header("Login_user_id")
	appNeedUp := make([]AppWithShop, 0)
	sdks := GetSdkList("", "", "")
	for _, item := range sdks {
		if item.Installed && item.IsUpgrade {
			sdkNeedUp = append(sdkNeedUp, item)
		}
	}
	apps := GetAppList("")
	for _, item := range apps {
		if item.Installed && item.IsUpgrade {
			appNeedUp = append(appNeedUp, item)
		}
	}

	return sdkNeedUp, appNeedUp
}

//同步更新设置
func PersistentWrapper(topic string, payloads []byte) {
	var sysSetting versionControlM.SysSetting
	if err := json.Unmarshal(payloads, &sysSetting); nil != err {
		logger.Error("handleSubMsg failed to persistent:", topic, string(payloads))
	}
	VersionUpdateSetting[sysSetting.Name] = sysSetting.Value
}

//获取更新提醒
func GetUpdateNotice() UpdateNoticeInfo {
	return updateNoticeInfo
}

//延迟提醒
func DelayNotice(uid string, second int) UpdateNoticeInfo {
	updateNoticeInfo.NoticeUser[uid] = second
	return updateNoticeInfo
}

//获取文件目录
func GetDirFiles(path string) ([]string, error) {
	files, err := filepath.Glob(filepath.Join(path, "*"))
	return files, err
}

//获取预下载路径
func GetPredownPath() string {
	configPatchPath := ""
	if config.Server.PatchPath != "" {
		configPatchPath = config.Server.PatchPath
	} else {
		configPatchPath = "../patch"
	}
	return configPatchPath
}

//检查是否已经下载
func CheckPreDown(version string, sdkName string) bool {
	predowns, err := GetDirFiles(GetPredownPath())
	if nil == err {
		for _, item := range predowns {
			if strings.Contains(item, sdkName+"-"+version) {
				return true
			}
		}
	}
	return false
}