package esutil

import (
	"basic.com/pubsub/protomsg.git"
	"bytes"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/spf13/viper"
	"io/ioutil"
	"log"
	"math"
	"net/http"
	"time"
)

func Parsesources(sources []map[string]interface{}) (multiInfos []*protomsg.MultiFeaCache) {
	var ok bool
	for _, source := range sources {
		var multiInfo protomsg.MultiFeaCache
		var tmpinfo protomsg.Esinfo
		tmpinfo.Id, ok = source["id"].(string)
		if !ok {
			continue
		}
		if source["targetInfo"] != nil {
			for _, v := range source["targetInfo"].([]interface{}) {
				m := v.(map[string]interface{})
				tmpinfo.FaceFeature, ok = m["feature"].(string)
				if !ok {
					continue
				}
				if m["attachTarget"] != nil {
					multiInfo.AttachFeature, ok = m["attachTarget"].(map[string]interface{})["feature"].(string)
				}
				if m["targetLocation"] != nil {
					targetLocation := m["targetLocation"].(map[string]interface{})
					topLeft := targetLocation["topLeft"].(map[string]interface{})
					tx := topLeft["x"].(float64)
					ty := topLeft["y"].(float64)
					bottomRight := targetLocation["bottomRight"].(map[string]interface{})
					bx := bottomRight["x"].(float64)
					by := bottomRight["y"].(float64)
					multiInfo.TargetLocation = &protomsg.TargetLocation{
						TopLeft: &protomsg.Location{
							X: tx,
							Y: ty,
						},
						BottomRight: &protomsg.Location{
							X: bx,
							Y: by,
						},
					}
				}
			}
		}
		tmpinfo.AnalyServerId, ok = source["analyServerId"].(string)
		if !ok {
			continue
		}
		multiInfo.EsInfo = &tmpinfo
		multiInfo.CameraId, ok = source["cameraId"].(string)
		//fmt.Println(source["cameraId"])
		leis := make([]*protomsg.LinkEsInfo, 0)
		if source["linkTagInfo"] != nil {
			for _, v := range source["linkTagInfo"].([]interface{}) {
				var lei protomsg.LinkEsInfo
				mi := v.(map[string]interface{})
				lei.CameraId, ok = mi["cameraId"].(string)
				if mi["targetInfo"] != nil {
					for _, val := range mi["targetInfo"].([]interface{}) {
						fmi := val.(map[string]interface{})
						lei.Feature, ok = fmi["feature"].(string)
						if fmi["targetLocation"] != nil {
							targetLocation := fmi["targetLocation"].(map[string]interface{})
							topLeft := targetLocation["topLeft"].(map[string]interface{})
							tx := topLeft["x"].(float64)
							ty := topLeft["y"].(float64)
							bottomRight := targetLocation["bottomRight"].(map[string]interface{})
							bx := bottomRight["x"].(float64)
							by := bottomRight["y"].(float64)
							multiInfo.TargetLocation = &protomsg.TargetLocation{
								TopLeft: &protomsg.Location{
									X: tx,
									Y: ty,
								},
								BottomRight: &protomsg.Location{
									X: bx,
									Y: by,
								},
							}
						}
						lei.AttachFeature, ok = fmi["attachTarget"].(map[string]interface{})["feature"].(string)
					}
				}
				leis = append(leis, &lei)
			}
		}
		multiInfo.LinkEsInfo = leis
		multiInfos = append(multiInfos, &multiInfo)
	}
	return
}

