package service

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"rtzh_elec_temperature/enum"
	"rtzh_elec_temperature/global"
	"rtzh_elec_temperature/logger"
	"rtzh_elec_temperature/models/bo"
	"rtzh_elec_temperature/tools"
	"strconv"
	"sync"
	"time"

	"github.com/spf13/cast"

	"git.rtzhtech.cn/iss/public-lib/logic"

	"git.rtzhtech.cn/iss/public-lib/model"

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

//设备测点分组模型(本地库)
type t_data_mp_group struct {
	Id        int    `"pk;auto"` //(11) NOT NULL AUTO_INCREMENT,
	Deviceid  int32  //(11) NOT NULL,
	Groupid   int64  //(11) NOT NULL,
	Groupname string //varchar(20) NOT NULL,
	Mpid      int64  //(20) NOT NULL,
	Attrname  string
}

//设备测点列表缓存
var mpList = sync.Map{}

//测点相关服务
type MpinfoService struct {
	BaseService
}

func init() {
	orm.RegisterModel(new(t_data_mp_group))
}

// 根据模型ID获取对应的测点定义
// 返回对应的mpid、mpname、attrname等
func (t *MpinfoService) MpList(modelid int) []orm.Params {
	key := fmt.Sprintf("%d", modelid)
	var list = []orm.Params{}
	if info, ok := mpList.Load(key); ok {
		return info.([]orm.Params)
	} else {
		db := orm.NewOrm()
		db.Using("iss")
		var sqlCommandText = "select * from dev_mpinfo where appid=? and modelid=?"
		_, err := db.Raw(sqlCommandText, RtelecManageApp().RegAppID, modelid).Values(&list)
		if err == nil {
			if len(list) > 0 {
				mpList.Store(key, list)
				return list
			}
		} else {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Error SQL:%s 参数:%s,%s", sqlCommandText, RtelecManageApp().RegAppID, modelid))
		}
	}
	return list
}

//根据测点id获取测点信息
func (t *MpinfoService) GetMpinfo(mpid int64) (orm.Params, error) {
	db := orm.NewOrm()
	db.Using("iss")
	rowset := []orm.Params{}
	sqlCommandText := "select * from dev_mpinfo where appid=? and mpid=?"
	_, err := db.Raw(sqlCommandText, RtelecManageApp().RegAppID, mpid).Values(&rowset)
	if err == nil {
		if len(rowset) > 0 {
			return rowset[0], nil
		}
	} else {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error SQL:%s 参数:%s,%d", sqlCommandText, RtelecManageApp().RegAppID, mpid))
		return orm.Params{}, err
	}
	return orm.Params{}, nil
}

//获取测点参数
func (t *MpinfoService) GetMpField(mpinfo_parameter string, AppId, ModelId int32) ([]model.DevMpinfo, error) {
	var MpField []model.DevMpinfo
	if mpinfo_parameter == "" {
		return MpField, nil
	}
	var MpData []map[string]interface{}
	bytes := []byte(mpinfo_parameter)
	json_err := json.Unmarshal(bytes, &MpData)
	if json_err != nil {
		return MpField, errors.New("测点信息不是标准的json格式!")
	} else {
		for _, Record := range MpData {
			var newFile model.DevMpinfo
			if mpid, ok := Record["mpid"]; ok && tools.IsEmpty(mpid) != "" {
				_id := mpid.(string)
				newFile.Mpid, _ = strconv.ParseInt(_id, 10, 64)
			}
			if mpname, ok := Record["mpname"]; ok && tools.IsEmpty(mpname) != "" {
				newFile.Mpname = mpname.(string)
			}
			if newFile.Mpname == "" {
				return MpField, errors.New("测点信息不允许为空!")
			}
			if zonename, ok := Record["zonename"]; ok && tools.IsEmpty(zonename) != "" {
				newFile.Zonename = zonename.(string)
			}
			if position, ok := Record["positionname"]; ok && tools.IsEmpty(position) != "" {
				newFile.Positionname = position.(string)
			}
			if unit, ok := Record["unit"]; ok && tools.IsEmpty(unit) != "" {
				newFile.Unit = unit.(string)
			}
			if online, ok := Record["online"]; ok && tools.IsEmpty(online) != "" {
				var OnLine = ""
				if reflect.TypeOf(online).Kind() == reflect.Float64 {
					OnLine = strconv.FormatFloat(online.(float64), 'f', 10, 64)
				} else {
					OnLine = online.(string)
				}
				if _online, toerr := strconv.Atoi(OnLine); toerr == nil {
					newFile.Online = int32(_online)
				}
			}
			if attrname, ok := Record["attrname"]; ok && tools.IsEmpty(attrname) != "" {
				newFile.Attrname = attrname.(string)
			}
			newFile.Appid = AppId
			newFile.Modelid = ModelId
			MpField = append(MpField, newFile)
		}
	}
	return MpField, nil
}

