package controllers

import (
	"encoding/json"
	"fmt"
	"os/exec"
	"regexp"
	"strconv"
	"strings"
	"time"
	"vamicro/config"
	"vamicro/extend/util"
	"vamicro/system-service/models"
	"vamicro/system-service/service"
	"vamicro/system-service/sys"
	"vamicro/system-service/vo"

	"basic.com/valib/go-aiot.git/aiotProto/aiot"
	"basic.com/valib/licence.git"
	"gitee.com/LearingIt/goTypeTrans/trans"
	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/host"
	"github.com/shirou/gopsutil/mem"

	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/logger.git"
	uuid "github.com/satori/go.uuid"
)

type SysSetController struct {
}

// @Summary 存储信息查询
// @Description 存储信息查询
// @Accept  json
// @Produce json
// @Tags sysset
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/alarmServerShow [GET]
func (sset SysSetController) AlarmServerShow(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	conf := new(models.LocalConfig)
	if err := conf.Select(); err != nil {
		conf.ServerId = config.Server.AnalyServerId
		return &bhomeclient.Reply{Success: false, Msg: "记录不存在", Data: conf}
	} else {
		return &bhomeclient.Reply{Success: true, Data: conf}
	}
}

// @Summary 存储信息修改
// @Description 存储信息修改
// @Accept  json
// @Produce json
// @Tags sysset
// @Param config body models.LocalConfig true "报警和存储信息数据"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/alarmEdit [POST]
func (sset SysSetController) AlarmEdit(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	conf := new(models.LocalConfig)   // 查询绑定
	reqCon := new(models.LocalConfig) // 前台数据绑定
	c.BindJSON(reqCon)
	if err := conf.Select(); err != nil { // 查询是否存在
		return &bhomeclient.Reply{Success: false, Msg: "记录不存在"}
	} else {
		copyColumnValueForAlarm(reqCon, conf) // 不印象其他值
		reqCon.Id = conf.Id                   // 修改必须有 id
		reqCon.ServerId = config.Server.AnalyServerId
		if e := reqCon.Update(); e == nil {
			pMsg := protomsg.DbChangeMessage{
				Table:  protomsg.TableChanged_T_Server,
				Action: protomsg.DbAction_Update,
			}
			pb, _ := json.Marshal(pMsg)
			h.Bk.Publish(service.ProcName, pb)

			return &bhomeclient.Reply{Success: true, Data: *reqCon}
		} else {
			return &bhomeclient.Reply{Success: false, Msg: e.Error()}
		}
	}
}

// 本地 配置信息 复制
func copyColumnValueForAlarm(reqCon *models.LocalConfig, config *models.LocalConfig) {
	reqCon.ServerId = config.ServerId
	reqCon.ServerName = config.ServerName
	reqCon.ServerType = config.ServerType
	reqCon.Reserved = config.Reserved
}

// @Summary 存储信息修改
// @Description 存储信息修改
// @Accept  json
// @Produce json
// @Tags sysset
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/videoLenShow [GET]
func (sset SysSetController) VideoLenShow(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	conf := new(models.LocalConfig)       // 前台数据绑定
	if err := conf.Select(); err != nil { // 查询是否存在
		conf.ServerId = config.Server.AnalyServerId
		return &bhomeclient.Reply{Success: false, Msg: "记录不存在", Data: conf}
	} else {
		resData := make(map[string]int, 0)
		resData["max_video_len"] = conf.CutMaxDuration
		resData["min_video_len"] = conf.CutMinDuration
		// 存在则修改
		return &bhomeclient.Reply{Success: true, Data: resData}
	}
}

// @Summary 视频截取时长修改
// @Description 视频截取时长信息
// @Accept  x-www-form-urlencoded
// @Produce json
// @Tags sysset
// @Param min_video_len formData string true "视频截取最短时长"
// @Param max_video_len formData string true "视频截取最长时长"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/videoLenEdit [POST]
func (sset SysSetController) VideoLenEdit(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	conf := new(models.LocalConfig) // 前台数据绑定

	/*min_video_len := c.QueryMap("min_video_len") //查询请求URL后面的参数
	max_video_len := c.PostForm("max_video_len") //从表单中查询参数*/
	//POST和PUT主体参数优先于URL查询字符串值。
	max_video_len := c.PostForm("max_video_len")
	min_video_len := c.PostForm("min_video_len")
	if err := conf.Select(); err != nil { // 查询是否存在
		return &bhomeclient.Reply{Success: false, Msg: "记录不存在", Data: conf}
	} else {
		max, _ := strconv.Atoi(max_video_len) // 数据 string 转 int8
		min, _ := strconv.Atoi(min_video_len)
		conf.CutMaxDuration = max
		conf.CutMinDuration = min
		conf.ServerId = config.Server.AnalyServerId
		if e := conf.Update(); e == nil {
			pMsg := protomsg.DbChangeMessage{
				Table:  protomsg.TableChanged_T_Server,
				Action: protomsg.DbAction_Update,
			}
			pb, _ := json.Marshal(pMsg)
			h.Bk.Publish(service.ProcName, pb)
			return &bhomeclient.Reply{Success: true, Data: *conf}
		} else {
			return &bhomeclient.Reply{Success: false, Msg: e.Error()}
		}
	}
}

func (sset SysSetController) GetServerInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var conf models.LocalConfig           // 前台数据绑定
	if err := conf.Select(); err != nil { // 查询是否存在
		return &bhomeclient.Reply{Msg: "查询失败"}
	} else {
		conf.ServerId = config.Server.AnalyServerId
		m := util.Struct2Map(conf)
		ipv4, _, _ := sys.GetLocalIP(config.Server.NetworkAdapter)
		m["server_ip"] = ipv4
		return &bhomeclient.Reply{Success: true, Data: conf}
	}
}

