package iot

import (
	"encoding/json"
	"fmt"

	"myschools.me/suguo/hikvision/iot/model"
)

/*
	基础服务能力 > 设备管理 > 设备接入管理
*/

const (
	ACCESS_BASE     = "https://api2.hik-cloud.com/api/v1/open/basic/devices"
	ACCESS_REGISTER = ACCESS_BASE + "/create"
	ACCESS_DELETE   = ACCESS_BASE + "/delete"
	ACCESS_UPDATE   = ACCESS_BASE + "/update"
	ACCESS_DETAIL   = ACCESS_BASE + "/get"
	ACCESS_LIST     = ACCESS_BASE + "/list"
	ACCESS_ACCOUNT  = ACCESS_BASE + "/actions/deviceCount"
	ACCESS_STATUS   = ACCESS_BASE + "https://api2.hik-cloud.com/api/v1/ezviz/devices/queryDeviceStatus"
	ACCESS_REBOOT   = ACCESS_BASE + "/actions/system/reboot"

	// 设备校时配置
	TIME_BASE         = "https://api2.hik-cloud.com/api/v1/device/isapi/system/time"
	TIME_NTPCFG       = TIME_BASE + "/ntpServers"
	TIM_NTPSERVER_CFG = TIME_BASE + "/ntpServers/config"
)

// 注册设备到对应分组内。
//
// 注册设备时首先会将设备添加到平台，然后异步同步设备通道。如果设备添加成功而同步设备通道失败，则可以先获取设备列表信息，再手动调用通道同步接口同步设备下的通道。\
func DeivceRegister(deviceserial, groupno, validatecode string) (*model.DeviceData, error) {

	req := &struct {
		DeviceSerial string `json:"deviceSerial"` //设备序列号
		GroupNo      string `json:"groupNo"`      //组编号
		ValidateCode string `json:"validateCode"` //验证码
	}{

		DeviceSerial: deviceserial,
		GroupNo:      groupno,
		ValidateCode: validatecode,
	}

	resp, err := hikvisionRequest("POST", ACCESS_REGISTER, req)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data model.DeviceData `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data, nil
}

// 从某一分组内删除设备
func DeivceDelete(deviceSerial string) (*model.Hikvision, error) {
	resp, err := hikvisionRequest("POST", fmt.Sprintf("%s?deviceSerial=%s", ACCESS_DELETE, deviceSerial), nil)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

// 该接口用于修改设备名称
func DeivceUpdate(deviceserial, devicename string) (*model.Hikvision, error) {

	req := &struct {
		DeviceSerial string `json:"deviceSerial"` //设备序列号
		DeviceName   string `json:"deviceName"`   //设备名称
	}{
		DeviceSerial: deviceserial,
		DeviceName:   devicename,
	}

	resp, err := hikvisionRequest("POST", ACCESS_UPDATE, req)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

// 该接口用于根据设备序列号获取单个设备详细信息
func DeivceDetail(deviceSerial string) (*model.DeviceData, error) {
	resp, err := hikvisionRequest("GET", fmt.Sprintf("%s?deviceSerial=%s", ACCESS_DETAIL, deviceSerial), nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data model.DeviceData `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data, nil
}

// 该接口用于查询某组下设备列表信息 ,组编号，页数，页行数
func DeivceList(groupno string, pageno, pagesize int) (*model.DeivceListData, error) {
	url := fmt.Sprintf("%s?groupNo=%s&pageNo=%d&pageSize=%d", ACCESS_LIST, groupno, pageno, pagesize)
	resp, err := hikvisionRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data model.DeivceListData `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data, nil
}

// 该接口用于获取用户接入的设备总数
func DeivceNum() (*int, error) {

	resp, err := hikvisionRequest("GET", ACCESS_ACCOUNT, nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data struct {
			TotalCount int `json:"totalCount"`
		} `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data.TotalCount, nil
}

