package controllers

import (
	"encoding/json"
	"errors"
	"fmt"
	"rtzh_elec_temperature/logger"
	"rtzh_elec_temperature/rtelec_app_public_lib/service"
	"rtzh_elec_temperature/tools"
	"strconv"

	"github.com/astaxie/beego/orm"
)

//数据优化相关服务
type DataOptimizeController struct {
	BaseController
}

// 获取算法优化策略开启状态 godoc
// @Summary      获取算法优化策略开启状态
// @Description  获取算法优化策略开启状态。包括以下状态字典：deletion_fill_rule(数据缺点填充规则)、deletion_fill_specifypoint(指定测点填充开启状态)、deletion_fill_randompoint(相邻测点填充开启状态)、invalid_fill_rule（无效数据填充规则）、invalid_show_rule(无效数据显示)，以上状态字典值均为1或者0.
// @Tags         api
// @Accept       x-www-form-urlencoded
// @Produce      json
// @Success      200    {object}  ApiOK|ApiError   服务访问成功
// @Failure 	 401 	status  认证未通过，一般是未指定token或token已失效
// @Failure 	 500 	status  服务器｜后台发生错误
// @router /rule_state/list [get]
func (c *DataOptimizeController) GetRuleState() {
	obj := new(service.DataoptimizeService)
	obj.UserInfo = c.GetCurrentUserInfo_rt()
	list := obj.GetRuleStatus()
	c.Data["json"] = c.ApiOK(list)
	c.ServeJSON()
}

// 设置算法优化策略开启状态 godoc
// @Summary      设置保存算法优化策略开启状态
// @Description  设置保存算法优化策略开启状态。包括以下状态字典：deletion_fill_rule(数据缺点填充规则)、deletion_fill_specifypoint(指定测点填充开启状态)、deletion_fill_randompoint(相邻测点填充开启状态)、invalid_fill_rule（无效数据填充规则）、invalid_show_rule(无效数据显示)，以上状态字典值均为1或者0.
// @Tags         api
// @Accept       x-www-form-urlencoded
// @Produce      json
// @Success      200    {object}  ApiOK|ApiError   服务访问成功
// @Param        rulecode  query     string      true  "规则代码。deletion_fill_rule(数据缺点填充规则)、deletion_fill_specifypoint(指定测点填充开启状态)、deletion_fill_randompoint(相邻测点填充开启状态)、invalid_fill_rule（无效数据填充规则）、invalid_show_rule(无效数据显示配置)"
// @Param        value  query     string      true "开启状态。仅支持1（启用）或0（禁用）"
// @Failure 	 401 	status  认证未通过，一般是未指定token或token已失效
// @Failure 	 500 	status  服务器｜后台发生错误
// @router /rule_state/save [post]
func (c *DataOptimizeController) SetRuleState() {
	obj := new(service.DataoptimizeService)
	obj.UserInfo = c.GetCurrentUserInfo_rt()
	err := obj.SetRuleStatus(c.GetString("rulecode"), c.GetString("value"))
	if err != nil {
		logger.Logger.Error(err)
		c.Data["json"] = c.ApiError(err.Error())
	} else {
		c.Data["json"] = c.ApiOK("")
	}
	c.ServeJSON()
}