// @Summary 获取分析设备信息
// @Description  分析设备信息
// @Accept  json
// @Produce json
// @Tags sysset
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/getDevInfo [GET]
func (sset SysSetController) GetDevInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	sysconf := new(models.LocalConfig)       // 前台数据绑定
	if err := sysconf.Select(); err != nil { // 查询是否存在
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	} else {
		resData := make(map[string]interface{}, 0)
		sysconf.ServerId = config.Server.AnalyServerId

		resData["server_id"] = sysconf.ServerId
		resData["server_name"] = sysconf.ServerName

		ipv4, _, _ := sys.GetLocalIP(config.Server.NetworkAdapter)
		resData["server_ip"] = ipv4
		resData["server_port"] = sys.GetNginxListenPort()
		resData["server_domain"] = sys.GetNginxListenHost()

		ipv4, mask, _ := sys.GetLocalIP(config.Server.NetworkAdapter)
		gateway, _ := sys.GetDefaultRoute(config.Server.NetworkAdapter)
		dns, _ := sys.GetDnsServer()

		resData["ip"] = ipv4
		resData["subMask"] = mask
		resData["gateway"] = gateway
		resData["dns"] = dns
		resData["min_video_len"] = sysconf.CutMinDuration
		resData["max_video_len"] = sysconf.CutMaxDuration
		resData["alarm_ip"] = sysconf.AlarmIp
		resData["alarm_port"] = sysconf.AlarmPort
		resData["web_pic_ip"] = sysconf.WebPicIp
		resData["web_pic_port"] = sysconf.WebPicPort
		resData["es_pic_ip"] = sysconf.EsPicIp
		resData["es_pic_port"] = sysconf.EsPicPort

		resData["channelCount"] = sysconf.RealMax
		resData["deviceInfo"] = sys.GetDeviceInfo()

		resData["deviceNum"] = config.Server.DeviceNum
		resData["deviceType"] = config.Server.DeviceType
		resData["deviceModel"] = config.Server.DeviceModel
		resData["deviceSerialNum"] = config.Server.DeviceSerialNum
		resData["masterVersion"] = config.Server.MasterVersion
		resData["deviceDesc"] = config.Server.DeviceDesc //设备描述，说明是分析还是存储设备
		return &bhomeclient.Reply{Success: true, Data: resData}
	}
}

// @Summary 获取分析设备信息
// @Description  分析设备信息
// @Accept  json
// @Produce json
// @Tags sysset
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/getFullDevInfo [GET]
func (sset SysSetController) GetFullDevInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	conf := new(models.LocalConfig)       // 前台数据绑定
	if err := conf.Select(); err != nil { // 查询是否存在
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	} else {
		conf.ServerId = config.Server.AnalyServerId
		resData := make(map[string]string, 0)
		resData["server_id"] = conf.ServerId
		resData["server_name"] = conf.ServerName
		ipv4, mask, _ := util.GetLocalIP(config.Server.NetworkAdapter)
		gateway, _ := util.GetDefaultRoute(config.Server.NetworkAdapter)
		resData["ip"] = ipv4
		resData["subMask"] = mask
		resData["gateway"] = gateway

		resData["deviceNum"] = config.Server.DeviceNum
		resData["deviceType"] = config.Server.DeviceType
		resData["deviceSerialNum"] = config.Server.DeviceSerialNum
		resData["masterVersion"] = config.Server.MasterVersion
		resData["webVersion"] = config.Server.WebVersion
		resData["channelCount"] = config.Server.ChannelCount
		resData["diskCount"] = config.Server.DiskCount
		return &bhomeclient.Reply{Success: true, Data: resData}
	}
}

// @Summary 保存视频分析设备信息
// @Description 分析设备信息
// @Accept  x-www-form-urlencoded
// @Produce json
// @Tags sysset
// @Param serverName formData string true "分析设备名称"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/saveDevInfo [POST]
func (sset SysSetController) SaveDevInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	// 设置ip
	isOk, msg := sys.SetNetworkConfig(
		c.PostForm("ip"),
		c.PostForm("subMask"),
		c.PostForm("gateway"),
		c.PostForm("dns"),
		config.Server.NetworkAdapter)
	logger.Debug("isOk:", isOk, "msg:", msg)
	if !isOk {
		return &bhomeclient.Reply{Success: false, Msg: msg}
	}

	conf := new(models.LocalConfig)
	serverName := c.PostForm("server_name")
	logger.Debug("saveServerInfo serverName:", serverName)
	if err := conf.Select(); err != nil { // 查询是否存在
		logger.Debug("saveServerInfo err:", err)
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	} else { // 存在及修改 不存在 即添加
		conf.ServerName = serverName
		conf.ServerId = config.Server.AnalyServerId
		newIp := c.PostForm("ip")
		logger.Debug("saveServerInfo newIp:", newIp)
		if newIp != "" && (conf.AlarmIp != newIp || conf.WebPicIp != newIp) {
			conf.AlarmIp = newIp
			conf.WebPicIp = newIp
		}
		if conf.ServerId == "" {
			conf.ServerId = uuid.NewV4().String()
			if conf.AlarmPort == 0 {
				conf.AlarmPort = 9200
			}
			if conf.WebPicPort == 0 {
				conf.WebPicPort = 6333
			}
			if err := conf.Insert(); err == nil {
				pMsg := protomsg.DbChangeMessage{
					Table:  protomsg.TableChanged_T_Server,
					Action: protomsg.DbAction_Update,
				}
				pb, _ := json.Marshal(pMsg)
				h.Bk.Publish(service.ProcName, pb)
				return &bhomeclient.Reply{Success: true, Data: *conf}
			} else {
				return &bhomeclient.Reply{Success: false, Msg: "新增失败"}
			}
		} else {
			if e := conf.Update(); e != nil {
				return &bhomeclient.Reply{Success: false, Msg: e.Error()}
			} else {
				go func() {
					//网卡可能在重启
					time.Sleep(20 * time.Second)
					//修改国标ip
					tmpResourceConf := models.ResourceConfig{}
					rcErr := tmpResourceConf.Select()

					var gbApi bhomedbapi.Gb28181Api
					flag, gbConf := gbApi.Show()

					if flag { //国标已配置
						setGbIp := ""
						if rcErr == nil { //对外服务已配置
							if tmpResourceConf.IpType == models.IpType_Local { //配置的是本机Ip
								setGbIp = newIp
							} else { //设置的是对外服务，则不需要刷新了

							}
						} else { //对外服务ip未配置,国标使用本机ip
							setGbIp = newIp
						}
						if setGbIp != "" && setGbIp != gbConf.ServerIp {
							gbConf.ServerIp = setGbIp
							paramBody := util.Struct2Map(gbConf)
							gbApi.Edit(paramBody)
						}

					}
				}()
				var clusterE models.Cluster
				clusterE.UpdateNodeName(conf.ServerName, config.Server.AnalyServerId)

				pMsg := protomsg.DbChangeMessage{
					Table:  protomsg.TableChanged_T_Server,
					Action: protomsg.DbAction_Update,
				}
				pb, _ := json.Marshal(pMsg)
				h.Bk.Publish(service.ProcName, pb)
				return &bhomeclient.Reply{Success: true, Data: *conf}
			}
		}
	}
}

