package controllers

import (
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/logger.git"
	"context"
	"encoding/json"
	"github.com/satori/go.uuid"
	"nanomsg.org/go-mangos"
	"nanomsg.org/go-mangos/protocol/rep"
	"nanomsg.org/go-mangos/transport/ipc"
	"nanomsg.org/go-mangos/transport/tcp"
	"strconv"
	"time"
	"vamicro/devicemanage-service/broadcast"
	"vamicro/devicemanage-service/models"
	"vamicro/devicemanage-service/service"
	"vamicro/devicemanage-service/vo"
)

type DeviceController struct {

}

//搜索设备
func (dc *DeviceController) Search(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	nodes, err := broadcast.BroadCast()
	if err != nil {
		return &bhomeclient.Reply{ Msg: err.Error()}
	}
	if nodes == nil {
		nodes = make([]string, 0)
	}
	return &bhomeclient.Reply{ Success: true, Data: nodes}
}

//申请添加设备
func (dc *DeviceController) AddApply(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	type addApplyArg struct {
		Key 	string 	`json:"key"`
		DevId 	string 	`json:"devId"`
		Ip 		string 	`json:"ip"`
	}
	var reqBody addApplyArg
	err := c.BindJSON(&reqBody)
	if err != nil || reqBody.Key == "" || reqBody.DevId == "" || reqBody.Ip == "" {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	var da models.DeviceApply
	i,e := da.FindByDevId(reqBody.DevId)
	if e != nil || i == 0 { //未申请添加过此设备
		da.Id = uuid.NewV4().String()
		da.DevId = reqBody.DevId
		da.CreateTime = time.Now().Format("2006-01-02 15:04:05")
		da.ApplyKey = reqBody.Key
		da.Ip = reqBody.Ip
		da.Status = models.ApplyStatus_Sending
		if da.Insert() {
			return &bhomeclient.Reply{ Success: true, Msg: "添加成功"}
		} else {
			return &bhomeclient.Reply{ Success: true, Msg: "添加失败"}
		}
	} else if da.Status == models.ApplyStatus_Reject { //已被拒绝的请求，可以重新发起申请
		if da.UpdateStatus(models.ApplyStatus_Sending, da.Id) {
			return &bhomeclient.Reply{ Success: true, Msg: "操作成功"}
		} else {
			return &bhomeclient.Reply{ Msg: "重新发送请求失败"}
		}
	}

	return &bhomeclient.Reply{ Msg: "已添加对此设备的申请"}
}

func RecvApprove(ctx context.Context) {
	url := "0.0.0.0:"+strconv.Itoa(4012)
	var sock mangos.Socket
	var err error
	var msg []byte
	if sock, err = rep.NewSocket(); err != nil {
		logger.Debug("new applyApprove socket err:", err)
	}
	sock.AddTransport(ipc.NewTransport())
	sock.AddTransport(tcp.NewTransport())
	if err = sock.Listen(url); err != nil {
		logger.Debug("listen on applyApprove socket err:", err)
	}

	for {
		select {
		case <-ctx.Done():
			logger.Debug("ctx done")
			return
		default:
			msg, err = sock.Recv()
			if err != nil {
				continue
			}

			if len(msg) > 0 {
				apply := dealApprove(msg)
				ret, _ := json.Marshal(*apply)
				retErr := sock.Send(ret)
				if retErr != nil {
					logger.Debug("retErr:", retErr)
				}
			} else {
				time.Sleep(time.Millisecond*100)
			}
		}
	}
}

func dealApprove(msg []byte) *bhomeclient.Reply {
	type approveArg struct {
		DevId 	string 	`json:"devId"`  //设备id
		Status 	int 	`json:"status"` //-1表示拒绝，1：表示通过
	}

	var reqBody approveArg
	err := json.Unmarshal(msg, &reqBody)
	if err != nil || reqBody.Status < models.ApplyStatus_Reject || reqBody.Status > models.ApplyStatus_Agreed {
		return &bhomeclient.Reply{ Msg: "请求参数有误"}
	}
	var da models.DeviceApply
	i, _ := da.FindByDevId(reqBody.DevId)
	if i == 0 {
		return &bhomeclient.Reply{ Msg: reqBody.DevId+"的申请请求已不存在，请检查" }
	}
	if da.Status != models.ApplyStatus_Waiting {
		return &bhomeclient.Reply{ Msg: "当前此设备id不是申请状态，请检查" }
	}
	if da.UpdateStatus(reqBody.Status, da.Id) {
		return &bhomeclient.Reply{ Success: true, Msg: "操作成功"}
	}

	return &bhomeclient.Reply{ Msg: "操作失败"}
}

//其他节点通过申请或者拒绝申请
func (dc *DeviceController) ApplyApprove(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	return &bhomeclient.Reply{ Msg: "building..."}
}

//func (dc *DeviceController) SyncDevToManager(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
//	var reqBody sysVo.SyncDevInfo
//	err := c.BindJSON(&reqBody)
//	if err != nil {
//		return &bhomeclient.Reply{ Msg: err.Error() }
//	}
//
//	return &bhomeclient.Reply{ Data: reqBody }
//}

//设备归类统计，分全部设备、集群xx设备、未加入集群
func (dc *DeviceController) Types(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	type devStatistic struct {
		Name   		string 		`json:"name"`
		DevCount 	int 		`json:"devCount"`
		SdkCount 	int 		`json:"sdkCount"`
		Percent 	string 		`json:"percent"`
		ClusterId 	string 		`json:"clusterId"`
		Type 		int 		`json:"type"`
	}
	list := make([]devStatistic, 0)
	//1.统计全部设备
	total := devStatistic{
		Name: "全部设备",
		DevCount: 100,
		SdkCount: 45,
		Percent: "80%",
		Type: 0,
	}
	list = append(list, total)
	//2.按集群统计
	var d models.Device
	devCts := d.GroupByCluster()
	if devCts != nil {
		for _,g := range devCts {
			ds := devStatistic{
				Name: g.ClusterName,
				ClusterId: g.ClusterId,
				DevCount: g.Count,
				SdkCount: 0,
				Percent: "70%",
				Type: 1,
			}
			list = append(list, ds)
		}
	}
	//3.未加入集群设备
	ns := devStatistic{
		Name: "未加入集群",
		DevCount: 0,
		SdkCount: 0,
		Percent: "10%",
		Type: 2,
	}
	list = append(list, ns)

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

//通过不同类别获取设备列表,分页
func (dc *DeviceController) PageByType(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	type PageDevArg struct {
		Type 		int 	`json:"type"`  //类型
		ClusterId 	string 	`json:"clusterId"`   //集群id
		Status 		int 	`json:"status"`   //状态 0：全部，1：在线，-1：离线
		Page 		int 	`json:"page"`
		Size 		int 	`json:"size"`
		InputTxt 	string 	`json:"inputTxt"`
	}
	var reqBody PageDevArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg:err.Error()}
	}
	if reqBody.Page <= 0 {
		reqBody.Page = 1
	}
	if reqBody.Size <= 0 {
		reqBody.Size = 8
	}
	var d models.Device
	if reqBody.Type == 0 { //全部设备
		list, err := d.PageAllDev(reqBody.Page, reqBody.Size, reqBody.Status, reqBody.InputTxt)
		if err != nil {
			return &bhomeclient.Reply{ Msg: err.Error()}
		}
		return &bhomeclient.Reply{ Success: true, Data: list}
	} else if reqBody.Type == 1 || reqBody.Type == 2 {  //按集群统计
		list, err := d.PageDevByCluster(reqBody.Page, reqBody.Size, reqBody.ClusterId, reqBody.Status, reqBody.InputTxt)
		if err != nil {
			return &bhomeclient.Reply{ Msg: err.Error()}
		}
		return &bhomeclient.Reply{ Success: true, Data: list}
	}

	return nil
}