// 解析抓拍库人员结构
func AIOceanAnalysis(sources []map[string]interface{}) (tmpinfos []protomsg.AIOcean) {
	var ok bool
	for _, source := range sources {
		var tmpinfo protomsg.AIOcean
		tmpinfo.Id, ok = source["id"].(string)
		if !ok {
			continue
		}
		tmpinfo.CameraId, ok = source["cameraId"].(string)
		if !ok {
			continue
		}
		tmpinfo.CameraAddr, ok = source["cameraAddr"].(string)
		if !ok {
			continue
		}
		tmpinfo.AnalyServerId, ok = source["analyServerId"].(string)
		tmpinfo.AnalyServerName, ok = source["analyServerName"].(string)
		tmpinfo.AnalyServerIp, ok = source["analyServerIp"].(string)
		tmpinfo.ClusterId, ok = source["clusterId"].(string)
		tmpinfo.TaskId, ok = source["taskId"].(string)
		tmpinfo.TaskName, ok = source["taskName"].(string)
		tmpinfo.SdkName, ok = source["sdkName"].(string)

		if source["picMaxUrl"] != nil {
			for _, v := range source["picMaxUrl"].([]interface{}) {
				tmpinfo.PicMaxUrl = append(tmpinfo.PicMaxUrl, v.(string))
			}
		}
		tmpinfo.VideoUrl, ok = source["videoUrl"].(string)
		tmpinfo.PicDate, ok = source["picDate"].(string)
		if source["targetInfo"] != nil {
			for _, v := range source["targetInfo"].([]interface{}) {
				m := v.(map[string]interface{})
				var ti protomsg.TargetInfo
				ti.TargetId, ok = m["targetId"].(string)
				ti.TargetType, ok = m["targetType"].(string)
				ti.TargetScore, ok = m["targetScore"].(float64)
				ti.Feature, ok = m["feature"].(string)
				ti.PicSmUrl, ok = m["picSmUrl"].(string)
				targetLocation := m["targetLocation"].(map[string]interface{})
				topLeft := targetLocation["topLeft"].(map[string]interface{})
				tx := topLeft["x"].(float64)
				ty := topLeft["y"].(float64)
				bottomRight := targetLocation["bottomRight"].(map[string]interface{})
				bx := bottomRight["x"].(float64)
				by := bottomRight["y"].(float64)
				ti.TargetLocation = &protomsg.TargetLocation{
					TopLeft: &protomsg.Location{
						X: tx,
						Y: ty,
					},
					BottomRight: &protomsg.Location{
						X: bx,
						Y: by,
					},
				}
				tmpinfo.TargetInfo = append(tmpinfo.TargetInfo, &ti)
			}

		}
		tmpinfo.OtherLabels, ok = source["otherLabels"].(string)
		tmpinfo.ShowLabels, ok = source["showLabels"].(string)
		tmpinfo.LikeDate, ok = source["likeDate"].(string)
		if source["baseInfo"] != nil {
			for _, v := range source["baseInfo"].([]interface{}) {
				m := v.(map[string]interface{})
				var bi protomsg.BaseInfo
				bi.TableId, ok = m["tableId"].(string)
				bi.TableName, ok = m["tableName"].(string)
				bi.CompareScore, ok = m["compareScore"].(float64)
				bi.BwType, ok = m["bwType"].(string)
				bi.TargetId, ok = m["targetId"].(string)
				bi.TargetName, ok = m["targetName"].(string)
				bi.TargetPicUrl, ok = m["targetPicUrl"].(string)
				bi.MonitorLevel, ok = m["monitorLevel"].(string)
				bi.Labels, ok = m["labels"].(string)
				bi.Content, ok = m["content"].(string)
				tmpinfo.BaseInfo = append(tmpinfo.BaseInfo, &bi)
			}
		}
		tmpinfo.IsAlarm, ok = source["isAlarm"].(bool)
		tmpinfo.IsAckAlarm, ok = source["isAckAlarm"].(bool)
		if source["alarmRules"] != nil {
			for _, v := range source["alarmRules"].([]interface{}) {
				m := v.(map[string]interface{})
				var ar protomsg.AlarmRules
				ar.GroupId, ok = m["groupId"].(string)
				ar.AlarmLevel, ok = m["alarmLevel"].(string)
				ar.RuleText, ok = m["ruleText"].(string)
				ar.DefenceState, ok = m["defenceState"].(bool)
				ar.LinkInfo, ok = m["linkInfo"].(string)
				tmpinfo.AlarmRules = append(tmpinfo.AlarmRules, &ar)
			}

		}
		tmpinfo.IsCollect, ok = source["isCollect"].(bool)
		tmpinfo.IsDelete, ok = source["isDelete"].(bool)
		tmpinfo.Content, ok = source["content"].(string)
		tmpinfo.LinkTag, ok = source["linkTag"].(string)
		if source["linkTagInfo"] != nil {
			for _, v := range source["linkTagInfo"].([]interface{}) {
				var lti protomsg.EsDataBase
				lm := v.(map[string]interface{})
				lti.Id, ok = lm["id"].(string)
				if !ok {
					continue
				}
				lti.CameraId, ok = lm["cameraId"].(string)
				if !ok {
					continue
				}
				lti.CameraAddr, ok = lm["cameraAddr"].(string)
				if !ok {
					continue
				}
				lti.AnalyServerId, ok = lm["analyServerId"].(string)
				lti.AnalyServerName, ok = lm["analyServerName"].(string)
				lti.AnalyServerIp, ok = lm["analyServerIp"].(string)
				lti.ClusterId, ok = lm["clusterId"].(string)
				lti.TaskId, ok = lm["taskId"].(string)
				lti.TaskName, ok = lm["taskName"].(string)
				lti.SdkName, ok = lm["sdkName"].(string)
				if lm["picMaxUrl"] != nil {
					for _, v := range lm["picMaxUrl"].([]interface{}) {
						lti.PicMaxUrl = append(lti.PicMaxUrl, v.(string))
					}
				}
				lti.VideoUrl, ok = lm["videoUrl"].(string)
				lti.PicDate, ok = lm["picDate"].(string)
				if lm["targetInfo"] != nil {
					for _, v := range lm["targetInfo"].([]interface{}) {
						m := v.(map[string]interface{})
						var ti protomsg.TargetInfo
						ti.TargetId, ok = m["targetId"].(string)
						ti.TargetType, ok = m["targetType"].(string)
						ti.TargetScore, ok = m["targetScore"].(float64)
						ti.Feature, ok = m["feature"].(string)
						ti.PicSmUrl, ok = m["picSmUrl"].(string)
						targetLocation := m["targetLocation"].(map[string]interface{})
						topLeft := targetLocation["topLeft"].(map[string]interface{})
						tx := topLeft["x"].(float64)
						ty := topLeft["y"].(float64)
						bottomRight := targetLocation["bottomRight"].(map[string]interface{})
						bx := bottomRight["x"].(float64)
						by := bottomRight["y"].(float64)
						ti.TargetLocation = &protomsg.TargetLocation{
							TopLeft: &protomsg.Location{
								X: tx,
								Y: ty,
							},
							BottomRight: &protomsg.Location{
								X: bx,
								Y: by,
							},
						}
						lti.TargetInfo = append(lti.TargetInfo, &ti)
					}

				}
				lti.OtherLabels, ok = lm["otherLabels"].(string)
				lti.ShowLabels, ok = lm["showLabels"].(string)
				lti.LikeDate, ok = lm["likeDate"].(string)
				if lm["baseInfo"] != nil {
					for _, v := range lm["baseInfo"].([]interface{}) {
						m := v.(map[string]interface{})
						var bi protomsg.BaseInfo
						bi.TableId, ok = m["tableId"].(string)
						bi.TableName, ok = m["tableName"].(string)
						bi.CompareScore, ok = m["compareScore"].(float64)
						bi.BwType, ok = m["bwType"].(string)
						bi.TargetId, ok = m["targetId"].(string)
						bi.TargetName, ok = m["targetName"].(string)
						bi.TargetPicUrl, ok = m["targetPicUrl"].(string)
						bi.MonitorLevel, ok = m["monitorLevel"].(string)
						bi.Labels, ok = m["labels"].(string)
						bi.Content, ok = m["content"].(string)
						tmpinfo.BaseInfo = append(tmpinfo.BaseInfo, &bi)
					}
				}
				lti.IsAlarm, ok = lm["isAlarm"].(bool)
				lti.IsAckAlarm, ok = lm["isAckAlarm"].(bool)
				if lm["alarmRules"] != nil {
					for _, v := range lm["alarmRules"].([]interface{}) {
						m := v.(map[string]interface{})
						var ar protomsg.AlarmRules
						ar.GroupId, ok = m["groupId"].(string)
						ar.AlarmLevel, ok = m["alarmLevel"].(string)
						ar.RuleText, ok = m["ruleText"].(string)
						ar.DefenceState, ok = m["defenceState"].(bool)
						ar.LinkInfo, ok = m["linkInfo"].(string)
						lti.AlarmRules = append(lti.AlarmRules, &ar)
					}

				}
				lti.IsCollect, ok = lm["isCollect"].(bool)
				lti.IsDelete, ok = lm["isDelete"].(bool)
				lti.Content, ok = lm["content"].(string)
				tmpinfo.LinkTagInfo = append(tmpinfo.LinkTagInfo, &lti)
			}
		}
		tmpinfos = append(tmpinfos, tmpinfo)
	}
	return tmpinfos
}

