package labelFilter

import (
	"basic.com/dbapi.git"
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/logger.git"
	"github.com/knetic/govaluate"
	"ruleprocess/structure"
	"strconv"
	"time"
)

func PushSomthing(msg structure.ResultMsg) {
	defer func() {
		if err := recover(); err != nil {
			logger.Error("事件推送模块儿的异常捕获：",err)
		}
	}()

	// 装配成自己可以识别的数据
	label := new(Label)
	label.DataFormatToLabel(msg)
	logger.Info("label的信息：", label.CameraName, label.DefenceLevel, label.Time)
	if label.CameraName == "" {
		logger.Error("无效数据，直接返回")
		return
	}
	//拿到所有规则组
	var api dbapi.EventPushApi
	b, allRules := api.FindAllDetails()
	logger.Info("查看所有规则组：", allRules)
	if !b {
		logger.Error("查询时间推送规则失败！")
	}
	//遍历所有的规则组，看看符合哪个规则组，就把数据插入到哪个规则组的目标机器上
	for _, ruleGroup := range allRules {
		if ruleGroup.Enable { // 大规则开关开启状态
			// 先过时间规则
			timeFlag := timeJudge(label, ruleGroup)
			if !timeFlag {
				logger.Info("不在规则的时间范围内，不推送！")
				continue
			}
			result := ""
			var Connector string
			if ruleGroup.IsSatisfyAll {
				Connector = "&&"
			} else {
				Connector = "||"
			}
			for _, rule := range ruleGroup.Rules {
				// 过每一个小规则
				if rule.TopicType == "camera" {
					result += Connector + cameraJudge(label, rule)
				}
				if rule.TopicType == "dbtable" {
					result += Connector + baseJudge(label, rule)
				}
				if rule.TopicType == "task" {
					result += Connector + taskJudge(label, rule)
				}
				if rule.TopicType == "person" {
					result += Connector + taskJudge(label, rule)
				}
				if rule.TopicType == "alarmLevel" {
					result += Connector + defenceJudge(label, rule)
				}
			}
			// 得出总的判断结果
			if result != "" {
				logger.Info("总的判断结果：", result)
				result = result[2:] // 把前两位字符去掉
				expression, err := govaluate.NewEvaluableExpression(result);
				if err != nil {
					logger.Error("表达式有误，请检查！")
					return
				}
				result, err1 := expression.Evaluate(nil)
				if err1 != nil {
					logger.Error("带入参数有误")
				}
				if result.(bool) {
					logger.Info("通过规则，表达式为：", result)
					// 推送服务器
					pushData(ruleGroup.Urls, msg)
					//os.Exit(1)
				} else {
					logger.Info("没通过规则,表达式为：", result)
					//os.Exit(1)
				}
			}
		}
	}

	//符合本规则组的就把数据推送到该目的服务器上
}

// 是否符合时间规则
func timeJudge(label *Label, groupRule protomsg.EventPush) bool {
	timeNow := time.Now().Format("2006-01-02 15:04:05")
	logger.Info("标签过滤器起始时间为：",groupRule.TimeStart,groupRule.TimeEnd)
	flag1 := isBefore(groupRule.TimeStart, timeNow)
	flag2 := isBefore(timeNow, groupRule.TimeEnd)
	if flag1 && flag2 {
		return true
	} else {
		logger.Info("不在规定的时间范围内！")
		return false
	}
}

// 传入两个时间的字符串，判断第一个时间是否小于第二个时间
func isBefore(time1 string, time2 string) bool {
	expression, err := govaluate.NewEvaluableExpression("t1 < t2");
	if err != nil {
		logger.Error("表达式有误，请检查！")
		return false
	}
	parameters := make(map[string]interface{}, 8)
	parameters["t1"] = time1
	parameters["t2"] = time2
	result, err1 := expression.Evaluate(parameters)
	if err1 != nil {
		logger.Error("带入参数有误")
	}
	return result.(bool)
}

// 是否符合摄像机规则
func cameraJudge(label *Label, rule *protomsg.EventPushRule) string {
	formula := ""
	if rule.TopicArg == "name" {
		formula = "'" + label.CameraName + "'" + rule.Operator + "'" + rule.RuleValue + "'"
	}
	if rule.TopicArg == "addr" {
		formula = "'" + label.CameraAddr + "'" + rule.Operator + "'" + rule.RuleValue + "'"
	}
	logger.Info("-------打印摄像机规则公式：",formula)
	expression, err := govaluate.NewEvaluableExpression(formula);
	if err != nil {
		logger.Error("表达式有误，请检查！", formula)
		return "false"
	}
	result, err1 := expression.Evaluate(nil)
	if err1 != nil {
		logger.Error("带入参数有误")
		return "false"
	}
	if result.(bool) {
		logger.Info("符合摄像机规则!")
		return "true"
	}
	logger.Info("不符合摄像机规则!")
	return "false"
}