// @Summary 获取存储对外服务信息
// @Description 获取存储对外服务信息
// @Produce json
// @Tags sysset
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/sysset/getResourceConfig [get]
func (sset SysSetController) GetResourceConfig(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	t := time.Now()
	logger.Debug("收到请求，当前时间:", t.Nanosecond())
	var conf models.ResourceConfig
	err := conf.Select()
	if err != nil {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	} else {
		logger.Debug("取数据库用时:", time.Since(t))
		return &bhomeclient.Reply{Success: true, Data: conf}
	}
}

// @Summary 存储对外服务信息
// @Description 存储对外服务信息
// @Accept  json
// @Produce json
// @Tags sysset
// @Param reqBoby body models.ResourceConfig true "post请求，json参数"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/sysset/saveResourceConfig [post]
func (sset SysSetController) SaveResourceConfig(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var reqBody models.ResourceConfig
	c.BindJSON(&reqBody)
	if reqBody.ServiceIp == "" && reqBody.Domain == "" {
		return &bhomeclient.Reply{Success: false, Msg: "参数有误"}
	}

	var sv service.ResourceConfigService
	if sv.Save(reqBody) {
		pMsg := protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_ResourceConfig,
			Action: protomsg.DbAction_Update,
		}
		pb, _ := json.Marshal(pMsg)
		h.Bk.Publish(service.ProcName, pb)
		return &bhomeclient.Reply{Success: true, Msg: "保存成功"}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: "保存失败"}
	}
}

// @Summary 系统更新包上传(分块检查)
// @Description 系统更新包上传(分块检查)
// @Accept multipart/form-data
// @Produce json
// @Tags sysset
// @Param chunkNumber formData int true "当前是第几个分块"
// @Param chunkSize formData int true "每一块的大小"
// @Param currentChunkSize formData int true "当前块的大小"
// @Param identifier formData string true "整个文件的唯一标识，目前是md5"
// @Param filename formData string true "文件名称"
// @Param relativePath formData string true "文件在客户端电脑的路径"
// @Param totalChunks formData int true "文件总块数"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/sysset/patchUpdate [get]
func (sset SysSetController) PatchUpdateCheck(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	chunkNumber, e1 := strconv.Atoi(c.Query("chunkNumber"))
	chunkSize, e2 := strconv.Atoi(c.Query("chunkSize"))
	currentChunkSize, e3 := strconv.Atoi(c.Query("currentChunkSize"))
	identifier := c.Query("identifier")
	filename := c.Query("filename")
	relativePath := c.Query("relativePath")
	totalChunks, e5 := strconv.Atoi(c.Query("totalChunks"))
	if identifier == "" || e1 != nil || e2 != nil || e3 != nil || e5 != nil {
		return &bhomeclient.Reply{Msg: "参数有误"}
	}
	userId := c.Header("Login_user_id")
	var arg = service.FileChunkCheckVo{
		UserId:           userId,
		FileName:         filename,
		Identifier:       identifier,
		RelativePath:     relativePath,
		TotalChunks:      totalChunks,
		ChunkNumber:      chunkNumber,
		ChunkSize:        chunkSize,
		CurrentChunkSize: currentChunkSize,
	}
	var sv service.SysService
	if b := sv.CheckUpdateFile(&arg); b {
		return &bhomeclient.Reply{Success: true, Data: "found"}
	} else {
		return &bhomeclient.Reply{Success: true, Data: ""}
	}
}