// 解析底库人员结构
func Dbpersonbyid(sources []map[string]interface{}) (tmpinfos []protomsg.Dbperson) {
	var ok bool

	var tmpinfo protomsg.Dbperson
	for _, source := range sources {
		tmpinfo.FaceFeature, ok = source["faceFeature"].(string)
		if !ok {
			continue
		}

		tmpinfo.Id, ok = source["id"].(string)
		if !ok {
			continue
		}

		tmpinfo.TableId, ok = source["tableId"].(string)
		if !ok {
			continue
		}

		tmpinfo.PersonName, ok = source["personName"].(string)
		//Isnil("personName", ok)
		tmpinfo.PersonPicUrl, ok = source["personPicUrl"].(string)
		//Isnil("personPicUrl", ok)
		tmpinfo.PhoneNum, ok = source["phoneNum"].(string)
		//Isnil("phoneNum", ok)
		tmpinfo.Sex, ok = source["sex"].(string)
		//Isnil("sex", ok)
		tmpinfo.IdCard, ok = source["idCard"].(string)
		//Isnil("idCard", ok)
		tmpinfo.MonitorLevel, ok = source["monitorLevel"].(string)
		//Isnil("monitorLevel",ok)
		tmpinfo.UpdateTime, ok = source["updateTime"].(string)
		//Isnil("updateTime",ok)
		tmpinfo.Age, ok = source["age"].(string)
		//Isnil("age", ok)

		isDelete, ok := source["isDelete"].(float64)
		if ok {
			tmpinfo.IsDelete = int32(isDelete)
		}
		//Isnil("isDelete", ok)

		enable, ok := source["enable"].(float64)
		if ok {
			tmpinfo.Enable = int32(enable)
		}
		//Isnil("endTime", ok)

		tmpinfo.Reserved, ok = source["reserved"].(string)
		//Isnil("reserved",ok)
		tmpinfo.PicDesc, ok = source["picDesc"].(string)
		//Isnil("picDesc",ok)
		tmpinfo.CreateTime, ok = source["createTime"].(string)
		//Isnil("createTime",ok)
		tmpinfo.CreateBy, ok = source["createBy"].(string)
		//Isnil("createBy",ok)

		//根据 tableid 获取 tablename
		//name, _:= Dbtablename(tmpinfo.TableId)
		//tmpinfo.TableName= name
		tmpinfos = append(tmpinfos, tmpinfo)
	}

	return tmpinfos
}