//获取设备详情
func (dc *DeviceController) Detail(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	devId := c.Query("devId")
	logger.Debug("Detail devId:", devId)
	var d models.Device
	i, e := d.FindByDevId(devId)
	if e == nil && i > 0 {
		detail := vo.DevDetail{}
		pd,_ := vo.CopyDeviceFromModel(d)
		detail.Device = pd
		detail.Sdks = getSdkDetailsByDevId(d.DevId)
		detail.Apps = getAppDetailsByDevId(d.DevId)


		return &bhomeclient.Reply{ Success:true, Data: detail }
	} else {
		return &bhomeclient.Reply{ Msg:"未找到此设备的相关信息"}
	}
}

func getSdkDetailsByDevId(devId string) []vo.SdkDetail {
	arr := make([]vo.SdkDetail, 0)

	var sdkApi bhomedbapi.SdkApi
	sdkMap := sdkApi.FindAllMap()

	var ds models.DeviceSdk
	list, _ := ds.FindByMachineCode("", devId)
	if list != nil {
		for _,s :=range list {
			if v,ok := sdkMap[s.SdkId]; ok {
				sd := vo.SdkDetail{}
				sd.Sdk = v
				sd.InstallTime = s.InstallTime
				sd.ExpireTime = s.ExpireTime
				sd.ActivateCode = s.ActivateCode
				arr = append(arr, sd)
			}
		}
	}
	return arr
}