// @Security ApiKeyAuth
// @Summary 系统更新包上传
// @Description 系统更新包上传
// @Accept multipart/form-data
// @Produce json
// @Tags sysset
// @Param chunkNumber formData int true "当前是第几个分块"
// @Param chunkSize formData int true "每一块的大小"
// @Param currentChunkSize formData int true "当前块的大小"
// @Param totalSize formData string true "文件总大小"
// @Param identifier formData string true "整个文件的唯一标识，目前是md5"
// @Param filename formData string true "文件名称"
// @Param relativePath formData string true "文件在客户端电脑的路径"
// @Param totalChunks formData int true "文件总块数"
// @Param file formData file true "文件分片内容"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/sysset/patchUpdatePack [post]
func (sset SysSetController) PatchUpdatePack(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	chunkNumber, e1 := strconv.Atoi(c.PostForm("chunkNumber"))
	chunkSize, e2 := strconv.Atoi(c.PostForm("chunkSize"))
	currentChunkSize, e3 := strconv.Atoi(c.PostForm("currentChunkSize"))
	totalSize, e4 := strconv.ParseInt(c.PostForm("totalSize"), 10, 64)
	identifier := c.PostForm("identifier")
	filename := c.PostForm("filename")
	relativePath := c.PostForm("relativePath")
	totalChunks, e5 := strconv.Atoi(c.PostForm("totalChunks"))
	file, e6 := c.FormFile()
	if identifier == "" || e1 != nil || e2 != nil || e3 != nil || e4 != nil || e5 != nil || e6 != nil {
		return &bhomeclient.Reply{Msg: "参数有误"}
	}
	userId := c.Header("Login_user_id")
	var arg = service.FileUploadVo{
		UserId:           userId,
		FileName:         filename,
		Identifier:       identifier,
		RelativePath:     relativePath,
		TotalSize:        totalSize,
		TotalChunks:      totalChunks,
		ChunkNumber:      chunkNumber,
		ChunkSize:        chunkSize,
		CurrentChunkSize: currentChunkSize,
		File:             file,
	}
	var sv service.SysService
	if b, _, msg := sv.PatchUpload(&arg); b {
		return &bhomeclient.Reply{Success: true, Msg: "上传成功"}
	} else {
		return &bhomeclient.Reply{Msg: msg}
	}
}

// @Security ApiKeyAuth
// @Summary 开始升级
// @Description 开始升级
// @Accept multipart/form-data
// @Produce json
// @Tags sysset
// @Param identifier formData string true "整个文件的唯一标识，目前是md5"
// @Param filename formData string true "文件名称"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/sysset/upgrade [post]
func (sset SysSetController) Upgrade(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	identifier := c.Query("identifier")
	filename := c.Query("filename")
	if identifier == "" || filename == "" {
		return &bhomeclient.Reply{Msg: "参数有误"}
	}
	var sv service.SysService
	if b, err := sv.Upgrade(identifier, filename); b {
		return &bhomeclient.Reply{Success: true, Msg: "升级成功"}
	} else {
		return &bhomeclient.Reply{Msg: "升级失败，原因:" + err.Error()}
	}
}

// @Security ApiKeyAuth
// @Summary 获取时间配置
// @Description  系统时间配置信息
// @Accept  json
// @Produce json
// @Tags 系统配置
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/clockInfo [GET]
func (sset SysSetController) GetClockInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	resData := make(map[string]interface{}, 0)
	resData["time_zone"], resData["local_time"] = sys.TimeZone()
	resData["ntp"], resData["ntp_server"], resData["interval"] = sys.NTPConfig()

	return &bhomeclient.Reply{Success: true, Data: resData}
}

// @Security ApiKeyAuth
// @Summary 测试同步时间
// @Description 测试同步时间服务器是否可用
// @Produce json
// @Tags 系统配置
// @Param server query string true "时间服务器ip"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/ntpTest [GET]
func (sset SysSetController) TestNTPServer(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	ntpServer := c.Query("server")

	//if root := sys.CheckRootPermissions(); !root {
	//	util.ResponseFormat(c, code.ServiceInsideError, "服务器没有修改时间的权限")
	//	return
	//}

	if len(ntpServer) < 7 {
		return &bhomeclient.Reply{Msg: "NTP服务器地址有误"}
	}

	isConn := sys.RunNTPDate(ntpServer)
	if !isConn {
		return &bhomeclient.Reply{Msg: "NTP服务不可用"}
	}

	return &bhomeclient.Reply{Success: true, Data: ""}
}

type SysClockConfigVo struct {
	TimeZone  string `json:"timeZone" example:"时区"`
	NTP       bool   `json:"ntp" example:"NTP校时"`
	NTPServer string `json:"ntpServer" example:"NTP服务器地址"`
	Interval  int    `json:"interval" example:"自动校时间隔"`
	NewTime   string `json:"newTime" example:"手动指定时间"`
}

// @Security ApiKeyAuth
// @Summary 设置系统时间
// @Description 校正系统时间
// @Accept  json
// @Produce json
// @Tags 系统配置
// @Param config body controllers.SysClockConfigVo true "校时信息"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/updateClock [POST]
func (sset SysSetController) SetSysClock(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var args SysClockConfigVo
	err := c.BindJSON(&args)
	if err != nil {
		return &bhomeclient.Reply{Msg: "参数有误"}
	}

	if args.TimeZone != "" { //CST UTC
		if r := sys.SetTimeZone(args.TimeZone); !r {
			return &bhomeclient.Reply{Msg: "时区参数错误"}
		}
	}

	if !args.NTP {
		if r := sys.SetLocalTime(args.NewTime, args.TimeZone); !r {
			return &bhomeclient.Reply{Msg: "指定的时间参数错误"}
		}
	} else {
		if r := sys.EnableNTPCron(args.NTPServer, args.Interval); !r {
			return &bhomeclient.Reply{Msg: "指定的服务器地址错误"}
		}
	}

	return &bhomeclient.Reply{Success: true, Data: "配置成功"}
}

// @Security ApiKeyAuth
// @Summary 查询系统运行信息
// @Description 获取当前系统的运行状态，CPU, GPU, 内存等
// @Produce json
// @Tags 系统配置
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/sysinfo [GET]
func (sset SysSetController) GetSysInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	info := sys.GetSysInfo()
	return &bhomeclient.Reply{Success: true, Data: info}
}