// 解析底库结构
func Dbtablebyid(sources []map[string]interface{}) (tmpinfos []protomsg.Dbtable) {
	var ok bool

	var tmpinfo protomsg.Dbtable
	for _, source := range sources {

		tmpinfo.Id, ok = source["id"].(string)
		if !ok {
			continue
		}
		tmpinfo.TableName, ok = source["tableName"].(string)
		//Isnil("tableName", ok)
		tmpinfo.TableType, ok = source["tableType"].(string)
		//Isnil("tableType", ok)
		tmpinfo.CreateBy, ok = source["createBy"].(string)
		//Isnil("createBy", ok)
		tmpinfo.TableDesc, ok = source["tableDesc"].(string)
		//Isnil("tableDesc", ok)
		tmpinfo.BwType, ok = source["bwType"].(string)
		//Isnil("bwType", ok)
		tmpinfo.StartTime, ok = source["startTime"].(string)
		//Isnil("startTime", ok)
		tmpinfo.EndTime, ok = source["endTime"].(string)
		//Isnil("endTime", ok)

		isDelete, ok := source["isDelete"].(float64)
		if ok {
			tmpinfo.IsDelete = int32(isDelete)
		}
		//Isnil("isDelete", ok)

		enable, ok := source["enable"].(float64)
		if ok {
			tmpinfo.Enable = int32(enable)
		}
		//Isnil("endTime", ok)

		tmpinfo.CreateTime, ok = source["createTime"].(string)
		//Isnil("createTime", ok)
		tmpinfo.UpdateTime, ok = source["updateTime"].(string)
		//Isnil("updateTime", ok)
		tmpinfo.IsForever, ok = source["isForever"].(string)
		//Isnil("isForever", ok)
		tmpinfo.IsSync, ok = source["isSync"].(string)
		//Isnil("isSync", ok)
		tmpinfo.AnalyServerId, ok = source["analyServerId"].(string)
		//Isnil("analyServerId", ok)

		tmpinfos = append(tmpinfos, tmpinfo)
	}

	return tmpinfos
}

func FaceSourceAggregations(buf []byte, thresholdTime int, thresholdStayTime int) (sources []map[string]interface{}, err error) {
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		return nil, errors.New("时区设置错误")
	}
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}
	middle, ok := out["aggregations"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
	buckets := bucketsAggs["buckets"].([]interface{})
	if len(buckets) == 0 {
		return nil, nil
	}
	allSource := make([]map[string]interface{}, 0)
	for _, inf := range buckets {
		hitsSources := make([]map[string]interface{}, 0)
		topAttentionHits := inf.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
		middleHits := topAttentionHits["hits"].(map[string]interface{})
		finalHits := middleHits["hits"].([]interface{})
		startTime := ""
		indexLength := len(finalHits)
		point := 0
		for _, in := range finalHits {
			point = point + 1
			tmpHitSource := make(map[string]interface{})
			tmpBuf, ok := in.(map[string]interface{})
			if !ok {
				fmt.Println("change to source error!")
				continue
			}
			source, ok := tmpBuf["_source"].(map[string]interface{})
			if !ok {
				fmt.Println("change _source error!")
				continue
			}
			baseInfo := source["baseInfo"].([]interface{})[0].(map[string]interface{})
			targetInfo := source["targetInfo"].([]interface{})[0].(map[string]interface{})
			tmpTime := source["picDate"].(string)
			if len(tmpTime) > 19 {
				tmpTime = tmpTime[:19]
			}
			mTime, err := time.ParseInLocation("2006-01-02 15:04:05", tmpTime, loc)
			if err != nil {
				return nil, errors.New("时间解析错误")
			}

			sTime := tmpTime
			eTime := mTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
			stayTime := 1.0
			if startTime != "" && point <= indexLength {
				sinTime, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
				passTime := math.Abs(mTime.Sub(sinTime).Seconds())
				hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
				//fmt.Println("passTime:   ", passTime)
				if int(passTime) <= thresholdTime {
					if point == indexLength {
						hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
						realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
						stayTime = math.Abs(mTime.Sub(realStartTime).Seconds())
						hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
						startTime = ""
					} else {
						startTime = tmpTime
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
					}
					continue
				} else {
					hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
					hitEndTime := hitsSources[len(hitsSources)-1]["endTime"].(string)
					realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
					realEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitEndTime, loc)
					stayTime = math.Abs(realEndTime.Sub(realStartTime).Seconds())
					if sinTime.Sub(mTime).Seconds() == 0 {
						sinTime.Add(time.Second * 1)
						sinTime.Format("2006-01-02 15:04:05")
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
						stayTime = 1
					} else if stayTime == 0 {
						stayTime = 1
						hitsSources[len(hitsSources)-1]["endTime"] = realEndTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
					}
					hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
					if point == indexLength {
						stayTime = 1
					}
					startTime = ""
				}
			}
			//fmt.Println("========================================================")
			startTime = tmpTime
			tmpHitSource["faceId"] = baseInfo["targetId"].(string)
			if targetInfo["areaId"] == nil {
				continue
			}
			tmpHitSource["areaId"] = targetInfo["areaId"].(string)
			tmpHitSource["startTime"] = sTime
			tmpHitSource["faceImg"] = targetInfo["picSmUrl"].(string)
			tmpHitSource["endTime"] = eTime
			tmpHitSource["stayTime"] = stayTime
			hitsSources = append(hitsSources, tmpHitSource)
		}
		allSource = append(allSource, hitsSources...)
	}
	return allSource, nil
}

