package flathandler

import (
	"errors"
	"fmt"

	business "device-manage/app/admin/models/busmodels"

	"device-manage/common/log"
	model "device-manage/common/mqttcli/flatbuffer/models"
	deviceopts "device-manage/common/mqttcli/flatbuffer/src/deviceopts/msg"

	flatbuffers "github.com/google/flatbuffers/go"
)

//create collect log data buffer
func CreateLogCollectBuffer(userid, url string, reply string) []byte {
	builder := flatbuffers.NewBuilder(0)
	userOffset := builder.CreateString(userid)
	urlOffset := builder.CreateString(url)
	replyOffset := builder.CreateString(reply)
	reasonOffset := builder.CreateString("collect log.")

	deviceopts.LogCollectStart(builder)
	deviceopts.LogCollectAddUserid(builder, userOffset)
	deviceopts.LogCollectAddUrl(builder, urlOffset)
	deviceopts.LogCollectAddReason(builder, reasonOffset)
	deviceopts.LogCollectAddReply(builder, replyOffset)
	deviceopts.LogCollectAddResult(builder, 0)
	dataOffset := deviceopts.LogCollectEnd(builder)

	deviceopts.PayloadStart(builder)
	deviceopts.PayloadAddTypeType(builder, deviceopts.PayloadsLogCollect)
	deviceopts.PayloadAddType(builder, dataOffset)
	payload := deviceopts.PayloadEnd(builder)
	builder.Finish(payload)

	buffer := builder.FinishedBytes()
	return buffer
}

//create App Install data buffer
func CreateFileUpgradeBuffer(userid, url, appKey, reply, fileUid string) []byte {
	builder := flatbuffers.NewBuilder(0)
	userOffset := builder.CreateString(userid)
	urlOffset := builder.CreateString(url)
	keyOffset := builder.CreateString(appKey)
	fileUidOffset := builder.CreateString(fileUid)
	reasonOffset := builder.CreateString("app install.")
	replyOffset := builder.CreateString(reply)

	deviceopts.FileUpgradeStart(builder)
	deviceopts.FileUpgradeAddUrl(builder, urlOffset)
	deviceopts.FileUpgradeAddUserid(builder, userOffset)
	deviceopts.FileUpgradeAddAppkey(builder, keyOffset)
	deviceopts.FileUpgradeAddReason(builder, reasonOffset)
	deviceopts.FileUpgradeAddUid(builder, fileUidOffset)
	deviceopts.FileUpgradeAddReply(builder, replyOffset)
	deviceopts.FileUpgradeAddResult(builder, 0)
	dataOffset := deviceopts.FileUpgradeEnd(builder)

	deviceopts.PayloadStart(builder)
	deviceopts.PayloadAddTypeType(builder, deviceopts.PayloadsFileUpgrade)
	deviceopts.PayloadAddType(builder, dataOffset)
	payload := deviceopts.PayloadEnd(builder)
	builder.Finish(payload)

	buffer := builder.FinishedBytes()
	return buffer
}

//create reboot data buffer
func CreateRebootBuffer(reqtime int64, reply string) []byte {
	builder := flatbuffers.NewBuilder(0)
	reasonOffset := builder.CreateString("reboot.")
	replyOffset := builder.CreateString(reply)

	deviceopts.RebootStart(builder)
	deviceopts.RebootAddResult(builder, 0)
	deviceopts.RebootAddReqtime(builder, reqtime)
	deviceopts.RebootAddReply(builder, replyOffset)
	deviceopts.RebootAddReason(builder, reasonOffset)
	dataOffset := deviceopts.RebootEnd(builder)

	deviceopts.PayloadStart(builder)
	deviceopts.PayloadAddTypeType(builder, deviceopts.PayloadsReboot)
	deviceopts.PayloadAddType(builder, dataOffset)
	payload := deviceopts.PayloadEnd(builder)
	builder.Finish(payload)
	buffer := builder.FinishedBytes()
	return buffer
}

//create heartbeat buffer
func CreateHeartbeatBuffer(messg *model.Heartbeat) []byte {
	builder := flatbuffers.NewBuilder(0)
	serialOffset := builder.CreateString(messg.Serial)
	ipOffset := builder.CreateString(messg.DeviceIp)
	gpsOffset := builder.CreateString(messg.Gps)
	devtypeOffset := builder.CreateString(messg.Devtype)
	softverOffset := builder.CreateString(messg.Softver)

	deviceopts.HeartBeatEventStart(builder)
	deviceopts.HeartBeatEventAddGps(builder, gpsOffset)
	deviceopts.HeartBeatEventAddDeviceip(builder, ipOffset)
	deviceopts.HeartBeatEventAddSerial(builder, serialOffset)
	deviceopts.HeartBeatEventAddSoftver(builder, softverOffset)
	deviceopts.HeartBeatEventAddDevtype(builder, devtypeOffset)
	deviceopts.HeartBeatEventAddStatus(builder, int32(messg.Status))
	deviceopts.HeartBeatEventAddNettype(builder, int32(messg.Nettype))
	dataOffset := deviceopts.HeartBeatEventEnd(builder)

	deviceopts.PayloadStart(builder)
	deviceopts.PayloadAddTypeType(builder, deviceopts.PayloadsHeartBeatEvent)
	deviceopts.PayloadAddType(builder, dataOffset)
	payload := deviceopts.PayloadEnd(builder)
	builder.Finish(payload)
	buffer := builder.FinishedBytes()
	return buffer
}