// @Security ApiKeyAuth
// @Summary 查询系统状态阈值设置
// @Description 获取当前系统的运行状态，CPU, GPU, 内存的阈值配置
// @Produce json
// @Tags 系统配置
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/sysThresholds [GET]
func (sset SysSetController) GetSysThresholds(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	return &bhomeclient.Reply{Success: true, Data: config.Server.SysThresholds}
}

// @Security ApiKeyAuth
// @Summary 重启系统
// @Description 重启操作系统
// @Produce json
// @Tags 系统配置
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/reboot [GET]
func (sset SysSetController) RebootOS(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	if isOk, msg := sys.Reboot(); !isOk {
		return &bhomeclient.Reply{Msg: msg}
	}

	return &bhomeclient.Reply{Success: true, Data: "正在重启"}
}

// @Security ApiKeyAuth
// @Summary 获取定时重启
// @Description 获取定时重启任务的配置规则
// @Produce json
// @Tags 系统配置
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/rebootTask [GET]
func (sset SysSetController) GetRebootTask(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	_, msg := sys.ReadRebootTaskInCrontab()
	return &bhomeclient.Reply{Success: true, Data: msg}
}

// @Security ApiKeyAuth
// @Summary 设置定时重启
// @Description 设置定时重启任务的配置规则
// @Accept x-www-form-urlencoded
// @Produce json
// @Tags 系统配置
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/rebootTask [POST]
func (sset SysSetController) SetRebootTask(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	task := c.PostForm("task")
	if len(task) < 1 {
		sys.CleanRebootTask()
		return &bhomeclient.Reply{Success: true, Data: "配置成功"}
	}

	regEx := `^([0-9*]+\s){4}[0-9*]+$`
	if r, _ := regexp.MatchString(regEx, task); !r {
		return &bhomeclient.Reply{Msg: "参数错误"}
	}

	if r := sys.UpdateRebootTask(task); !r {
		return &bhomeclient.Reply{Msg: "配置失败"}
	}

	return &bhomeclient.Reply{Success: true, Data: "配置成功"}
}

// @Security ApiKeyAuth
// @Summary 查询网卡信息列表
// @Description 获取服务器网卡信息列表
// @Accept x-www-form-urlencoded
// @Produce json
// @Tags 网卡列表
// @Success 200 {string} json "{"code":200, msg:"网卡数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/netWorkCards [GET]
func (sset SysSetController) GetNetWorkCards(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	interfaces, err := sys.GetNetWorkCards()
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: "获取失败"}
	}

	return &bhomeclient.Reply{Success: true, Data: interfaces}
}

// @Security ApiKeyAuth
// @Summary 查询网卡信息
// @Description 获取服务器网卡信息
// @Accept x-www-form-urlencoded
// @Produce json
// @Tags 网卡信息
// @Success 200 {string} json "{"code":200, msg:"网卡数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/getNetWorkCardInfo [GET]
func (sset SysSetController) GetNetWorkCardInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	fname := c.PostForm("ifname")
	info, err := sys.GetNetWorkInfo(fname)
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
	return &bhomeclient.Reply{Success: true, Data: info}
}

// @Security ApiKeyAuth
// @Summary 设置网卡
// @Description 设置网卡信息
// @Accept  x-www-form-urlencoded
// @Produce json
// @Tags 设置网卡
// @Param ip formData string true "IP"
// @Param subMask formData string true "子网掩码"
// @Param gateway formData string true "网关"
// @Param dns formData string true "DNS"
// @Param ifname formData string true "NetworkAdapter"
// @Success 200 {string} json "{"code":200, msg:"配置成功", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/setNetWorkCard [POST]
func (sset SysSetController) SetNetWorkCard(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	ip := c.PostForm("ip")
	subMask := c.PostForm("subMask")
	gateway := c.PostForm("gateway")
	dns := c.PostForm("dns")
	fname := c.PostForm("ifname")
	if "" == ip || "" == subMask || "" == gateway || "" == dns || "" == fname {
		return &bhomeclient.Reply{Success: false, Msg: "参数错误"}
	}
	isOk, msg := sys.SetNetworkConfig(
		ip,
		subMask,
		gateway,
		dns,
		fname)
	logger.Debug("isOk:", isOk, "msg:", msg)
	if !isOk && !strings.Contains(msg, "some wrong happens") {
		return &bhomeclient.Reply{Success: false, Msg: msg}
	}
	if fname == config.Server.NetworkAdapter {
		_, err := sys.ConfigUpdate("", ip)
		if nil != err {
			return &bhomeclient.Reply{Success: false, Msg: err.Error()}
		}

		pMsg := protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_Server,
			Action: protomsg.DbAction_Update,
		}
		pb, _ := json.Marshal(pMsg)
		h.Bk.Publish(service.ProcName, pb)
	}
	return &bhomeclient.Reply{Success: true, Data: "配置成功"}
}