func SourceDeduplication(buf []byte) ([]map[string]interface{}, error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}
	middle, ok := out["aggregations"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
	buckets := bucketsAggs["buckets"].([]interface{})
	if len(buckets) == 0 {
		return nil, nil
	}
	faceId := make([]map[string]interface{}, 0)
	for _, in := range buckets {
		tmpInfo := make(map[string]interface{})
		topAttentionHits := in.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
		middleHits := topAttentionHits["hits"].(map[string]interface{})
		finalHits := middleHits["hits"].([]interface{})
		tmpInfo["faceId"] = in.(map[string]interface{})["key"].(map[string]interface{})["faceId"].(string)
		tmpInfo["lastTime"] = finalHits[0].(map[string]interface{})["_source"].(map[string]interface{})["picDate"].(string)
		faceId = append(faceId, tmpInfo)
	}
	return faceId, nil
}

// 解析聚合计数结构
func SourceStatistics(buf []byte) ([]map[string]interface{}, error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}
	middle, ok := out["aggregations"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
	buckets := bucketsAggs["buckets"].([]interface{})
	if len(buckets) == 0 {
		return nil, nil
	}
	resultData := make([]map[string]interface{}, 0)
	for _, pick := range buckets {
		data := make(map[string]interface{}, 0)
		data["areaId"] = pick.(map[string]interface{})["key"].(map[string]interface{})["areaId"].(string)
		data["peopleNum"] = int(pick.(map[string]interface{})["doc_count"].(float64))
		resultData = append(resultData, data)
	}
	return resultData, nil
}