// 该接口用于查询设备的状态信息，目前仅支持萤石设备 /*测试未通过*/
func DeivceStatus(deviceserial string) (*model.DeivceStatusData, error) {

	resp, err := hikvisionRequest("GET", fmt.Sprintf("%s?deviceSerial=%s", ACCESS_STATUS, deviceserial), nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data model.DeivceStatusData `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data, nil
}

// 该接口用于重启设备，请谨慎操作
func DeivceReboot(deviceserial string) (*model.Hikvision, error) {
	params := &struct {
		DeviceSerial string `json:"deviceSerial"`
	}{
		DeviceSerial: deviceserial,
	}

	resp, err := hikvisionRequest("POST", ACCESS_REBOOT, params)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

/*
确权流程说明
设备接入政策进行了如下调整：
（1）设备首次激活，需要在规定的时间（72小时）内上线平台，否则，上线时需要走确权流程；
（2）设备重新注册平台，删除设备并重新添加设备超过规定时间（72小时）需要走确权流程；

什么时候需要进行确权
注册设备接口返回内容code=60058时，需要进行设备确权操作。
*/

// 下线确认
func DeivceOffline(deviceserial string) (*model.Hikvision, error) {

	resp, err := hikvisionRequest("GET", fmt.Sprintf("https://api2.hik-cloud.com/v1/carrier/wing/endpoint/confirm/right/offlineconfirm?deviceSerial=%s", deviceserial), nil)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

// 上线线确认
func DeivceOnline(deviceserial string) (*model.Hikvision, error) {

	resp, err := hikvisionRequest("GET", fmt.Sprintf("https://api2.hik-cloud.com/v1/carrier/wing/endpoint/confirm/right/onlineconfirm?deviceSerial=%s", deviceserial), nil)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

// 该接口用于获取设备当前校时配置
func DeviceGetTimeMode(deviceserial string) (*string, error) {
	resp, err := hikvisionRequest("GET", fmt.Sprintf("%s?deviceSerial=%s", TIME_BASE, deviceserial), nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data struct {
			TimeMode string `json:"timeMode"`
		} `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data.TimeMode, nil
}

// 该接口用于配置设备校时模式
func DeviceSetTimeMode(deviceSerial, timeMode string) (*model.Hikvision, error) {

	req := &struct {
		DeviceSerial string `json:"deviceSerial"`
		TimeMode     string `json:"timeMode"`
	}{
		DeviceSerial: deviceSerial,
		TimeMode:     timeMode,
	}

	resp, err := hikvisionRequest("POST", TIME_BASE, req)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

// 该接口用于获取设备当前NTP服务器配置
func DeviceGetNTPCfg(deviceserial string) (*model.DeviceSetNTPCfgServer, error) {
	resp, err := hikvisionRequest("GET", fmt.Sprintf("%s?deviceSerial=%s", TIME_NTPCFG, deviceserial), nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data model.DeviceSetNTPCfgServer `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data, nil
}

// 该接口用于配置设备NTP服务器参数
func DeviceSetNTPCfg(deviceSerial string, ntpserver *model.DeviceSetNTPCfgServer) (*model.Hikvision, error) {

	req := &struct {
		DeviceSerial string                      `json:"deviceSerial"`
		NtpServer    model.DeviceSetNTPCfgServer `json:"ntpServer"`
	}{
		DeviceSerial: deviceSerial,
		NtpServer:    *ntpserver,
	}

	resp, err := hikvisionRequest("POST", TIME_NTPCFG, req)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}

// 该接口用于获取设备指定NTP服务器配置
func DeviceGetNTPServerCfg(deviceserial string, ntpserverid int) (*model.DeviceSetNTPCfgServer, error) {
	resp, err := hikvisionRequest("GET", fmt.Sprintf("%s?deviceSerial=%s&ntpServerId=%d", TIM_NTPSERVER_CFG, deviceserial, ntpserverid), nil)
	if err != nil {
		return nil, err
	}
	var result = &struct {
		model.Hikvision
		Data model.DeviceSetNTPCfgServer `json:"data"`
	}{}
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return &result.Data, nil
}

// 该接口用于配置设备指定NTP服务器参数
func DeviceSetNTPServerCfg(req model.DeviceSetNTPServerCfgReq) (*model.Hikvision, error) {
	resp, err := hikvisionRequest("POST", TIM_NTPSERVER_CFG, req)
	if err != nil {
		return nil, err
	}
	var result *model.Hikvision
	if err := json.Unmarshal(resp, &result); err != nil {
		return nil, err
	}

	if result.Code != 200 {
		return nil, fmt.Errorf("result errcode:%d errmsg:%s", result.Code, result.Message)
	}
	return result, nil
}