// @Security ApiKeyAuth
// @Summary 设置服务名称
// @Description 设置服务名称
// @Accept  x-www-form-urlencoded
// @Produce json
// @Tags 设置服务名称
// @Param server_name formData string true "服务名称"
// @Param server_port formData string true "外部访问端口"
// @Success 200 {string} json "{"code":200, msg:"配置成功", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Router /data/api-v/sysset/setSerName [POST]
func (sset SysSetController) SetSerName(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	// 修改nginx 配置
	serverPort := c.PostForm("server_port")
	serverDomain := c.PostForm("server_domain")
	// 兼容不支持修改端口和域名的前端
	if serverPort != "" || serverDomain != "" {
		currentNginxListenPort := sys.GetNginxListenPort()
		cunrentNginxListenHost := sys.GetNginxListenHost()
		if serverDomain == "" {
			serverDomain = cunrentNginxListenHost
		}

		// 判断端口或域名有修改
		if serverPort != currentNginxListenPort || serverDomain != cunrentNginxListenHost {
			if serverPort != currentNginxListenPort && util.PortInUse(serverPort) {
				return &bhomeclient.Reply{Success: false, Msg: "无效的端口或端口被占用," + serverPort}
			}
			if !sys.SetNginxConf(serverPort, serverDomain) {
				return &bhomeclient.Reply{Success: false, Msg: "端口或域名配置失败, 请检查配置"}
			}
		}
	}

	serverName := c.PostForm("server_name")
	if "" == serverName {
		return &bhomeclient.Reply{Success: false, Msg: "设备名称不能为空"}
	}
	result, err := sys.ConfigUpdate(serverName, "")
	if nil != err {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
	//如果不是新增配置同步服务名称
	if !result {
		var clusterE models.Cluster
		clusterE.UpdateNodeName(serverName, config.Server.AnalyServerId)

		pMsg := protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_Server,
			Action: protomsg.DbAction_Update,
		}
		pb, _ := json.Marshal(pMsg)
		err = h.Bk.Publish(service.ProcName, pb)
		if nil != err {
			return &bhomeclient.Reply{Success: false, Msg: err.Error()}
		}
	}

	return &bhomeclient.Reply{Success: true, Data: "配置成功"}
}

// @Summary 获取服务信息
// @Description 获取服务信息
// @Produce json
// @Tags 获取服务信息
// @Success 200 {string} json "{"code":200, msg:"",data:"",success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getSerInfo [GET]
func (sset SysSetController) GetSerInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	conf := new(models.LocalConfig)
	conf.Select()
	return &bhomeclient.Reply{Success: true, Data: conf}
}

// @Summary 获取语言列表
// @Description 获取语言列表
// @Produce json
// @Tags 获取语言列表
// @Success 200 {string} json "{"code":200, msg:"",data:"",success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getLangs [GET]
func (sset SysSetController) GetLangs(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	langs := config.Server.Langs
	return &bhomeclient.Reply{Success: true, Data: langs}
}

// @Summary 获取当前语言
// @Description 获取当前语言
// @Produce json
// @Tags 获取语言列表
// @Success 200 {string} json "{"code":200, msg:"",data:"",success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getLang [GET]
func (sset SysSetController) GetLang(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	lang, err := sys.GetLang()
	res := map[string]string{"lang": lang}
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: res}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 设置语言
// @Description 设置语言
// @Produce json
// @Tags 设置语言
// @Success 200 {string} json "{"code":200, msg:"",data:"",success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/setLang [POST]
func (sset SysSetController) SetLang(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	lang := c.PostForm("lang")
	langs := config.Server.Langs
	for _, l := range langs {
		if lang == l.Lang {
			err := sys.SetLang(l.Lang, l.Language)
			if nil == err {
				return &bhomeclient.Reply{Success: true, Data: "配置成功"}
			} else {
				return &bhomeclient.Reply{Success: false, Msg: err.Error()}
			}
		}
	}
	return &bhomeclient.Reply{Success: false, Msg: "参数错误"}
}

// @Summary 获取键盘布局列表
// @Description 获取键盘布局列表
// @Produce json
// @Tags 获取键盘布局列表
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getKeyboardLayouts [GET]
func (sset SysSetController) GetKeyboardLayouts(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	_, keyBoardLayouts, err := sys.GetKeyboardLayouts()
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: keyBoardLayouts}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 获取默认键盘布局
// @Description 获取默认键盘布局
// @Produce json
// @Tags 获取默认键盘布局
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getDefKeyboardLayout [GET]
func (sset SysSetController) GetDefKeyboardLayout(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	keyBoardLayout, err := sys.GetDefKeyboard()
	result := map[string]string{"keyboard": keyBoardLayout}
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: result}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 获取键盘布局列表
// @Description 获取键盘布局列表
// @Produce json
// @Tags 获取键盘布局列表
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/setKeyboardLayout [POST]
func (sset SysSetController) SetKeyboardLayout(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	layout := c.PostForm("layout")
	keyboardLayoutMap, _, err := sys.GetKeyboardLayouts()
	if nil == err {
		_, ok := keyboardLayoutMap[layout]
		if ok {
			err = sys.SetKeyboardLayout(layout)
			if nil == err {
				return &bhomeclient.Reply{Success: true, Data: "配置成功"}
			} else {
				return &bhomeclient.Reply{Success: false, Msg: err.Error()}
			}
		} else {
			return &bhomeclient.Reply{Success: false, Msg: "指定Layout不存在!"}
		}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 禁用网卡
// @Description 禁用网卡
// @Produce json
// @Tags 禁用网卡
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/downNetCard [POST]
func (sset SysSetController) DownNetCard(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	fname := c.PostForm("ifname")
	if config.Server.NetworkAdapter == fname {
		return &bhomeclient.Reply{Success: false, Msg: "不可以禁用这个网卡"}
	}
	err := sys.DownNetCard(fname)
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: "禁用成功"}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 启用网卡
// @Description 启用网卡
// @Produce json
// @Tags 启用网卡
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/upNetCard [POST]
func (sset SysSetController) UpNetCard(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	fname := c.PostForm("ifname")
	err := sys.UpNetCard(fname)
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: "启用成功"}
	} else {
		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 启用网卡
// @Description 启用网卡
// @Produce json
// @Tags 启用网卡
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getWifiList [POST]
func (sset SysSetController) GetWifiList(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	fname := c.PostForm("ifname")
	wifiList, err := sys.ScanWifiList(fname)
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: wifiList}
	} else {
		logger.Debug("iwlist err,", fname, err.Error())

		return &bhomeclient.Reply{Success: false, Msg: err.Error()}
	}
}

