package main

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

// 车牌算法

func Entrance(rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others,args *structure.SdkDatas,message *protomsg.SdkMessage) structure.LittleRuleResult {
	if rule.PolygonId == am.AreaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
		if rule.SdkArgAlias != "nCarCount" && rule.SdkArgAlias != "nCarLogoCount" {
			logger.Info("过滤车牌信息")
			return filterRule(rule, am)
		} else {
			logger.Info("计算车牌车辆数量") // 目前只能检测出车牌数量
			return transferParameters(rule, am)
		}
	} else {
		return structure.LittleRuleResult{}
	}
}



// 过滤规则先筛选出符合条件的目标数量
func filterRule(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
	// 处理的都是yolo数据
	carFlag := rule.SdkArgAlias == "license" ||  rule.SdkArgAlias == "nColor" || rule.SdkArgAlias == "nConfidence" ||
		rule.SdkArgAlias == "nBright" || rule.SdkArgAlias == "nTime" ||  rule.SdkArgAlias == "nCarBright" || rule.SdkArgAlias == "nCarColor" ||
		rule.SdkArgAlias == "nCarLogo" || rule.SdkArgAlias == "nCarType" ||  rule.SdkArgAlias == "nCarModel" || rule.SdkArgAlias == "nCarModelConfidence"

	if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" || carFlag{ // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
		logger.Debug("---------走了车牌识别过滤算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
		var args []*structure.Arg
		if rule.RuleWithPre == "&&" {
			args = am.FilterData
		} else {
			args = am.Args
		}
		// 先清空过滤后的数据，再往里塞本次过滤后的数据
		am.FilterData = am.FilterData[0:0]
		//logger.Debug("看看args：：：：：", args)
		for _, arg := range args {
			var formula string
			switch rule.SdkArgAlias {
				case "score":
					formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("相似度小公式：", formula)
				case "proportion":
					formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("占比公式：", formula)
				case "size":
					formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("尺寸小公式：", formula)
				case "license":
					formula = arg.Car.License + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("当前车牌号码小公式：", formula)
				case "nColor":
					formula = strconv.Itoa(int(arg.Car.NColor)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车牌颜色小公式：", formula)
				case "nConfidence":
					formula = strconv.Itoa(int(arg.Car.NConfidence)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("整牌可信度小公式：", formula)
				case "nBright":
					formula = strconv.Itoa(int(arg.Car.NBright)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车牌亮度评价小公式：", formula)
				case "nDirection":
					formula = strconv.Itoa(int(arg.Car.NDirection)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车牌运动方向小公式：", formula)
				case "nCarBright":
					formula = strconv.Itoa(int(arg.Car.NCarBright)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车的亮度小公式：", formula)
				case "nCarColor":
					formula = strconv.Itoa(int(arg.Car.NCarColor)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车的颜色小公式：", formula)
				case "nCarLogo":
					formula = strconv.Itoa(int(arg.Car.NCarLogo)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车标类型小公式：", formula)
				case "nCarType":
					formula = strconv.Itoa(int(arg.Car.NCarType)) + " " + rule.Operator + " " + rule.SdkArgValue
					logger.Info("车辆类型小公式：", formula)
				//case "nCarModel":
				//	formula = strconv.Itoa(int(arg.Car.ncm)) + " " + rule.Operator + " " + rule.SdkArgValue
				//	logger.Info("识别成功与否小公式：", formula)
				//case "nCarModelConfidence":
				//	formula = strconv.Itoa(int(arg.Car.NCarModelConfidence)) + " " + rule.Operator + " " + rule.SdkArgValue
				//	logger.Info("车型可信度小公式：", formula)
			}
			expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
			result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
			if result.(bool) {
				am.FilterData = append(am.FilterData, arg) // 得到符合条件的过滤数据
			}
		}
		am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
		if am.TargetNum > 0 {
			return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
		} else {
			return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
		}

	} else if rule.SdkArgAlias == "" {
		if am.TargetNum > 0 {
			return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
		} else {
			return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
		}
	}
	return structure.LittleRuleResult{}
}


// 给数据库的规则表达式代参 args: 一条子规则，区域数据
func transferParameters(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
	//logger.Info("当前小规则是：---------", rule)
	//logger.Info("得出结果阶段", "比较的规则是：", rule)
	if rule.Operator == "" {
		return structure.LittleRuleResult{am.SdkName, strconv.Itoa(am.TargetNum) + "" + rule.RuleWithPre, rule.Sort} // 如果后面不跟操作符就直接返回数量  比如要跟下一个区域比较数量的就直接返回本区域的数量
	}
	//args := am.targetNum     targetNum 已成所有目标的总数量，这里只算yolo的
	var num int = len(am.FilterData)
	formula := strconv.Itoa(num) + " " + rule.Operator + " " + rule.SdkArgValue
	logger.Info("车牌数量公式",formula)
	expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
	result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
	return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + " " + strconv.FormatBool(result.(bool)), rule.Sort}
	// 加上关于算法的判断条件，不能只有关于规则的，有的算法本身就是一个规则，如个体静止，靠右行,所以，拿到当前子规则的sdkid来判断是否是那些特殊的规则
}