func SourceAggregations(buf []byte, thresholdTime float64, queryUseTime float64) (sources map[string]interface{}, err error) {
	s := make(map[string]interface{})
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		return nil, errors.New("时区设置错误")
	}
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}
	middle, ok := out["aggregations"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
	buckets := bucketsAggs["buckets"].([]interface{})
	if len(buckets) == 0 {
		return nil, nil
	}
	allSource := make([]map[string]interface{}, 0)
	for _, inf := range buckets {
		//tmpSources := make(map[string]interface{}, 0)
		hitsSources := make([]map[string]interface{}, 0)
		//groupKey := inf.(map[string]interface{})["key"].(map[string]interface{})
		//docCount := int(inf.(map[string]interface{})["doc_count"].(float64))
		topAttentionHits := inf.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
		middleHits := topAttentionHits["hits"].(map[string]interface{})
		finalHits := middleHits["hits"].([]interface{})
		startTime := ""
		indexLength := len(finalHits)
		point := 0
		for _, in := range finalHits {
			point = point + 1
			tmpHitSource := make(map[string]interface{})
			tmpbuf, ok := in.(map[string]interface{})
			if !ok {
				fmt.Println("change to source error!")
				continue
			}
			source, ok := tmpbuf["_source"].(map[string]interface{})
			if !ok {
				fmt.Println("change _source error!")
				continue
			}
			baseInfo := source["baseInfo"].([]interface{})[0].(map[string]interface{})
			targetInfo := source["targetInfo"].([]interface{})[0].(map[string]interface{})
			tmpTime := source["picDate"].(string)
			if len(tmpTime) > 19 {
				tmpTime = tmpTime[:19]
			}
			mTime, err := time.ParseInLocation("2006-01-02 15:04:05", tmpTime, loc)
			if err != nil {
				return nil, errors.New("时间解析错误")
			}

			sTime := tmpTime
			eTime := mTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
			stayTime := 1.0
			if startTime != "" && point <= indexLength {
				sinTime, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
				passTime := math.Abs(mTime.Sub(sinTime).Seconds())
				hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
				//fmt.Println("passTime:   ", passTime)
				if passTime <= thresholdTime {
					if point == indexLength {
						hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
						realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
						stayTime = math.Abs(mTime.Sub(realStartTime).Seconds())
						hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
						startTime = ""
					} else {
						startTime = tmpTime
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
					}
					continue
				} else {
					hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
					hitEndTime := hitsSources[len(hitsSources)-1]["endTime"].(string)
					realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
					realEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitEndTime, loc)
					stayTime = math.Abs(realEndTime.Sub(realStartTime).Seconds())
					if sinTime.Sub(mTime).Seconds() == 0 {
						sinTime.Add(time.Second * 1)
						sinTime.Format("2006-01-02 15:04:05")
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
						stayTime = 1
					} else if stayTime == 0 {
						stayTime = 1
						hitsSources[len(hitsSources)-1]["endTime"] = realEndTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
					}
					hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
					if point == indexLength {
						stayTime = 1
					}
					startTime = ""
				}
			}
			//fmt.Println("========================================================")
			startTime = tmpTime
			tmpHitSource["personId"] = baseInfo["targetId"].(string)
			tmpHitSource["cameraId"] = source["cameraId"].(string)
			tmpHitSource["cameraName"] = source["cameraName"].(string)
			tmpHitSource["cameraAddr"] = source["cameraAddr"].(string)
			tmpHitSource["targetScore"] = int(targetInfo["targetScore"].(float64))
			tmpHitSource["properties"] = source["showLabels"].(string)
			tmpHitSource["tableId"] = baseInfo["tableId"].(string)
			tmpHitSource["tableName"] = baseInfo["tableName"].(string)
			tmpHitSource["bwType"] = baseInfo["bwType"].(string)
			tmpHitSource["personName"] = baseInfo["targetName"].(string)
			tmpHitSource["compareScore"] = int(baseInfo["compareScore"].(float64))
			tmpHitSource["startTime"] = sTime
			tmpHitSource["startBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
			tmpHitSource["startFacePicUrl"] = targetInfo["picSmUrl"].(string)
			tmpHitSource["endTime"] = eTime
			tmpHitSource["stayTime"] = stayTime
			tmpHitSource["endTBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
			tmpHitSource["endTFacePicUrl"] = targetInfo["picSmUrl"].(string)
			if source["picWH"] != nil {
				tmpHitSource["picWH"] = source["picWH"].(map[string]interface{})
			}
			hitsSources = append(hitsSources, tmpHitSource)
		}
		allSource = append(allSource, hitsSources...)
	}
	count := len(allSource)
	//fmt.Println(count)
	s["count"] = count
	s["allSource"] = allSource
	s["queryUseTime"] = queryUseTime
	return s, nil
}

func SourceAggregationsReturnByGrouped(buf []byte, thresholdTime float64) (sources []map[string]interface{}, err error) {
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		return nil, errors.New("时区设置错误")
	}
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}
	middle, ok := out["aggregations"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	bucketsAggs := middle["buckets_aggs"].(map[string]interface{})
	buckets := bucketsAggs["buckets"].([]interface{})
	if len(buckets) == 0 {
		return nil, nil
	}
	for _, inf := range buckets {
		tmpSources := make(map[string]interface{}, 0)
		hitsSources := make([]map[string]interface{}, 0)
		groupKey := inf.(map[string]interface{})["key"].(map[string]interface{})
		topAttentionHits := inf.(map[string]interface{})["top_attention_hits"].(map[string]interface{})
		middleHits := topAttentionHits["hits"].(map[string]interface{})
		finalHits := middleHits["hits"].([]interface{})
		indexLength := len(finalHits)
		point := 0
		startTime := ""
		//fmt.Println("finalHits: ",finalHits)
		for _, in := range finalHits {
			point = point + 1
			tmpHitSource := make(map[string]interface{})
			tmpbuf, ok := in.(map[string]interface{})
			if !ok {
				fmt.Println("change to source error!")
				continue
			}
			source, ok := tmpbuf["_source"].(map[string]interface{})
			if !ok {
				fmt.Println("change _source error!")
				continue
			}
			baseInfo := source["baseInfo"].([]interface{})[0].(map[string]interface{})
			targetInfo := source["targetInfo"].([]interface{})[0].(map[string]interface{})
			tmpTime := source["picDate"].(string)
			if len(tmpTime) > 19 {
				tmpTime = tmpTime[:19]
			}
			mTime, err := time.ParseInLocation("2006-01-02 15:04:05", tmpTime, loc)
			if err != nil {
				return nil, errors.New("时间解析错误")
			}

			sTime := tmpTime
			eTime := mTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
			stayTime := 1.0
			if startTime != "" && point <= indexLength {
				sinTime, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
				passTime := math.Abs(mTime.Sub(sinTime).Seconds())
				hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
				//fmt.Println("passTime:   ", passTime)
				if passTime <= thresholdTime {
					if point == indexLength {
						hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
						realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
						stayTime = math.Abs(mTime.Sub(realStartTime).Seconds())
						hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
						startTime = ""
					} else {
						startTime = tmpTime
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
					}
					continue
				} else {
					hitStartTime := hitsSources[len(hitsSources)-1]["startTime"].(string)
					hitEndTime := hitsSources[len(hitsSources)-1]["endTime"].(string)
					realStartTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitStartTime, loc)
					realEndTime, _ := time.ParseInLocation("2006-01-02 15:04:05", hitEndTime, loc)
					stayTime = math.Abs(realEndTime.Sub(realStartTime).Seconds())
					if sinTime.Sub(mTime).Seconds() == 0 {
						sinTime.Add(time.Second * 1)
						sinTime.Format("2006-01-02 15:04:05")
						hitsSources[len(hitsSources)-1]["endTime"] = tmpTime
						stayTime = 1
					} else if stayTime == 0 {
						stayTime = 1
						hitsSources[len(hitsSources)-1]["endTime"] = realEndTime.Add(time.Second * 1).Format("2006-01-02 15:04:05")
					}
					hitsSources[len(hitsSources)-1]["stayTime"] = stayTime
					if point == indexLength {
						stayTime = 1
					}
					startTime = ""
				}
			}
			startTime = tmpTime
			tmpHitSource["personId"] = baseInfo["targetId"].(string)
			tmpHitSource["cameraId"] = source["cameraId"].(string)
			tmpHitSource["cameraName"] = source["cameraName"].(string)
			tmpHitSource["cameraAddr"] = source["cameraAddr"].(string)
			tmpHitSource["targetScore"] = int(targetInfo["targetScore"].(float64))
			tmpHitSource["properties"] = source["showLabels"].(string)
			tmpHitSource["tableId"] = baseInfo["tableId"].(string)
			tmpHitSource["tableName"] = baseInfo["tableName"].(string)
			tmpHitSource["bwType"] = baseInfo["bwType"].(string)
			tmpHitSource["personName"] = baseInfo["targetName"].(string)
			tmpHitSource["compareScore"] = int(baseInfo["compareScore"].(float64))
			tmpHitSource["startTime"] = sTime
			tmpHitSource["startBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
			tmpHitSource["startFacePicUrl"] = targetInfo["picSmUrl"].(string)
			tmpHitSource["endTime"] = eTime
			tmpHitSource["stayTime"] = stayTime
			tmpHitSource["endTBackGroundPicUrl"] = source["picMaxUrl"].([]interface{})
			tmpHitSource["endTFacePicUrl"] = targetInfo["picSmUrl"].(string)
			if source["picWH"] != nil {
				tmpHitSource["picWH"] = source["picWH"].(map[string]interface{})
			}
			hitsSources = append(hitsSources, tmpHitSource)
		}
		tmpSources["groupKey"] = groupKey
		tmpSources["hits_sources"] = hitsSources
		sources = append(sources, tmpSources)
	}
	return sources, nil
}