// 是否符合底库规则
func baseJudge(label *Label, rule *protomsg.EventPushRule) string {
	if rule.RuleValue == "all" {
		for _, personGroup := range label.Persons {
			for _, arg := range personGroup.Args {
				if len(arg.Liker) > 0 {
					logger.Info("满足全部底库规则")
					return "true"
				}
			}
		}
		return "false"
	} else {
		for _, personGroup := range label.Persons {
			for _, arg := range personGroup.Args {
				for _, liker := range arg.Liker {
					formula := "'" + liker.TableId + "'" + rule.Operator + "'" + rule.RuleValue + "'"
					expression, err := govaluate.NewEvaluableExpression(formula);
					logger.Info("-------打印底库规则公式：",formula)
					if err != nil {
						logger.Error("表达式有误，请检查！", formula)
						return "false"
					}
					result, err1 := expression.Evaluate(nil)
					if err1 != nil {
						logger.Error("带入参数有误")
						//return "false"
					}
					if result.(bool) {
						logger.Info("符合底库规则!")
						return "true"
					}
				}
			}
		}
		logger.Info("不符合底库规则!")
		return "false"
	}
}

//是否符合人员规则
func personJudge(label *Label, rule *protomsg.EventPushRule) string {
	for _, personGroup := range label.Persons {
		for _, person := range personGroup.Args {
			formula := ""
			if rule.TopicArg == "sex" {
				formula = strconv.Itoa(int(person.ThftRes.Gender)) + rule.Operator + rule.RuleValue
			}
			if rule.TopicArg == "race" {
				formula = strconv.Itoa(int(person.ThftRes.Race)) + rule.Operator + rule.RuleValue
			}
			if rule.TopicArg == "age" {
				formula = strconv.Itoa(int(person.ThftRes.Age)) + rule.Operator + rule.RuleValue
			}
			if rule.TopicArg == "otherInfo" {
				// 其他这个值先这么处理
				return "true"
			}
			logger.Info("-------打印人员规则公式：",formula)
			expression, err := govaluate.NewEvaluableExpression(formula);
			if err != nil {
				logger.Error("表达式有误，请检查！", formula)
				return "false"
			}
			result, err1 := expression.Evaluate(nil)
			if err1 != nil {
				logger.Error("带入参数有误")
				//return "false"
			}
			if result.(bool) {
				logger.Info("符合人员规则！", formula)
				return "true"
			}
		}
		if rule.TopicArg == "monitorLevel" {
			if rule.RuleValue == "all" {
				if len(personGroup.Args) > 0 {
					logger.Info("符合人员等级为全部的规则")
					return "true"
				}
			} else {
				formula := strconv.Itoa(int(personGroup.AlarmLevel)) + rule.Operator + formate(rule.RuleValue)
				logger.Info("-------打印人员等级规则公式：",formula)
				expression, err := govaluate.NewEvaluableExpression(formula);
				if err != nil {
					logger.Error("表达式有误，请检查！", formula)
					return "false"
				}
				result, err1 := expression.Evaluate(nil)
				if err1 != nil {
					logger.Error("带入参数有误")
					//return "false"
				}
				if result.(bool) {
					logger.Info("符合人员等级规则!")
					return "true"
				}
			}
			logger.Info("符合人员报警等级规则！")
			return "true"
		}
	}
	logger.Info("不符合人员规则")
	return "false"
}

// 是否符合布防等级规则
func defenceJudge(label *Label, rule *protomsg.EventPushRule) string {
	if rule.RuleValue == "all" { // 布防等级为全部时只有有布防等级即为通过
		if len(label.DefenceLevel) > 0 {
			logger.Info("符合布防等级规则，布防等级为全部")
			return "true"
		} else {
			logger.Info("不符合布防等级规则")
			return "false"
		}
	} else {
		for _, def := range label.DefenceLevel {
			formula := strconv.Itoa(int(def)) + rule.Operator + rule.RuleValue
			logger.Info("-------打印布防等级规则公式：",formula)
			expression, err := govaluate.NewEvaluableExpression(formula);
			if err != nil {
				logger.Error("表达式有误，请检查！", formula)
				return "false"
			}
			result, err1 := expression.Evaluate(nil)
			if err1 != nil {
				logger.Error("带入参数有误")
				//return "false"
			}
			if result.(bool) {
				logger.Info("符合布防等级规则!")
				return "true"
			}
		}
		logger.Info("不符合布防等级规则")
		return "false"
	}
}

// 是否符合任务规则
func taskJudge(label *Label, rule *protomsg.EventPushRule) string {
	formula := "'"+label.TaskId +"'"+ rule.Operator +"'"+ rule.RuleValue+"'"
	expression, err := govaluate.NewEvaluableExpression(formula);
	logger.Info("-------打印任务规则公式：",formula)
	if err != nil {
		logger.Error("表达式有误，请检查！", formula)
		return "false"
	}
	result, err1 := expression.Evaluate(nil)
	if err1 != nil {
		logger.Error("带入参数有误")
		return "false"
	}
	if result.(bool) {
		logger.Info("符合任务规则!")
		return "true"
	}
	logger.Info("不符合任务规则")
	return "false"
}

// 调用目标服务器的插入接口
func pushData(urls []*protomsg.PushUrl, data structure.ResultMsg) {
	for _, url := range urls {
		logger.Debug("看看推送地址：",url.Url)
		urlPool[url.Url] <- data
	}
}

// 把报警等级转化成汉字
func formate(str string) string {
	var i string
	if str == "一级" {
		i = "1"
	}
	if str == "二级" {
		i = "2"
	}
	if str == "三级" {
		i = "3"
	}
	if str == "四级" {
		i = "4"
	}
	if str == "五级" {
		i = "5"
	}
	return i
}