// @Summary 连接wifi
// @Description 连接wifi
// @Produce json
// @Tags 连接wifi
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/connectWifi [POST]
func (sset SysSetController) ConnectWifi(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	fname := c.PostForm("ifname")
	passwd := c.PostForm("passwd")
	ssid := c.PostForm("ssid")

	err := sys.ConnectWifi(fname, ssid, passwd)
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: "连接成功!"}
	} else {
		msg := err.Error()
		if strings.Contains(msg, "exit status") {
			msg = "加入失败,请检查配置!"
		}
		return &bhomeclient.Reply{Success: false, Msg: msg}
	}
}

// @Summary 连接wifi
// @Description 连接wifi
// @Produce json
// @Tags 连接wifi
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/connectWifi [POST]
func (sset SysSetController) DisonnectWifi(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	fname := c.PostForm("ifname")

	// 关闭wifi连接时ssid 传del
	err := sys.ConnectWifi(fname, "del", "")
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: "连接成功!"}
	} else {
		msg := err.Error()
		if strings.Contains(msg, "exit status") {
			msg = "加入失败,请检查配置!"
		}
		return &bhomeclient.Reply{Success: false, Msg: msg}
	}
}

// @Summary 获取配置
// @Description 获取配置
// @Produce json
// @Tags 获取配置
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/getSysSetting [GET]
func (sset SysSetController) GetSysSetting(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var settingSer service.SysService
	settings, err := settingSer.GetAllSetting()
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: settings}
	}
	return &bhomeclient.Reply{Success: false, Msg: "获取失败!" + err.Error()}
}

// @Summary 更新配置
// @Description 更新配置
// @Produce json
// @Tags 更新配置
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/updateSysSetting [POST]
func (sset SysSetController) UpdateSysSetting(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	name := c.PostForm("name")
	value := c.PostForm("value")
	if "" == name || "" == value {
		return &bhomeclient.Reply{Success: false, Msg: "参数错误!"}
	}
	setting := models.SysSetting{Name: name, Value: value}
	err := setting.SaveSetting(true)
	if nil == err {
		return &bhomeclient.Reply{Success: true, Data: "更新成功!"}
	}
	return &bhomeclient.Reply{Success: false, Msg: "更新失败!" + err.Error()}
}

// @Summary 获取剩余硬盘空间
// @Description 获取剩余硬盘空间
// @Produce json
// @Tags 获取剩余硬盘空间
// @Success 200 {string} json "{"code":200, msg:"",data:[],success:true}"
// @Failure 500 {string} json "{"code":500, msg:"",data:"[]",success:false}"
// @Router /data/api-v/sysset/freedisk [POST]
func (sset SysSetController) DiskInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	weedDataDir, _ := util.ExeCmd("ps aux | grep [m]dir | head -n1 | sed -s 's/.*-mdir//'| awk '{printf $1}'")

	var ser service.SysService
	all, free := ser.DiskInfo(weedDataDir)
	stat := map[string]uint64{"all": all, "free": free}
	return &bhomeclient.Reply{Success: true, Data: stat}
}

// 获取授权管理方式和授权密码
func (sset SysSetController) ShowAuthInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var ser service.SysService
	res, err := ser.ShowAuthInfo()
	if err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "查询失败!" + err.Error()}
	}
	return &bhomeclient.Reply{Success: true, Data: res}
}

// 设置授权管理方式和授权密码
func (sset SysSetController) SetAuthInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	reqCon := new(models.LocalConfig)
	c.BindJSON(reqCon)
	var ser service.SysService
	err := ser.SetAuthInfo(reqCon)
	if err != nil {
		return &bhomeclient.Reply{Success: false, Msg: "修改失败!" + err.Error()}
	}
	return &bhomeclient.Reply{Success: true, Msg: "修改成功!"}
}

// 获取设备授权信息
func (sset SysSetController) GetDeviceAuthInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	type DeviceAuthParam struct {
		DeviceId string `json:"deviceId"`
	}

	var reqParam DeviceAuthParam
	err := c.BindJSON(&reqParam)
	if err != nil {
		logger.Errorf("GetDeviceAuthInfo BindJson error=%v", err)
		return &bhomeclient.Reply{Success: false, Msg: "参数错误!"}
	}
	if reqParam.DeviceId == "" {
		logger.Error("GetDeviceAuthInfo deviceId is nil error")
		return &bhomeclient.Reply{Success: false, Msg: "参数错误!"}
	}

	logger.Debugf("GetDeviceAuthInfo start, deviceId=%v", reqParam.DeviceId)
	var sysconf models.LocalConfig
	if err := sysconf.SelectByDeviceId(reqParam.DeviceId); err != nil {
		logger.Errorf("GetDeviceAuthInfo err=%v", err)
		return &bhomeclient.Reply{Success: false, Msg: "失败! " + err.Error()}
	}

	if sysconf.ServerId == "" {
		return &bhomeclient.Reply{Success: false, Msg: "没有找到设备信息"}
	}

	result := map[string]string{
		"AuthPwd":     sysconf.AuthPwd,
		"NeedAuthPwd": fmt.Sprintf("%v", sysconf.NeedAuthPwd),
	}
	logger.Debugf("GetDeviceAuthInfo result=%v", result)
	return &bhomeclient.Reply{Success: true, Msg: "成功!", Data: result}
}