// 解析抓拍库人员结构
func PerSonAnalysis(preData []map[string]interface{}) (sources []map[string]interface{}, err error) {
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		return nil, errors.New("时区设置错误")
	}
	for _, key := range preData {
		source := make(map[string]interface{}, 0)
		info := key
		targetInfo := info["targetInfo"].([]interface{})[0].(map[string]interface{})
		startTime := info["picDate"].(string)
		endTime := info["updateTime"].(string)
		source["personId"] = targetInfo["belongsTargetId"].(string)
		source["cameraId"] = info["cameraId"].(string)
		source["cameraName"] = info["cameraName"].(string)
		source["cameraAddr"] = info["cameraAddr"].(string)
		source["targetScore"] = int(targetInfo["targetScore"].(float64))
		source["personRect"] = targetInfo["targetLocation"].(map[string]interface{})
		source["startTime"] = startTime
		pixMaxUrl := info["picMaxUrl"].([]interface{})
		source["startBackGroundPicUrl"] = pixMaxUrl[0]
		source["endTime"] = endTime
		startT, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, loc)
		endT, _ := time.ParseInLocation("2006-01-02 15:04:05", endTime, loc)
		stayTime := endT.Sub(startT).Seconds()
		source["stayTime"] = stayTime
		source["endBackGroundPicUrl"] = pixMaxUrl[len(pixMaxUrl)-1]
		if info["picWH"] != nil {
			source["picWH"] = info["picWH"].(map[string]interface{})
		}
		sources = append(sources, source)
	}

	return sources, nil
}