func getAppDetailsByDevId(devId string) []vo.AppDetail {
	arr := make([]vo.AppDetail, 0)

	var appApi bhomedbapi.AppApi
	appMap := appApi.FindAppMap()

	var da models.DeviceApp
	list, _ := da.FindByMachineCode("", devId)
	if list != nil {
		for _,s :=range list {
			if v,ok := appMap[s.AppId]; ok {
				ad := vo.AppDetail{}
				ad.App = v
				ad.InstallTime = s.InstallTime
				ad.ExpireTime = s.ExpireTime
				ad.ActivateCode = s.ActivateCode
				arr = append(arr, ad)
			}
		}
	}
	return arr
}


//控制远程设备创建集群
func (dc *DeviceController) RemoteCreateCluster(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var reqBody vo.CreateClusterArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}

	r,err := service.RemoteCreateCluster(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error() }
}

//控制远程设备搜索集群
func (dc *DeviceController) RemoteSearchCluster(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var reqBody vo.SearchClusterArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	r, err := service.RemoteSearchCluster(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error() }
}

//获取远程设备搜索到的设备列表
func (dc *DeviceController) RemoteGetSearchNodes(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply {
	var reqBody vo.GetSearchNodesArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	r,err := service.RemoteGetSearchNodes(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{Msg: err.Error()}
}

//加入集群
func (dc *DeviceController) RemoteJoinCluster(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	var reqBody vo.JoinClusterArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	r,err := service.RemoteJoinCluster(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error()}
}

//设备重启
func (dc *DeviceController) RemoteReboot(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	var reqBody vo.RebootArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	r,err := service.RemoteReboot(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error()}
}

//移除设备
func (dc *DeviceController) RemoteRemove(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{

	return nil
}

//卸载算法或者应用
func (dc *DeviceController) RemoteUninstall(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	var reqBody vo.UninstallArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	r,err := service.RemoteUninstall(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error()}
}

//升级算法或者应用
func (dc *DeviceController) RemoteUpgrade(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	var reqBody vo.UpgradeArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}
	r,err := service.RemoteUpgrade(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error()}
}

//系统更新
func (dc *DeviceController) RemoteSysUpdate(h *bhomeclient.WrapperHandler, c *bhomeclient.Request) *bhomeclient.Reply{
	var reqBody vo.SysUpdateArg
	err := c.BindJSON(&reqBody)
	if err != nil {
		return &bhomeclient.Reply{ Msg: "参数有误"}
	}

	r,err := service.RemoteSysUpdate(reqBody)
	if err == nil {
		return r
	}
	return &bhomeclient.Reply{ Msg: err.Error()}
}