//获取控制点参数
func (t *MpinfoService) GetControlField(mpinfo_parameter string, AppId, ModelId int32, deviceid int64) ([]map[string]interface{}, error) {
	var Result []map[string]interface{}
	if mpinfo_parameter == "" {
		return Result, nil
	}
	var ControlData []map[string]interface{}
	bytes := []byte(mpinfo_parameter)
	json_err := json.Unmarshal(bytes, &ControlData)
	if json_err != nil {
		return Result, errors.New("控制点信息不是标准的json格式!")
	} else {
		for _, Record := range ControlData {
			var Cpinfo model.CpMpinfo
			var rowRecord = make(map[string]interface{})
			if cpid, ok := Record["cpid"]; ok && tools.IsEmpty(cpid) != "" {
				_cpid := tools.IsEmpty(cpid)
				Cpinfo.Cpid, _ = strconv.ParseInt(_cpid, 10, 64)
			}
			if cpname, ok := Record["cpname"]; ok && tools.IsEmpty(cpname) != "" {
				Cpinfo.Cpname = cpname.(string)
			}
			if Cpinfo.Cpname == "" {
				return Result, errors.New("控制点名称不允许为空!")
			}
			if zonename, ok := Record["zonename"]; ok && tools.IsEmpty(zonename) != "" {
				Cpinfo.Zonename = zonename.(string)
			}
			if Cpinfo.Zonename == "" {
				return Result, errors.New("控制点所在区域不允许为空!")
			}
			if position, ok := Record["positionname"]; ok && tools.IsEmpty(position) != "" {
				Cpinfo.Positionname = position.(string)
			}
			if attrname, ok := Record["attrname"]; ok && tools.IsEmpty(attrname) != "" {
				Cpinfo.Attrname = attrname.(string)
			}
			if mpname, ok := Record["mpname"]; ok && tools.IsEmpty(mpname) != "" {
				//这里进行查找
				// Cpinfo.Mpid, _ = strconv.ParseInt(_mpid, 10, 64)
				Mpinfo, err := logic.GetMpidByMpnameDeviceId(deviceid, mpname.(string), int(AppId))
				if err != nil {
					tools.Log(err)
				}
				Cpinfo.Mpname = mpname.(string)
				Cpinfo.Mpid = Mpinfo
			}
			Cpinfo.Appid = AppId
			Cpinfo.Modelid = ModelId
			rowRecord["control"] = Cpinfo //控制点记录
			//控制点动作记录
			var ActionField []model.DevCpaction
			if action_parameter, ok := Record["actiondata"]; ok {
				if reflect.TypeOf(action_parameter).Kind() == reflect.Slice {
					ActionData := action_parameter.([]interface{})
					for _, ActionRow := range ActionData {
						row := ActionRow.(map[string]interface{})
						var RowField model.DevCpaction
						if id, ok := row["actid"]; ok && tools.IsEmpty(id) != "" {
							RowField.Actid, _ = strconv.ParseInt(tools.IsEmpty(id), 10, 64)
						}
						if acttype, ok := row["acttype"]; ok && tools.IsEmpty(acttype) != "" {
							var act_type = tools.IsEmpty(acttype)
							acttypeValue, _ := strconv.Atoi(act_type)
							RowField.Acttype = int32(acttypeValue)
						}
						if desc, ok := row["actdesc"]; ok && tools.IsEmpty(desc) != "" {
							RowField.Actdesc = desc.(string)
						}
						if value, ok := row["value"]; ok && tools.IsEmpty(value) != "" {
							_value := tools.IsEmpty(value)
							newValue, _ := strconv.ParseInt(_value, 10, 64)
							RowField.Value = float64(newValue)
						}
						if delay, ok := row["delay"]; ok && tools.IsEmpty(delay) != "" {
							var _actionDelay = tools.IsEmpty(delay)
							actionDelay, _ := strconv.Atoi(_actionDelay)
							RowField.Delay = int32(actionDelay)
						}
						if v, ok := row["successval"]; ok && tools.IsEmpty(v) != "" {
							RowField.Successval, _ = strconv.ParseFloat(tools.IsEmpty(v), 64)
						} else {
							RowField.Successval, _ = strconv.ParseFloat(tools.IsEmpty(row["value"]), 64)
						}
						ActionField = append(ActionField, RowField)
					}
				}
			}
			if len(ActionField) == 0 {
				return []map[string]interface{}{}, errors.New("控制点动作不允许为空,请检查传入参数！")
			}
			rowRecord["action"] = ActionField
			Result = append(Result, rowRecord)
		}
	}
	return Result, nil
}