// 获取设备详情
func (sset SysSetController) GetDeviceInfo(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	logger.Debug("hyjd enter GetDeviceInfo")
	result := &bhomeclient.Reply{}
	var sysconf models.LocalConfig
	err := sysconf.Select()
	if err != nil { // 查询是否存在
		return result
	}
	i := vo.SyncDevInfo{}
	ipv4, mask, _ := sys.GetLocalIP(config.Server.NetworkAdapter)
	gateway, _ := sys.GetDefaultRoute(config.Server.NetworkAdapter)
	dns, _ := sys.GetDnsServer()
	machineCode := licence.GetMachineCode()

	// 获取设备激活时间
	res, err := service.DoBusReq("/data/api-v/version/snBus", config.Server.AnalyServerId, aiot.RequestMethod_Post, aiot.RequestContentType_ApplicationJson, map[string]interface{}{})
	logger.Warn("snBus", string(res))
	installTime := ""
	if err == nil {
		type install struct {
			InstallTime string `json:"installTime"`
		}
		type reply struct {
			Success bool    `json:"success"`
			Msg     string  `json:"msg"`
			Data    install `json:"data"`
		}
		rep := reply{}
		err = json.Unmarshal(res, &rep)
		if err == nil {
			installTime = rep.Data.InstallTime
		} else {
			logger.Error("fail to Unmarshal /data/api-v/version/snBus", err)
		}
	} else {
		logger.Error("fail to /data/api-v/version/snBus", err)
	}

	//1.收集设备基本信息
	i.Detail = vo.DevDetail{
		ServerId:        config.Server.AnalyServerId,
		MachineCode:     machineCode,
		ServerName:      sysconf.ServerName,
		ServerPort:      sys.GetNginxListenPort(),
		Ip:              ipv4,
		SubMask:         mask,
		Gateway:         gateway,
		Dns:             dns,
		DeviceNum:       config.Server.DeviceNum,
		DeviceType:      config.Server.DeviceType,
		DeviceModel:     config.Server.DeviceModel,
		DeviceSerialNum: config.Server.DeviceSerialNum,
		MasterVersion:   config.Server.MasterVersion,
		InstallTime:     installTime,
		WebVersion:      "1.0.0",
		DeviceDesc:      config.Server.DeviceDesc,
		ChannelCount:    int(sysconf.RealMax),
		NeedAuthPwd:     sysconf.NeedAuthPwd,
		AuthPwd:         sysconf.AuthPwd,
	}
	if strings.HasPrefix(util.GetPlatform(), "X86") {
		vg, _ := util.NvidiaVGpu()
		i.Detail.VGpu = vg
	}
	cmd := exec.Command("/bin/sh", "-c", "lsblk -d | grep -v part | grep -v SWAP | grep -v M | grep disk | awk '{printf $4\" \"}'")
	disks, _ := cmd.Output()
	cpu, _ := cpu.Info()
	mem, _ := mem.VirtualMemory()
	hi, _ := host.Info()
	i.Detail.Disk = string(disks)
	i.Detail.Runtime = util.TimeSpan(time.Unix(int64(hi.BootTime), 0))
	if cpu != nil && len(cpu) > 0 {
		i.Detail.Cpu = cpu[0].ModelName + " x " + trans.Any2String(len(cpu))
	}
	if mem != nil {
		i.Detail.Mem = mem.Total
	}

	//2.收集已安装算法
	var sdkApi bhomedbapi.SdkApi
	sdks := sdkApi.FindAll("")
	//3.收集已安装应用
	var appApi bhomedbapi.AppApi
	aps := appApi.FindAll("")

	i.Sdks = sdks
	i.Apps = aps
	//if err != nil {
	//	logger.Debug("hyjd GetDeviceInfo err:",err)
	//	return &bhomeclient.Reply{Success: false, Msg: "获取失败!" + err.Error()}
	//}
	logger.Debug("GetDeviceInfo Success data::", i)
	return &bhomeclient.Reply{Success: true, Msg: "获取成功!", Data: i}
}

// 配置远程服务器
func (sset SysSetController) GetRemoteServer(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	return &bhomeclient.Reply{Success: true, Msg: "获取成功!", Data: map[string]string{"appServer": config.ShopConf.LocalShop}}
}

func (sset SysSetController) SetRemoteServer(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	appServer := c.PostForm("appServer")
	if appServer == "" {
		return &bhomeclient.Reply{Success: false, Msg: "无效的参数配置"}
	}

	if config.ShopConf.LocalShop == "" {
		_, err := addVasystemConfig("localShop", appServer, "shop:")
		if err != nil {
			logger.Warn(err)
		}
	} else {
		_, err := editVasystemConfig("localShop", appServer, config.ShopConf.LocalShop)
		if err != nil {
			logger.Warn(err)
		}
	}

	return &bhomeclient.Reply{Success: true, Msg: "设置成功!", Data: ""}
}

// 追加配置
func addVasystemConfig(key, value, prevLine string) ([]byte, error) {
	configFilePath := "/opt/vasystem/config/pro.yaml"

	sedCmd := "sed -i '/" + prevLine + "/a\\    " + key + ": " + value + "' " + configFilePath
	logger.Debug("run commond:", sedCmd)
	cmd := exec.Command("/bin/sh", "-c", sedCmd)
	return cmd.Output()
}

// 替换配置
func editVasystemConfig(key, dstVal, srcVal string) ([]byte, error) {
	configFilePath := "/opt/vasystem/config/pro.yaml"

	sedCmd := "sed -i 's/" + key + ": " + srcVal + "/" + key + ": " + dstVal + "/g' " + configFilePath
	logger.Debug("run commond:", sedCmd)
	cmd := exec.Command("/bin/sh", "-c", sedCmd)
	return cmd.Output()
}