// 获取数据优化配置测点列表 godoc
// @Summary      获取数据优化配置测点列表
// @Description  获取数据优化配置测点列表
// @Tags         api
// @Accept       x-www-form-urlencoded
// @Produce      json
// @Param        optimizetype  query     string      true  "填充规则类型。invalid：无效数据填充,其返回格式样例：{"data":{"Tem1":{"attrname":"Tem1","mpname":"测点温度1","value":["-10","20"]}},"msg":"操作成功","success":true}   deletion：缺点数据填充,其返回格式样例：{"data":[{"attrname":"Tem1","mpname":"测点温度1","value":[{"attrname":"Tem2","mpname":"温度2"},{"attrname":"Tem3","mpname":"温度3"}]}],"msg":"操作成功","success":true}"
// @Param        deviceid  query     string      false  "设备ID"
// @Param        modelid  query     string      false  "模型ID"
// @Success      200    {object}  ApiOK|ApiError   服务访问成功
// @Failure 	 401 	status  认证未通过，一般是未指定token或token已失效
// @Failure 	 500 	status  服务器｜后台发生错误
// @router /list [get]
func (c *DataOptimizeController) OptimizeList() {
	optimizetype := c.GetString("optimizetype")
	deviceid := c.GetString("deviceid", "0")
	modelid := c.GetString("modelid", "0")
	if deviceid == "0" && modelid == "0" {
		c.Data["json"] = c.ApiError("设备ID和模型ID不能同时为空")
		c.ServeJSON()
		return
	}
	obj := new(service.DataoptimizeService)
	obj.UserInfo = c.GetCurrentUserInfo_rt()
	list := []orm.Params{}
	var err error
	if optimizetype == "invalid" {
		list, err = obj.InvalidOptimizeCnfList()
	} else if optimizetype == "deletion" {
		list, err = obj.DeletionOptimizeCnfList()
	} else {
		err = errors.New("无效的数据优化类型")
	}
	deviceid32, _ := strconv.Atoi(deviceid)
	modelid64, _ := strconv.Atoi(modelid)
	if err != nil {
		c.Data["json"] = c.ApiError(err.Error())
	} else {
		allmplist := []orm.Params{}
		if deviceid32 == 0 {
			//获取模型定义
			modSrv := new(service.ModelService)
			modattrlist := modSrv.GetModelAttrList(int64(modelid64))
			for _, tmpRow := range modattrlist {
				tmpRow2 := tmpRow.(map[string]interface{})
				allmplist = append(allmplist, orm.Params{
					"attrname": tools.IsEmpty(tmpRow2["attr_name"]),
					"mpname":   tools.IsEmpty(tmpRow2["attr_name"]),
				})
			}
		} else {
			deviceObject := new(service.DeviceService)
			//获取设备测点
			allmplist, _, err = deviceObject.DeviceMpList(int32(deviceid32), 1, 1000, int64(modelid64))
			if err != nil {
				c.Data["json"] = c.ApiError(err.Error())
				c.ServeJSON()
				return
			}
		}
		cnfMap := map[string]orm.Params{}
		for _, row := range list {
			cnfMap[fmt.Sprintf("%v%v", row["model_id"], row["device_id"])] = row
		}
		if len(list) > 0 && "0" != deviceid && "0" != modelid {
			row := cnfMap[modelid+deviceid]
			cnfvalue := tools.IsEmpty(row["fill_cnf"])
			if cnfvalue != "" && optimizetype == "invalid" {
				cnfList := map[string]interface{}{}
				err = json.Unmarshal([]byte(cnfvalue), &cnfList)
				if err != nil {
					logger.Logger.Error(err)
					c.Data["json"] = c.ApiError(err.Error())
				} else {
					//无效数据规则组装
					resultMap := map[string]interface{}{}
					for _, mpitem := range allmplist {
						mpAttrname := tools.IsEmpty(mpitem["attrname"])
						if v, h := cnfList[mpAttrname]; h {
							v.(map[string]interface{})["mpname"] = tools.IsEmpty(mpitem["mpname"])
							resultMap[mpAttrname] = v
						} else {
							resultMap[mpAttrname] = map[string]interface{}{
								"attrname": mpAttrname,
								"mpname":   tools.IsEmpty(mpitem["mpname"]),
								"value":    []string{},
							}
						}
					}
					c.Data["json"] = c.ApiOK(resultMap)
				}
			} else if cnfvalue != "" && optimizetype == "deletion" {
				cnfList := []map[string]interface{}{}
				err = json.Unmarshal([]byte(cnfvalue), &cnfList)
				if err != nil {
					logger.Logger.Error(err, cnfvalue)
					c.Data["json"] = c.ApiError(err.Error())
				} else {
					deviceMpList := map[string]interface{}{}
					for _, row := range allmplist {
						attrname := tools.IsEmpty(row["attrname"])
						deviceMpList[attrname] = map[string]interface{}{
							"value":    []string{},
							"attrname": attrname,
							"mpname":   tools.IsEmpty(row["mpname"]),
						}
					}
					//缺点规则组装
					for _, mpitem := range cnfList {
						mpAttrname := tools.IsEmpty(mpitem["attrname"])
						if d1, h := deviceMpList[mpAttrname]; h {
							mpitem["mpname"] = tools.IsEmpty(d1.(map[string]interface{})["mpname"])
							filllist := mpitem["value"].([]interface{})
							for i2, tmpFillMp := range filllist {
								tmpFillMp2 := tmpFillMp.(map[string]interface{})
								attrname2 := tools.IsEmpty(tmpFillMp2["attrname"])
								tmpFillMp2["mpname"] = tools.IsEmpty(deviceMpList[attrname2].(map[string]interface{})["mpname"])
								filllist[i2] = tmpFillMp2
							}
							deviceMpList[mpAttrname] = mpitem
						}
					}
					fillResultList := []interface{}{}
					for _, tmpRow := range deviceMpList {
						fillResultList = append(fillResultList, tmpRow)
					}
					deviceMpList = nil
					c.Data["json"] = c.ApiOK(fillResultList)
				}
			}
			c.ServeJSON()
			return
		}
		//判断是否有模型规则设置，有则采用模型的测点规则设置
		if len(list) > 0 {
			row := cnfMap[modelid+"0"]
			if row != nil {
				cnfvalue := tools.IsEmpty(row["fill_cnf"])
				if optimizetype == "invalid" {
					cnfList := map[string]interface{}{}
					err = json.Unmarshal([]byte(cnfvalue), &cnfList)
					if err != nil {
						logger.Logger.Error(err)
						c.Data["json"] = c.ApiError(err.Error())
					} else {
						//无效数据规则组装
						resultMap := map[string]interface{}{}
						for _, mpitem := range allmplist {
							mpAttrname := tools.IsEmpty(mpitem["attrname"])
							if v, h := cnfList[mpAttrname]; h {
								v.(map[string]interface{})["mpname"] = tools.IsEmpty(mpitem["mpname"])
								resultMap[mpAttrname] = v
							} else {
								resultMap[mpAttrname] = map[string]interface{}{
									"attrname": mpAttrname,
									"mpname":   tools.IsEmpty(mpitem["mpname"]),
									"value":    []string{},
								}
							}
						}
						c.Data["json"] = c.ApiOK(resultMap)
					}
				} else if optimizetype == "deletion" {
					cnfList := []map[string]interface{}{}
					err = json.Unmarshal([]byte(cnfvalue), &cnfList)
					if err != nil {
						logger.Logger.Error(err)
						c.Data["json"] = c.ApiError(err.Error())
					} else {
						deviceMpList := map[string]interface{}{}
						for _, row := range allmplist {
							attrname := tools.IsEmpty(row["attrname"])
							deviceMpList[attrname] = map[string]interface{}{
								"value":    []string{},
								"attrname": attrname,
								"mpname":   tools.IsEmpty(row["mpname"]),
							}
						}
						//缺点规则组装
						for _, mpitem := range cnfList {
							mpAttrname := tools.IsEmpty(mpitem["attrname"])
							if d1, h := deviceMpList[mpAttrname]; h {
								mpitem["mpname"] = tools.IsEmpty(d1.(map[string]interface{})["mpname"])
								filllist := mpitem["value"].([]interface{})
								for i2, tmpFillMp := range filllist {
									tmpFillMp2 := tmpFillMp.(map[string]interface{})
									attrname2 := tools.IsEmpty(tmpFillMp2["attrname"])
									mpname := tools.IsEmpty(deviceMpList[attrname2].(map[string]interface{})["mpname"])
									tmpFillMp2["mpname"] = mpname
									filllist[i2] = tmpFillMp2
								}
								deviceMpList[mpAttrname] = mpitem
							}
						}
						fillResultList := []interface{}{}
						for _, tmpRow := range deviceMpList {
							fillResultList = append(fillResultList, tmpRow)
						}
						deviceMpList = nil
						c.Data["json"] = c.ApiOK(fillResultList)
					}
				}
				c.ServeJSON()
				return
			}

		}
		//未进行设置，采用模型或设备的测点
		if optimizetype == "invalid" {
			mpcnflist := map[string]interface{}{}
			for _, r := range allmplist {
				mpAttrname := tools.IsEmpty(r["attrname"])
				mpcnflist[mpAttrname] = map[string]interface{}{"attrname": mpAttrname, "mpname": tools.IsEmpty(r["mpname"]), "value": []string{"", ""}} //默认无效范围为未设置
			}
			c.Data["json"] = c.ApiOK(mpcnflist)
		} else if optimizetype == "deletion" {
			mpcnflist := []map[string]interface{}{}
			for _, r := range allmplist {
				mpAttrname := tools.IsEmpty(r["attrname"])
				mpcnflist = append(mpcnflist, map[string]interface{}{"attrname": mpAttrname, "mpname": tools.IsEmpty(r["mpname"]), "value": []interface{}{}}) //默认为未设置
			}
			c.Data["json"] = c.ApiOK(mpcnflist)
		}
		c.ServeJSON()
		return

	}
	c.ServeJSON()
}

