package service

import (
	"fmt"
	"github.com/astaxie/beego/orm"
	"rtzh_elec_temperature/logger"
	"rtzh_elec_temperature/rtelec_app_public_lib/models"
	"rtzh_elec_temperature/rtelec_app_public_lib/models/vo"
	"rtzh_elec_temperature/tools"
	"strconv"
)

type AlarmDeviceService struct {
	BaseService
}

// 根据设备id获取设备和设备的测点配置的策略
func (t *AlarmDeviceService) GetDeviceTactics(deviceid int64) ([]orm.Params, error) {
	db := orm.NewOrm()
	deviceList := []orm.Params{}
	qs := db.QueryTable("T_base_device_alarm")
	_, err := qs.Filter("deviceid", deviceid).Values(&deviceList)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
		return nil, err
	}
	var sqlCommandText = "select dev_alarm_id,tactics_id,tactics_name from t_base_device_alarm_tactics where dev_alarm_id=?"
	for _, row := range deviceList {
		tacticsList := []orm.Params{}
		_, err := db.Raw(sqlCommandText, row["Id"]).Values(&tacticsList)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
			return nil, err
		}
		row["tacticsList"] = tacticsList
	}
	return deviceList, nil
}

// 根据设备id删除这个设备的告警配置和下面的明细
func (t *AlarmDeviceService) DelDeviceTactics(deviceid int64) (bool, error) {
	db := orm.NewOrm()
	lst := []orm.Params{}
	// 先查询这个设备下的所有策略id
	qs := db.QueryTable("t_base_device_alarm")
	_, err := qs.Filter("deviceid", deviceid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Query tactics SQL err:%s.", err))
		return false, err
	}
	deviceAlarmId := ""
	params := []interface{}{}
	for i, row := range lst {
		if i == len(lst)-1 {
			deviceAlarmId += "?"
		} else {
			deviceAlarmId += "?,"
		}
		params = append(params, row["Id"])
	}
	var sqlCommandText = "delete from t_base_device_alarm_tactics where dev_alarm_id in (" + deviceAlarmId + ")"
	_, err = db.Raw(sqlCommandText, params).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("delete tactics SQL err:%s.\nParams is :%s", err, params))
		return false, err
	}
	sqlCommandText = "delete from t_base_device_alarm where deviceid=?"
	_, err = db.Raw(sqlCommandText, deviceid).Exec()
	if err == nil {
		return true, nil
	} else {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Delete deviceAlarm err:%s.", err))
		return false, err
	}
	return true, nil
}

// 保存设备id对应的告警配置策略.参数有id的时候为更新，没有id的时候为新增
func (t *AlarmDeviceService) SaveDeviceTactics(tactics *vo.DeviceAlarmTactics) (int64, error) {
	db := orm.NewOrm()

	obj := models.T_base_device_alarm{}
	if tools.IsEmpty(tactics.Id) != "" || tools.IsEmpty(tactics.Id) != "0" {
		obj.Id = tactics.Id
	}
	obj.Deviceid = tactics.Deviceid
	obj.Attrname = tactics.Attrname
	obj.Mpid = tactics.Mpid
	obj.Mpname = tactics.Mpname
	obj.Client_id = tactics.Client_id

	id, err := db.InsertOrUpdate(&obj)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Save device tactics error:%s", err))
		return 0, err
	}
	details := tactics.TacticsList
	err = t.BatchSaveTactics(id, details)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Batch save tactics error:%s", err))
		return 0, err
	}
	return id, nil
}

// 批量保存设备的策略
func (t *AlarmDeviceService) BatchSaveTactics(alarmId int64, tacticsList []map[string]interface{}) error {
	db := orm.NewOrm()
	var sqlCommandText = "delete from t_base_device_alarm_tactics where dev_alarm_id=?"
	_, err := db.Raw(sqlCommandText, alarmId).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Batch delete tactics SQL:%s.\nParam is:%s", sqlCommandText, alarmId))
		return err
	}
	sqlCommandText = "insert into t_base_device_alarm_tactics (dev_alarm_id,tactics_id,tactics_name) values"
	var parms = []interface{}{}
	if len(tacticsList) > 0 {
		for index, row := range tacticsList {
			if index == len(tacticsList)-1 {
				sqlCommandText += "(?,?,?)"
			} else {
				sqlCommandText += "(?,?,?),"
			}
			parms = append(parms, alarmId, row["tactics_id"], row["tactics_name"])
		}
		_, err := db.Raw(sqlCommandText, parms).Exec()
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Batch save tactics SQL:%s.\nParam is:%s", sqlCommandText, parms))
			return err
		}
	}
	return nil
}

// 复制一个设备的策略到另外一个设备
func (t *AlarmDeviceService) CopyDeviceTactics(oldDeviceId int64, otherDeviceId int64) (bool, error) {
	oldlst, err := t.GetDeviceTactics(oldDeviceId)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
		return false, err
	}
	objVO := t.Orm2VO(oldlst)
	for _, row := range objVO {
		row.Deviceid = otherDeviceId
		_, err := t.SaveDeviceTactics(&row)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
			return false, err
		}
	}
	return true, nil
}

// orm.params转化为VO
func (t *AlarmDeviceService) Orm2VO(lst []orm.Params) []vo.DeviceAlarmTactics {
	voList := []vo.DeviceAlarmTactics{}
	for _, row := range lst {
		t := vo.DeviceAlarmTactics{}

		d, _ := strconv.ParseInt(fmt.Sprint(row["Deviceid"]), 10, 64)
		t.Deviceid = d
		c, _ := strconv.ParseInt(fmt.Sprint(row["Client_id"]), 10, 64)
		t.Client_id = c
		m, _ := strconv.ParseInt(fmt.Sprint(row["Mpid"]), 10, 64)
		t.Mpid = m
		t.Mpname = fmt.Sprint(row["Mpname"])
		t.Attrname = fmt.Sprint(row["Attrname"])
		tacticsAttr := row["tacticsList"].([]orm.Params)
		tacticsList := []map[string]interface{}{}
		for _, row := range tacticsAttr {
			obj := map[string]interface{}{}
			obj["dev_alarm_id"] = row["dev_alarm_id"]
			obj["tactics_id"] = row["tactics_id"]
			obj["tactics_name"] = row["tactics_name"]
			tacticsList = append(tacticsList, obj)
		}
		t.TacticsList = tacticsList
		voList = append(voList, t)
	}
	return voList
}

// 单独修改设备告警配置阈值
func (t *AlarmDeviceService) UpdateAloneDeviceTactics() {

}