package rule

import (
	"basic.com/valib/logger.git"
	"fmt"
	"ruleModelEngine/cache"
	"ruleModelEngine/config"
	"ruleModelEngine/data"
	"ruleModelEngine/db"
	"ruleModelEngine/task"
	"strconv"
)

//
//// 检查规则表书否存在异常
//func checkRuleValidity(rules []db.PersonnelStatusRule) bool {
//	for i := 0; i < len(rules); i++ {
//		for j := i + 1; j < len(rules); j++ {
//			ruleI := rules[i]
//			ruleJ := rules[j]
//			//fmt.Println(ruleI.DetectionDaysStart,ruleI.DetectionDaysEnd)
//			//fmt.Println(ruleJ.DetectionDaysStart,ruleJ.DetectionDaysEnd)
//			if (ruleI.DetectionDaysStart <= ruleJ.DetectionDaysEnd && ruleI.DetectionDaysStart >= ruleJ.DetectionDaysStart) ||
//				(ruleI.DetectionDaysEnd <= ruleJ.DetectionDaysEnd && ruleI.DetectionDaysEnd >= ruleJ.DetectionDaysStart) ||
//				(ruleI.DetectionDaysStart <= ruleJ.DetectionDaysStart && ruleI.DetectionDaysEnd >= ruleJ.DetectionDaysEnd) {
//				return false
//			}
//		}
//	}
//	return true
//}

func executeEnteringButNotLeaving(communityId string) {
	//进出异常布控任务，暂时归类到标签计算部分
	//fmt.Println("进出异常开始入口！！！！！！")
	tasks, err := db.GetAllTaskData()
	if err != nil {
		logger.Error("GetAllTaskData Error", err)
	}
	var tkInfo db.Task
	for _, taskInfo := range tasks {
		if taskInfo.Name == "进出异常" {
			tkInfo.Id = taskInfo.Id
			tkInfo.Name = taskInfo.Name
		}
	}

	//fmt.Println("tkInfo: ", tkInfo)
	//fmt.Println("docNumIdMap: ", len(docNumIdMap))
	//获取商住楼cameraid

	cameraIds := make([]string, 0)
	for _, deviceInfo := range cache.Device {
		if deviceInfo.AreaID == communityId && deviceInfo.BuildingType == db.BuildingTypeMixedUse {
			cameraIds = append(cameraIds, deviceInfo.DeviceCode)
		}
	}
	if len(cameraIds) == 0 {
		logger.Info("不存在商住楼设备：", cameraIds)
		return
	}
	//查询待判断进出异常预警档案
	days := config.Api.AInterval
	docNumIdMap, err := db.QueryLastIdByDayRange(communityId, cameraIds, days, days-1)
	if err != nil {
		logger.Error("QueryByDayRange err: ", err)
	}
	for docNumber, id := range docNumIdMap {
		//fmt.Println(docNumber, id)
		alarmRules := make([]db.AlarmRule, 0)
		flag := task.EnteringButNotLeaving(docNumber, communityId, cameraIds, days)
		if flag == true {
			alarmRules = append(alarmRules, db.AlarmRule{RuleId: strconv.Itoa(tkInfo.Id), RuleText: tkInfo.Name, AlarmLevel: "0"})
		}
		//fmt.Println("alarmRules: ", id, alarmRules)
		addFlag, err := db.AddAlarmRules(alarmRules, id)
		if err != nil {
			logger.Error("AddAlarmRules err: ", err)
		}
		if addFlag == true {
			logger.Info("AddAlarmRules success: ", id)
		}
	}
}