func Sourcelist(buf []byte) (sources []map[string]interface{}, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["hits"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	for _, in := range middle["hits"].([]interface{}) {
		tmpbuf, ok := in.(map[string]interface{})
		if !ok {
			fmt.Println("change to source error!")
			continue
		}
		source, ok := tmpbuf["_source"].(map[string]interface{})
		if !ok {
			fmt.Println("change _source error!")
			continue
		}
		sources = append(sources, source)
	}
	return sources, nil
}

func Sourcelistforscroll(buf []byte) (datasource map[string]interface{}, err error) {
	var data = make(map[string]interface{})
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}
	scroll_id, ok := out["_scroll_id"].(string)
	if !ok {
		return nil, errors.New("first hits change error!")
	}

	//fmt.Println("middle: ",scroll_id)
	middle, ok := out["hits"].(map[string]interface{})
	//fmt.Println("middle: ",out)
	if !ok {
		return nil, errors.New("first hits change error!")
	}
	var sources = make([]map[string]interface{}, 0)
	for _, in := range middle["hits"].([]interface{}) {
		tmpbuf, ok := in.(map[string]interface{})
		if !ok {
			fmt.Println("change to source error!")
			continue
		}
		source, ok := tmpbuf["_source"].(map[string]interface{})
		if !ok {
			fmt.Println("change _source error!")
			continue
		}
		sources = append(sources, source)
	}

	data["sourcelist"] = sources
	data["scroll_id"] = scroll_id
	return data, nil
}

func SourceCreated(buf []byte) (result bool, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return false, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["result"].(string)
	if !ok {
		return false, errors.New("first total change error!")
	}
	if middle == "created" || middle == "updated" {
		result = true
	}
	return result, nil
}

func SourceDeleted(buf []byte) (total int, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return -1, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["deleted"].(float64)
	if !ok {
		return -1, errors.New("first total change error!")
	}
	total = int(middle)
	return total, nil
}

func SourceUpdated(buf []byte) (total int, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return -1, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["updated"].(float64)
	if !ok {
		return -1, errors.New("first total change error!")
	}
	total = int(middle)
	return total, nil
}

func SourceTotal(buf []byte) (total int, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return -1, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["hits"].(map[string]interface{})
	if !ok {
		return -1, errors.New("first total change error!")
	}

	tmp, b := middle["total"].(map[string]interface{})
	if b != true {
		v := middle["total"].(float64)
		t := int(v)
		return t, nil
	}
	value := tmp["value"].(float64)
	total = int(value)
	return total, nil
}

func SourceAggregationList(buf []byte) (sources []map[string]interface{}, err error) {
	var info interface{}
	json.Unmarshal(buf, &info)
	out, ok := info.(map[string]interface{})
	if !ok {
		return nil, errors.New("http response interface can not change map[string]interface{}")
	}

	middle, ok := out["aggregations"].(map[string]interface{})
	if !ok {
		return nil, errors.New("first hits change error!")
	}

	documentAggregations := middle["group_by_documentnumber"].(map[string]interface{})
	buckets := documentAggregations["buckets"].([]interface{})
	if len(buckets) == 0 {
		return nil, nil
	}
	for _, in := range buckets {
		tmpbuf, ok := in.(map[string]interface{})
		if !ok {
			return nil, errors.New("")
		}
		sources = append(sources, tmpbuf)
	}
	return sources, nil
}

func EsReq(method string, url string, parama []byte) (buf []byte, err error) {
	//defer elapsed("page")()
	timeout := time.Duration(100 * time.Second)
	client := http.Client{
		Timeout: timeout,
	}
	request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
	request.Header.Set("Content-type", "application/json")
	request.Header.Set("Authorization", Token)

	if err != nil {
		fmt.Println("build request fail !")
		return nil, err
	}

	resp, err := client.Do(request)
	if err != nil {
		fmt.Println("request error: ", err)
		return nil, err
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	return body, nil
}

// 计算时间
func elapsed(what string) func() {
	start := time.Now()
	return func() {
		fmt.Printf("%s took %v\n", what, time.Since(start))
	}
}

// 赋值时检测是否能够赋值
//func //Isnil(key string, ok bool){
//    if !ok {
//            fmt.Println(key, "is nil can not asign")
//    }
//}

type account struct {
	Username     string `mapstructure: "username"`
	Userpassword string `mapstructure: "userpassword"`
}

var Account = &account{}

var Token string

func init() {
	v := viper.New()
	v.SetConfigType("yaml")
	v.SetConfigName("pro")
	v.AddConfigPath("../config/")
	v.AddConfigPath("./config/")
	v.AddConfigPath("/opt/vasystem/config/")
	err := v.ReadInConfig()
	if err != nil {
		log.Fatal("err on parsing configuration file!", err)
	}
	v.UnmarshalKey("es.account", Account)

	Token = "Basic " + base64.StdEncoding.EncodeToString([]byte(Account.Username+":"+Account.Userpassword))
}