// 编辑(添加或修改)算法优化
// @Summary      添加或编辑数据优化规则
// @Description  保存添加或编辑测点数据优化规则的提交数据
// @Tags         api
// @Accept       x-www-form-urlencoded
// @Produce      json
// @Param        optimizetype    query     int64   true  "填充规则类型。invalid：无效数据填充,其cnf参数值格式样例：{"Tem1":{"attrname":"Tem1","value":["-10","55"]}}   deletion：缺点数据填充,其cnf参数格式样例：[{"attrname":"Tem1","value":[{"attrname":"Tem2"},{"attrname":"Tem3"}]}]"
// @Param        cnf  query     string      false  "填充配置内容。JSON格式的序列化串."
// @Param        deviceid  query     string      false  "设备ID"
// @Param        modelid  query     string      false  "模型ID"
// @Success      200    {object}  ApiOK|ApiError   服务访问成功
// @Failure 	 401 	status  认证未通过，一般是未指定token或token已失效
// @Failure 	 500 	status  服务器｜后台发生错误
// @router /edit [post]
func (c *DataOptimizeController) EditOptimize() {
	optimizetype := c.GetString("optimizetype")
	deviceid, _ := c.GetInt32("deviceid")
	modelid, _ := c.GetInt64("modelid")
	cnf := c.GetString("cnf")
	if cnf == "" {
		c.Data["json"] = c.ApiError("配置内容不能为空")
		c.ServeJSON()
		return
	}
	if optimizetype == "invalid" {
		testObj := map[string]interface{}{}
		err := json.Unmarshal([]byte(cnf), &testObj)
		if err != nil {
			logger.Logger.Error(err, cnf)
			c.Data["json"] = c.ApiError("配置内容格式不正确")
			c.ServeJSON()
			return
		}
	} else {
		testObj := []interface{}{}
		err := json.Unmarshal([]byte(cnf), &testObj)
		if err != nil {
			logger.Logger.Error(err, cnf)
			c.Data["json"] = c.ApiError("配置内容格式不正确")
			c.ServeJSON()
			return
		}
	}
	obj := new(service.DataoptimizeService)
	obj.UserInfo = c.GetCurrentUserInfo_rt()
	err := obj.EditOptimize(optimizetype, modelid, deviceid, cnf)
	if err != nil {
		c.Data["json"] = c.ApiError(err.Error())
	} else {
		c.Data["json"] = c.ApiOK("编辑数据优化配置成功")
	}
	c.ServeJSON()
}