func FlatbufferHandler(deviceSn string, buf []byte) error {
	var err error = errors.New("null")
	msg := deviceopts.GetRootAsPayload(buf, 0)
	unionTable := new(flatbuffers.Table)
	if msg.Type(unionTable) {
		unionType := msg.TypeType()
		switch unionType {
		case deviceopts.PayloadsLogCollect:
			{
				fmt.Println("Cmd: LogCollect")
				unionData := new(deviceopts.LogCollect)
				unionData.Init(unionTable.Bytes, unionTable.Pos)
				result := unionData.Result()
				reason := unionData.Reason()
				url := unionData.Url()
				fmt.Println("result:　", result, " reason: ", string(reason), " url: ", string(url))
				log.Info("[recv: %s LogCollect][Result:%s][Reason:%s]\n", deviceSn, result, string(reason))

				if result == 0 {
					err = nil
				} else {
					err = errors.New(string(reason))
				}
				return err
			}
		case deviceopts.PayloadsHeartBeatEvent:
			{
				unionData := new(deviceopts.HeartBeatEvent)
				unionData.Init(unionTable.Bytes, unionTable.Pos)
				serial := unionData.Serial()
				devip := unionData.Deviceip()
				sevip := unionData.Serverip()
				gps := unionData.Gps()
				status := unionData.Status()
				nettype := unionData.Nettype()
				devtype := unionData.Devtype()
				softver := unionData.Softver()
				fmt.Println("serial:", string(serial))
				fmt.Println("devip:", string(devip))
				fmt.Println("sevip:", string(sevip))
				fmt.Println("gps:", string(gps))
				fmt.Println("status:", status)
				fmt.Println("nettype:", nettype)
				fmt.Println("devtype:", string(devtype))
				fmt.Println("softver:", string(softver))
				var hbeatInfo model.Heartbeat
				hbeatInfo.Devtype = string(devtype)
				hbeatInfo.Gps = string(gps)
				hbeatInfo.DeviceIp = string(devip)
				hbeatInfo.ServerIp = string(sevip)
				hbeatInfo.Nettype = int(nettype)
				hbeatInfo.Serial = string(serial)
				hbeatInfo.Softver = string(softver)
				hbeatInfo.Status = int(status)
				go func() {
					business.DevicesHeartBeat(&hbeatInfo)
				}()
				//log.Info("[recv: %s HBeat][status:%s][devtype:%s]\n", string(serial), status, string(devtype))
				return nil
			}
		case deviceopts.PayloadsUpgradeRecordEvent:
			{
				unionData := new(deviceopts.UpgradeRecordEvent)
				unionData.Init(unionTable.Bytes, unionTable.Pos)
				userid := unionData.Userid()
				url := unionData.Url()
				uid := unionData.Uid()
				appkey := unionData.Appkey()
				result := unionData.Result()
				reason := unionData.Reason()
				fmt.Println("deviceSn:", string(deviceSn))
				fmt.Println("userid:", string(userid))
				fmt.Println("url:", string(url))
				fmt.Println("uid:", string(uid))
				fmt.Println("appkey:", string(appkey))
				fmt.Println("result:", result)
				fmt.Println("reason:", reason)
				var record business.BusUpgradeRecord
				record.Uid = string(uid)
				record.DeviceSn = deviceSn
				record.CreateBy = string(userid)
				record.Insert()
				/* var hbeatInfo model.Heartbeat
				hbeatInfo.Devtype = string(devtype)
				hbeatInfo.Gps = string(gps)
				hbeatInfo.DeviceIp = string(devip)
				hbeatInfo.ServerIp = string(sevip)
				hbeatInfo.Nettype = int(nettype)
				hbeatInfo.Serial = string(serial)
				hbeatInfo.Softver = string(softver)
				hbeatInfo.Status = int(status)
				go func() {
					business.DevicesHeartBeat(&hbeatInfo)
				}() */
				//log.Info("[recv: %s HBeat][status:%s][devtype:%s]\n", string(serial), status, string(devtype))
				return nil
			}
		case deviceopts.PayloadsFileUpgrade:
			{
				fmt.Println("Cmd: FileUpgrade")
				unionData := new(deviceopts.FileUpgrade)
				unionData.Init(unionTable.Bytes, unionTable.Pos)
				result := unionData.Result()
				reason := unionData.Reason()
				url := unionData.Url()
				fmt.Println("result:　", result, " reason: ", string(reason), " url: ", string(url))
				//log.Info("[recv: %s AppInstall][Result:%s][Reason:%s]\n", deviceSn, result, string(reason))
				if result == 0 {
					err = nil
				} else {
					err = errors.New(string(reason))
				}
				return err
			}
		case deviceopts.PayloadsReboot:
			{
				fmt.Println("Cmd: Reboot")
				unionData := new(deviceopts.Reboot)
				unionData.Init(unionTable.Bytes, unionTable.Pos)
				result := unionData.Result()
				reason := unionData.Reason()
				reqtime := unionData.Reqtime()
				fmt.Println("result:　", result, " reason: ", string(reason), " reqtime: ", reqtime)
				//log.Info("[recv: %s Reboot][Result:%s][Reason:%s]\n", deviceSn, result, string(reason))
				if result == 0 {
					err = nil
				} else {
					err = errors.New(string(reason))
				}
				return err
			}
		default:
			fmt.Println("unknow type")
		}
		return err
	}
	return err
}