package labelFilter

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

func Judge(result ruleserver.ResultMsg){
	// 装配成自己可以识别的数据
	label := new(Label)
	label.DataFormatToLabel(result)
	//拿到所有规则组
	var api dbapi.EventPushApi
	b,allRules := api.FindAllDetails()
	if !b {
		logger.Error("查询时间推送规则失败！")
	}
	//遍历所有的规则组，看看符合哪个规则组，就把数据插入到哪个规则组的目标机器上
	for _,ruleGroup := range allRules {
		if ruleGroup.Enable {  // 大规则开关开启状态
			// 先过时间规则
			timeJudge(label,ruleGroup)
			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 == "baseLibrary" {
					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 == "defence" {
					result = Connector + defenceJudge(label,rule)
				}
			}
			// 得出总的判断结果
			if result != "" {
				result = result[2:] // 把前两位字符去掉
				expression, err:= govaluate.NewEvaluableExpression(result);
				if err != nil {
					logger.Error("表达式有误，请检查！")
				}
				result, err1:= expression.Evaluate(nil)
				if err1 != nil {
					logger.Error("带入参数有误")
				}
				logger.Warn("规则判断结果是：",)
				if result.(bool) {
					logger.Info("通过规则，表达式为：",result)
					// 推送服务器
					pushData(ruleGroup.Urls,result.(ruleserver.ResultMsg))
					os.Exit(1)
				} else {
					logger.Info("没通过规则,表达式为：",result)
					os.Exit(1)
				}
			}
		}
	}

	//符合本规则组的就把数据推送到该目的服务器上
}
// 是否符合时间规则
func timeJudge(label *Label,groupRule protomsg.EventPush) string{
	timeNow := time.Now().Format("2006-01-02 15:04:05")
	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("表达式有误，请检查！")
	}
	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{
	if rule.TopicArg == "cameraName" {
		if label.CameraName == rule.RuleValue {
			logger.Info("符合摄像机名称规则")
			return "true"
		} else {
			logger.Info("不符合摄像机名称规则")
			return "false"
		}
	}
	if rule.TopicArg == "cameraLocation" {
		if label.CameraAddr == rule.RuleValue {
			logger.Info("符合摄像机位置规则")
			return "true"
		} else {
			logger.Info("不符合摄像机位置规则")
			return "false"
		}
	}
	return ""
}

// 是否符合底库规则
func baseJudge(label *Label,rule *protomsg.EventPushRule) string{
	flag := "false"
	for _,personGroup := range label.Persons  {
		for _,arg := range personGroup.Args {
			for _,liker := range arg.Liker{
				if liker.TableId == rule.RuleValue {
					logger.Info("符合底库规则！")
					flag = "true"
				}
			}
		}
	}
	return flag
}

//是否符合人员规则
func personJudge(label *Label,rule *protomsg.EventPushRule) string{
	for _,personGroup := range label.Persons  {
		for _,person := range personGroup.Args {
			if rule.TopicArg == "sex" && strconv.Itoa(int(person.ThftRes.Gender)) == rule.RuleValue{
				logger.Info("符合人员性别规则！")
				return  "true"
			}
			if rule.TopicArg == "race" && strconv.Itoa(int(person.ThftRes.Race)) == rule.RuleValue {
				logger.Info("符合人员种族规则！")
				return "true"
			}
			if rule.TopicArg == "age" && strconv.Itoa(int(person.ThftRes.Age)) == rule.RuleValue {
				logger.Info("符合人员年龄规则！")
				return "true"
			}
			if rule.TopicArg == "others" {
				// 其他这个值先这么处理
				return "true"
			}
		}
		if strconv.Itoa(int(personGroup.AlarmLevel)) == rule.RuleValue {
			logger.Info("符合人员报警等级规则！")
			return "true"
		}
	}
	logger.Info("不符合人员规则")
	return "false"
}

// 是否符合布防等级规则
func defenceJudge(label *Label,rule *protomsg.EventPushRule) string{
	for _,def := range label.DefenceLevel {
		if strconv.Itoa(int(def)) == rule.RuleValue {
			logger.Info("符合布防等级规则！")
			return "true"
		}
	}
	logger.Info("不符合布防等级规则")
	return "false"
}
// 是否符合任务规则
func taskJudge(label *Label,rule *protomsg.EventPushRule) string{
	if label.TaskId == rule.RuleValue {
		logger.Info("符合任务规则!")
		return "true"
	}
	logger.Info("不符合任务规则")
	return "false"
}
// 调用目标服务器的插入接口
func pushData (urls []*protomsg.PushUrl, data ruleserver.ResultMsg){
	for _,url := range urls {
		Push(url.Url,data)
	}
}