//保存测点分组
func (t *MpinfoService) SaveGroup(deviceid int32, groupid int64, groupname string, mps []string) error {
	if len(mps) == 0 {
		return errors.New("分组测点不能为空")
	}
	if len(mps) < 2 {
		return errors.New("同一分组测点数不能小于2个")
	}
	if len(mps) > 3 {
		return errors.New("同一分组测点数不能大于3个")
	}
	if groupname == "" {
		return errors.New("分组名称不能为空")
	}
	devSrv := new(DeviceService)
	key := fmt.Sprintf("GroupList_%d", deviceid)
	key2 := fmt.Sprintf("GroupList_mp_%d_%d", deviceid, groupid)
	db := orm.NewOrm()
	sql := "select groupid from t_data_mp_group where deviceid=? and groupname=?"
	rowset := []orm.Params{}
	sqlparams := []interface{}{deviceid, groupname}
	_, err := db.Raw(sql, sqlparams).Values(&rowset)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("SQL:%s 参数：%+v", sql, sqlparams))
		return err
	}
	if len(rowset) > 0 && groupid != cast.ToInt64(rowset[0]["groupid"]) {
		return errors.New("分组名称" + groupname + "已存在")
	}
	if groupid == 0 {
		groupid = time.Now().Unix()
	} else {
		//清除原分组测点
		db.Raw("delete from t_data_mp_group where deviceid=? and groupid=?", deviceid, groupid).Exec()
		global.GoCahce.Delete(key2)
	}
	//获取设备测点列表
	mpMap := devSrv.DeviceMpInfo(deviceid)
	var getAttrNameByMpid = func(mpmap map[string]orm.Params, mpid string) string {
		for _, row := range mpmap {
			if tools.IsEmpty(row["mpid"]) == mpid {
				return tools.IsEmpty(row["attrname"])
			}
		}
		return ""
	}
	db.Begin()
	for _, k := range mps {
		obj := t_data_mp_group{}
		obj.Deviceid = deviceid
		obj.Groupid = groupid
		obj.Groupname = groupname
		obj.Mpid, _ = strconv.ParseInt(k, 10, 64)
		obj.Attrname = getAttrNameByMpid(mpMap, k)
		_, err = db.Insert(&obj)
		if err != nil {
			db.Rollback()
			logger.Logger.Error(err)
			new(bo.SystemLog).Fail(enum.AuditType_mp,
				enum.LogType_Insert,
				enum.OptEventType_Bus,
				enum.OptEventLevel_Hight,
				fmt.Sprintf("创建测点分组失败:%s 操作数据：%+v", err.Error(), obj),
				map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
			)
			return err
		}
	}
	err = db.Commit()
	if err != nil {
		logger.Logger.Error(err)
		new(bo.SystemLog).Fail(enum.AuditType_mp,
			enum.LogType_Insert,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("创建测点分组失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	global.GoCahce.Delete(key)
	new(bo.SystemLog).Success(enum.AuditType_mp,
		enum.LogType_Insert,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		"创建测点分组成功",
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return err
}

//删除指定测点的分组记录
func (t *MpinfoService) DeleteMp(deviceid int32, mpId int64) error {
	key := fmt.Sprintf("GroupList_%d", deviceid)
	db := orm.NewOrm()
	sql := "delete from t_data_mp_group where deviceid=? and mpid=?"
	_, err := db.Raw(sql, deviceid, mpId).Exec()
	if err != nil {
		logger.Logger.Error(err)
		return err
	}
	global.GoCahce.Delete(key)
	return nil
}

//根据设备查询测点分组列表
func (t *MpinfoService) GroupList(deviceid int32) ([]orm.Params, error) {
	key := fmt.Sprintf("GroupList_%d", deviceid)
	if v, h := global.GoCahce.Get(key); h {
		return v.([]orm.Params), nil
	}
	sql := "select groupid,groupname from t_data_mp_group where deviceid=? group by groupid ORDER BY groupid"
	rowset := []orm.Params{}
	_, err := orm.NewOrm().Raw(sql, deviceid).Values(&rowset)
	if err != nil {
		logger.Logger.Error(err)
		return nil, err
	}
	global.GoCahce.Set(key, rowset, -1)
	return rowset, nil
}

//根据设备查询分组中的测点列表
func (t *MpinfoService) GroupMpList(deviceid int32, groupid int64) ([]orm.Params, error) {
	key := fmt.Sprintf("GroupList_mp_%d_%d", deviceid, groupid)
	if v, h := global.GoCahce.Get(key); h {
		return v.([]orm.Params), nil
	}
	sql := "select * from t_data_mp_group where deviceid=? and groupid=?"
	rowset := []orm.Params{}
	_, err := orm.NewOrm().Raw(sql, deviceid, groupid).Values(&rowset)
	if err != nil {
		logger.Logger.Error(err)
		return nil, err
	}
	global.GoCahce.Set(key, rowset, -1)
	return rowset, nil
}

// 根据测点id判断该测点是否在分组中
func (t *MpinfoService) MpidInGroup(mpid int64) (bool, error) {
	db := orm.NewOrm()
	lst := []orm.Params{}
	var sql = "select id from t_data_mp_group where mpid=?"
	_, err := db.Raw(sql, mpid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("****************Error is:%s.", err.Error()))
		return false, err
	}
	if len(lst) == 0 {
		return false, nil
	} else {
		return true, nil
	}
}