// 执行程序入口
func ExecuteTask() {
	//return
	ruleInfo, err := db.GetAllData()
	if err != nil {
		logger.Error("GetAllData Error", err)
	}
	fmt.Println("ruleInfo: ", ruleInfo)
	communityIDs, err := db.GetCommunityIDs()
	//fmt.Println("communityIDs:", communityIDs)
	if err != nil {
		logger.Error("GetCommunityIDs Error", err)
	}
	labeManage, err := db.GetLabelManageIdentity(2)
	if err != nil {
		logger.Error("GetDBPersonStatusData Error", err)
	}
	//fmt.Println(labeManage)
	for _, communityID := range communityIDs {
		executeEnteringButNotLeaving(communityID)
		//万全社区
		//if communityID != "50010101010000001001" {
		//	continue
		//}
		fmt.Println("communityID: ", communityID)
		//continue
		//查询社区内人员档案，方便数据更新
		personStatusList, err := db.QueryPersonStatusWithPagination(communityID, 30)
		if err != nil {
			logger.Error("QueryPersonStatusWithPagination err: ", err)
		}
		//

		documentNumberIDS := make([]string, 0)
		for _, personStatus := range personStatusList {
			//fmt.Println("personStatus.LastAppearanceTime: ", personStatus.LastAppearanceTime)
			documentNumberIDS = append(documentNumberIDS, personStatus.DocumentNumber)
			//业务逻辑
		}
		//fmt.Println("len(documentNumberIDS)", len(documentNumberIDS))
		captureInfos := make([]db.CaptureInfo, 0)
		batchSize := config.Elastic.BatchSize
		//fmt.Println(batchSize)
		for i := 0; i < len(documentNumberIDS); i += batchSize {
			end := i + batchSize
			if end > len(documentNumberIDS) {
				end = len(documentNumberIDS)
			}
			batch := documentNumberIDS[i:end]
			//fmt.Println("batch: ", batch)
			batchCaptureInfos, err := db.Query1MDataByCommunityId(communityID, batch, 30)
			if err != nil {
				logger.Error("Query1MDataByCommunityId Error", err)
			}
			if len(batchCaptureInfos) == 0 {
				continue
			}
			//fmt.Println("batchCaptureInfos: ", batchCaptureInfos)
			captureInfos = append(captureInfos, batchCaptureInfos...)
		}
		if len(captureInfos) == 0 {
			continue
		}
		fmt.Println("共计有档案数据条数为：", len(captureInfos))
		//补全分析所需数据
		for i := range captureInfos {

			captureDays, overnightCount := data.CalculateCaptureDays(captureInfos[i].CaptureDetail)
			captureInfos[i].CaptureDays = captureDays
			captureInfos[i].OvernightStays = overnightCount

			captureInfos[i].Status = data.SetStatus(captureDays, ruleInfo)
			if captureInfos[i].OvernightStays >= 5 && (captureInfos[i].CaptureDays <= 14 && captureInfos[i].CaptureDays >= 5) {
				captureInfos[i].Status = "resident"
			}
			//fmt.Println("SetStatus: ", captureInfos[i].Status)
			age, err := db.QueryAgeById(captureInfos[i].DocumentNumber)
			if err != nil {
				logger.Error("QueryAgeById ERROR", err)
			}
			captureInfos[i].Age = age
			captureInfos[i].FrequentAddress = data.GetFrequentAddress(captureInfos[i].CaptureDetail)
			//fmt.Println("CaptureDetail: ", captureInfos[i].DocumentNumber, captureInfos[i].CaptureDays, captureInfos[i].CaptureDetail)
		}
		//fmt.Println("residentCount: ", residentCount)
		//fmt.Println("captureInfosQ: ", captureInfos)

		for _, identity := range labeManage {
			switch identity.Name {
			case "服务人员":
				identity, attribute := CreateLinearModel(captureInfos, communityID, 2.68, identity.ValidDays, identity.Id)
				errIdentity := db.UpdateDBPersonLabel(identity)
				if errIdentity != nil {
					logger.Error("UpdateDBPersonLabel Error", errIdentity)
				}
				captureInfos = attribute

			}
		}
		identity := CreateProcessModel(captureInfos, 30, communityID, labeManage)
		errIdentity := db.UpdateDBPersonLabel(identity)
		if errIdentity != nil {
			logger.Error("UpdateDBPersonLabel Error", errIdentity)
		}
		//continue

		postCaptureInfos := data.ProcessData(captureInfos, personStatusList, ruleInfo, communityID)
		/*for _, inf := range postCaptureInfos {
			fmt.Println("inf: ", inf.DocumentNumber, inf.Status, inf.FrequentAddress, inf.LastAppearanceStatusTime)
		}*/
		//fmt.Println("共更新档案数：", len(postCaptureInfos))
		//fmt.Println("----->captureInfos: ", len(captureInfos))
		//continue
		UpdatePersonInfoErr := db.UpdatePersonInfo(postCaptureInfos, communityID)
		if UpdatePersonInfoErr != nil {
			logger.Error("MatchPermanentResidentTargets Error: ", UpdatePersonInfoErr)
		}

		resident, DocNumberErr := db.GetResidentData("resident", communityID)
		//fmt.Println(resident)
		//return
		if DocNumberErr != nil {
			logger.Error("GetDocNumberFromPersonStatus Error: ", DocNumberErr)
		}

		//fmt.Println(resident)
		//fmt.Println("resident: ", resident)
		mio := processResidentStatus(resident)
		//fmt.Println("mip: ", mio)
		UpdateMoveInoutErr := db.UpdateMoveInout(mio)
		if UpdateMoveInoutErr != nil {
			logger.Error("UpdateMoveInoutErr Error: ", UpdateMoveInoutErr)
		}
	}
}