// 删除指定设备的无效数据优化规则
// @Summary      删除指定设备的无效数据优化规则
// @Description  删除指定设备的无效数据优化规则
// @Tags         api
// @Accept       x-www-form-urlencoded
// @Produce      json
// @Param        deviceid   query     int64   true  "设备ID"
// @Success      200    {object}  ApiOK|ApiError   服务访问成功
// @Failure 	 401 	status  认证未通过，一般是未指定token或token已失效
// @Failure 	 500 	status  服务器｜后台发生错误
// @router /delete/invalid_rule [post]
func (c *DataOptimizeController) DeleteInvalidOptimize() {
	deviceid, _ := c.GetInt32("deviceid")
	obj := new(service.DataoptimizeService)
	obj.UserInfo = c.GetCurrentUserInfo_rt()
	err := obj.DeleteOptimize("invalid", deviceid)
	if err != nil {
		c.Data["json"] = c.ApiError(err.Error())
	} else {
		c.Data["json"] = c.ApiOK("")
	}
	c.ServeJSON()
}

// 删除指定设备的缺点数据优化规则
// @Summary      删除指定设备的缺点数据优化规则
// @Description  删除指定设备的缺点数据优化规则
// @Tags         api
// @Accept       x-www-form-urlencoded
// @Produce      json
// @Param        deviceid   query     int64   true  "设备ID"
// @Success      200    {object}  ApiOK|ApiError   服务访问成功
// @Failure 	 401 	status  认证未通过，一般是未指定token或token已失效
// @Failure 	 500 	status  服务器｜后台发生错误
// @router /delete/deletion_rule [post]
func (c *DataOptimizeController) DeleteDeletionOptimize() {
	deviceid, _ := c.GetInt32("deviceid")
	obj := new(service.DataoptimizeService)
	obj.UserInfo = c.GetCurrentUserInfo_rt()
	err := obj.DeleteOptimize("deletion", deviceid)
	if err != nil {
		c.Data["json"] = c.ApiError(err.Error())
	} else {
		c.Data["json"] = c.ApiOK("")
	}
	c.ServeJSON()
}