package front

import (
	"go.mongodb.org/mongo-driver/bson/primitive"
	"log"
	qu "qfw/util"
	"qua"
	"time"
	u "util"
)

func (f *Front) QuaScoreData() {
	defer qu.Catch()
	coll_name := f.GetString("coll_name")
	field_tag := f.GetSlice("field_tag")
	rep := QuaFieldScore(field_tag, coll_name)
	f.ServeJson(map[string]interface{}{
		"rep": rep,
	})
}
func QuaFieldScore(field_tag []string, coll_name string) bool {
	if coll_name == "" || len(field_tag) <= 0 {
		return false
	}
	//查询标注表-临时测试-指定表
	start := int(time.Now().Unix())
	q := map[string]interface{}{}
	sess := u.Mgo.GetMgoConn()
	defer u.Mgo.DestoryMongoConn(sess)
	it := sess.DB(u.Mgo.DbName).C(coll_name).Find(&q).Sort("_id").Iter()
	updateFieldScore, total := [][]map[string]interface{}{}, 0
	for tmp := make(map[string]interface{}); it.Next(&tmp); total++ {
		if total%1000 == 0 {
			log.Println("当前数量:", total)
		}
		update_dict := calculateFieldScore(tmp, field_tag)
		updateFieldScore = append(updateFieldScore, []map[string]interface{}{
			map[string]interface{}{"_id": tmp["_id"]},
			update_dict,
		})
		if len(updateFieldScore) >= 200 {
			u.Mgo.UpSertBulk(coll_name, updateFieldScore...)
			updateFieldScore = [][]map[string]interface{}{}
		}
		tmp = make(map[string]interface{})
	}
	if len(updateFieldScore) > 0 {
		u.Mgo.UpSertBulk(coll_name, updateFieldScore...)
	}
	log.Printf("处理耗时：%d秒~数量：%d个\n", int(time.Now().Unix())-start, total)

	if total <= 0 {
		return false
	}
	return true
}

//计算字段分
func calculateFieldScore(tmp map[string]interface{}, field_tag []string) map[string]interface{} {
	source := *qu.ObjToMap(tmp["field_source"])
	f_s := qua.FieldSourceScore(source) //打初始分
	update_dict := make(map[string]interface{}, 0)
	buyer_s := qua.BuyerFieldScore(tmp, f_s["buyer"])
	budget_s := qua.BudgetFieldScore(tmp, f_s["budget"])
	projectname_s := qua.ProjectnameFieldScore(tmp, f_s["projectname"])
	projectcode_s := qua.ProjectcodeFieldScore(tmp, f_s["projectcode"])

	update_dict["buyer"] = buyer_s
	update_dict["budget"] = budget_s
	update_dict["projectname"] = projectname_s
	update_dict["projectcode"] = projectcode_s

	subtype := qu.ObjToString(tmp["subtype"])
	if subtype == "中标" || subtype == "成交" || subtype == "合同" {
		s_winner_s := qua.WinnerFieldScore(tmp, f_s["s_winner"])
		update_dict["s_winner"] = s_winner_s
		bidamount_s := qua.BidamountFieldScore(tmp, f_s["bidamount"])
		update_dict["bidamount"] = bidamount_s
	}

	//综合比对是否正确 field_tag   - 指定字段
	isUse := true
	b_isfield_tag := make(map[string]interface{}, 0)
	for _, key := range field_tag {
		value := *qu.ObjToMap(update_dict[key])
		score := qu.Int64All(value["score"])
		if score < 99 {
			isUse = false //需要标注
		}
	}

	for k, v := range update_dict {
		data := *qu.ObjToMap(v)
		score := qu.Int64All(data["score"])
		if score < 99 {
			b_isfield_tag[k] = true
		} else {
			b_isfield_tag[k] = false
		}
	}
	b_istagging := !isUse

	ckdata := 0
	if isUse { //达标数据ck_data默认未2，未达标为0
		ckdata = 2
	}
	//计算标的物-有效状态
	b_isprchasing := calculatePrchasinglist(tmp)

	return map[string]interface{}{
		"$set": map[string]interface{}{
			"v_fieldscore":  update_dict,
			"b_isfield_tag": b_isfield_tag,
			"b_istagging":   b_istagging,
			"b_isprchasing": b_isprchasing,
			"i_ckdata":      ckdata,
		},
	}
}

//标的物-计算
func calculatePrchasinglist(tmp map[string]interface{}) bool {
	b_ispurchasing := true //默认需要标注
	if purchasinglist, ok := tmp["purchasinglist"].([]interface{}); ok {
		if len(purchasinglist) <= 0 {
			return b_ispurchasing
		}
		isListUserArr := []bool{}
		for _, data := range purchasinglist {
			isUse := isUsePurchasing(*qu.ObjToMap(data))
			isListUserArr = append(isListUserArr, isUse)
		}
		b_ispurchasing = !isUseAllPurchasing(isListUserArr)
		return b_ispurchasing
	}

	if purchasinglistA, okA := tmp["purchasinglist"].(primitive.A); okA {
		if len(purchasinglistA) <= 0 {
			return b_ispurchasing
		}
		isListUserArr := []bool{}
		for _, data := range purchasinglistA {
			isUse := isUsePurchasing(*qu.ObjToMap(data))
			isListUserArr = append(isListUserArr, isUse)
		}
		b_ispurchasing = !isUseAllPurchasing(isListUserArr)
	}
	return b_ispurchasing
}

//判断各个标的物是否可用  默认不可用
func isUsePurchasing(data map[string]interface{}) bool {
	isUse := false
	num := 1
	total_score := qu.Float64All(data["score"])
	if total_score <= float64(0) {
		return isUse
	}
	ner_data := *qu.ObjToMap(data["ner_data"])
	NerGoods := *qu.ObjToMap(ner_data["NerGoods"])
	for _, v := range NerGoods {
		num++
		total_score += qu.Float64All(v)
	}
	//计算总平均分输
	if total_score/float64(num) > float64(0.3) {
		isUse = true
	}
	return isUse
}

//是否整体可用 - 默认不可用
func isUseAllPurchasing(isListUserArr []bool) bool {
	isUse := false
	total_num := len(isListUserArr)
	ok_num := 0
	for _, v := range isListUserArr {
		if v {
			ok_num++
		}
	}
	if ok_num == 0 {
		return isUse
	}
	correct := float64(ok_num) / float64(total_num)
	if total_num <= 2 {
		if correct >= float64(1) {
			isUse = true
		}
	} else if total_num > 2 && total_num <= 6 {
		if correct >= float64(0.6) {
			isUse = true
		}
	} else if total_num > 7 {
		if correct >= float64(0.5) {
			isUse = true
		}
	} else {

	}
	return isUse
}
