package service

import (
	"encoding/json"
	"errors"
	"regexp"
	"sort"
	"strings"
	"sync"
	"vamicro/scene-service/models"
	"vamicro/scene-service/vo"

	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"basic.com/valib/logger.git"
	"github.com/satori/go.uuid"
)

type CameraRuleService struct {
	Broker bhomeclient.Broker
}

//保存单个摄像机的独立任务
func (sv CameraRuleService) Save(reqBody vo.GroupRuleVo) (bool, error) {
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()

	var dbAction protomsg.DbAction
	var dbId string
	if reqBody.Id == "" { //新增
		crg := models.CameraRuleGroup{
			Id:           uuid.NewV4().String(),
			GroupText:    reqBody.GroupText,
			SetType:      "batchTask",
			AlarmLevel:   reqBody.AlarmLevel,
			TemplateId:   reqBody.TemplateId,
			TemplateRule: "",
			TimeRuleId:   reqBody.TimeRuleId,
			SceneName:    reqBody.SceneName,
			Desc:         reqBody.Desc,
			Enable:       true,
			VoiceId:      reqBody.VoiceId,
		}
		if err = tx.Table(crg.TableName()).Create(&crg).Error; err != nil {
			return false, err
		}
		for sort, baseRule := range reqBody.Rules {
			rga := models.CameraRuleGroupArg{
				Id: uuid.NewV4().String(),
			}
			rga.CameraRuleBase = models.CameraRuleBase{
				CameraId:     baseRule.CameraId,
				SdkId:        baseRule.SdkId,
				PolygonId:    baseRule.PolygonId,
				RuleWithPre:  baseRule.RuleWithPre,
				IsSaveAnyhow: baseRule.IsSaveAnyhow,
				Sort:         sort,
			}
			setB, _ := json.Marshal(baseRule.SdkSet)
			rga.SdkSet = string(setB)
			rga.GroupId = crg.Id
			if err = tx.Exec("insert into "+rga.TableName()+"(id,camera_id,sdk_id,polygon_id,sdk_set,rule_with_pre,is_save_anyhow,group_id,sort) values(?,?,?,?,?,?,?,?,?)", rga.Id, rga.CameraId, rga.SdkId, rga.PolygonId, rga.SdkSet, rga.RuleWithPre, rga.IsSaveAnyhow, rga.GroupId, rga.Sort).Error; err != nil {
				return false, err
			}
		}
		dbAction = protomsg.DbAction_Insert
		dbId = crg.Id
	} else { //更新
		var crg models.CameraRuleGroup
		rows, _ := crg.SelectById(reqBody.Id)
		if rows <= 0 {
			err = errors.New("场景规则已删除")
			return false, err
		}
		if err = tx.Exec("delete from "+models.CameraRuleGroupArg{}.TableName()+" where group_id=?", reqBody.Id).Error; err != nil {
			return false, err
		}

		if err = tx.Exec("update "+models.CameraRuleGroup{}.TableName()+" set template_id=?,time_rule_id=?,scene_name=?,desc=?,alarm_level=?,group_text=?,voiceId=? where id=?", reqBody.TemplateId, reqBody.TimeRuleId, reqBody.SceneName, reqBody.Desc, reqBody.AlarmLevel, reqBody.GroupText, reqBody.VoiceId, reqBody.Id).Error; err != nil {
			return false, err
		}
		for sort, baseRule := range reqBody.Rules {
			rga := models.CameraRuleGroupArg{
				Id: uuid.NewV4().String(),
			}
			rga.CameraRuleBase = models.CameraRuleBase{
				CameraId:     baseRule.CameraId,
				SdkId:        baseRule.SdkId,
				PolygonId:    baseRule.PolygonId,
				RuleWithPre:  baseRule.RuleWithPre,
				IsSaveAnyhow: baseRule.IsSaveAnyhow,
				Sort:         sort,
			}
			setB, _ := json.Marshal(baseRule.SdkSet)
			rga.SdkSet = string(setB)
			rga.GroupId = reqBody.Id
			if err = tx.Exec("insert into "+rga.TableName()+"(id,camera_id,sdk_id,polygon_id,sdk_set,rule_with_pre,is_save_anyhow,group_id,sort) values(?,?,?,?,?,?,?,?,?)", rga.Id, rga.CameraId, rga.SdkId, rga.PolygonId, rga.SdkSet, rga.RuleWithPre, rga.IsSaveAnyhow, rga.GroupId, rga.Sort).Error; err != nil {
				return false, err
			}
		}
		dbAction = protomsg.DbAction_Update
		dbId = reqBody.Id
	}

	tx.Commit()
	//var camE models.Camera
	//camE.ReSetCamerasRun(reqBody.CameraIds)//实时或者轮询摄像机有变化
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_Camera,
		Id:     dbId,
		Action: dbAction,
		Info:   dbId,
	})
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_CameraRule,
		Id:     dbId,
		Action: dbAction,
		Info:   dbId,
	})

	return true, nil
}

//保存联动任务规则
func (sv CameraRuleService) SaveLinkRulesByGroup(reqBody *vo.GroupRuleVo) (bool, string) {
	var linkCameras []string
	if len(reqBody.CameraIds) <= 1 {
		return false, "联动摄像机数量必须大于1"
	} else {
		cM := make(map[string]string)
		for _, r := range reqBody.Rules {
			if r.CameraId != "" {
				if _, ok := cM[r.CameraId]; !ok {
					cM[r.CameraId] = r.CameraId
				}
			}
		}
		for _, v := range cM {
			linkCameras = append(linkCameras, v)
		}
		if len(linkCameras) <= 1 {
			return false, "联动摄像机数量必须大于1"
		}
	}
	sort.Strings(linkCameras)
	dbCamIdStr := strings.Join(linkCameras, ",")
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()

	var dbAction protomsg.DbAction
	var dbId string
	if reqBody.Id == "" { //新增
		crg := models.CameraRuleGroup{
			Id:           uuid.NewV4().String(),
			GroupText:    reqBody.GroupText,
			SetType:      "linkTask",
			AlarmLevel:   reqBody.AlarmLevel,
			TemplateId:   reqBody.TemplateId,
			TemplateRule: "",
			TimeRuleId:   reqBody.TimeRuleId,
			SceneName:    reqBody.SceneName,
			Desc:         reqBody.Desc,
			Enable:       true,
			VoiceId:      reqBody.VoiceId,
		}
		if err = tx.Table(crg.TableName()).Create(&crg).Error; err != nil {
			return false, err.Error()
		}
		for sort, baseRule := range reqBody.Rules {
			rga := models.CameraRuleGroupArg{
				Id: uuid.NewV4().String(),
			}
			rga.CameraRuleBase = models.CameraRuleBase{
				CameraId:     baseRule.CameraId,
				SdkId:        baseRule.SdkId,
				PolygonId:    baseRule.PolygonId,
				RuleWithPre:  baseRule.RuleWithPre,
				IsSaveAnyhow: baseRule.IsSaveAnyhow,
				Sort:         sort,
			}
			setB, _ := json.Marshal(baseRule.SdkSet)
			rga.SdkSet = string(setB)
			rga.GroupId = crg.Id
			if err = tx.Exec("insert into "+rga.TableName()+"(id,camera_id,sdk_id,polygon_id,sdk_set,rule_with_pre,is_save_anyhow,group_id,sort) values(?,?,?,?,?,?,?,?,?)", rga.Id, rga.CameraId, rga.SdkId, rga.PolygonId, rga.SdkSet, rga.RuleWithPre, rga.IsSaveAnyhow, rga.GroupId, rga.Sort).Error; err != nil {
				return false, err.Error()
			}
		}
		ctl := models.CameraTaskLink{
			CameraIds:  dbCamIdStr,
			LinkTaskId: crg.Id,
		}
		if err = tx.Table(ctl.TableName()).Create(&ctl).Error; err != nil {
			return false, err.Error()
		}
		dbAction = protomsg.DbAction_Insert
		dbId = crg.Id
	} else { //更新
		var crg models.CameraRuleGroup
		rows, _ := crg.SelectById(reqBody.Id)
		if rows <= 0 {
			err = errors.New("场景规则已删除")
			return false, err.Error()
		}
		if err = tx.Exec("delete from "+models.CameraRuleGroupArg{}.TableName()+" where group_id=?", reqBody.Id).Error; err != nil {
			return false, err.Error()
		}

		if err = tx.Exec("update "+models.CameraRuleGroup{}.TableName()+" set template_id=?,time_rule_id=?,scene_name=?,desc=?,alarm_level=?,group_text=?,voiceId=? where id=?", reqBody.TemplateId, reqBody.TimeRuleId, reqBody.SceneName, reqBody.Desc, reqBody.AlarmLevel, reqBody.GroupText, reqBody.VoiceId, reqBody.Id).Error; err != nil {
			return false, err.Error()
		}
		if err = tx.Exec("update "+models.CameraTaskLink{}.TableName()+" set camera_ids=? where link_task_id=?", dbCamIdStr, reqBody.Id).Error; err != nil {
			return false, err.Error()
		}
		for sort, baseRule := range reqBody.Rules {
			rga := models.CameraRuleGroupArg{
				Id: uuid.NewV4().String(),
			}
			rga.CameraRuleBase = models.CameraRuleBase{
				CameraId:     baseRule.CameraId,
				SdkId:        baseRule.SdkId,
				PolygonId:    baseRule.PolygonId,
				RuleWithPre:  baseRule.RuleWithPre,
				IsSaveAnyhow: baseRule.IsSaveAnyhow,
				Sort:         sort,
			}
			setB, _ := json.Marshal(baseRule.SdkSet)
			rga.SdkSet = string(setB)
			rga.GroupId = reqBody.Id
			if err = tx.Exec("insert into "+rga.TableName()+"(id,camera_id,sdk_id,polygon_id,sdk_set,rule_with_pre,is_save_anyhow,group_id,sort) values(?,?,?,?,?,?,?,?,?)", rga.Id, rga.CameraId, rga.SdkId, rga.PolygonId, rga.SdkSet, rga.RuleWithPre, rga.IsSaveAnyhow, rga.GroupId, rga.Sort).Error; err != nil {
				return false, err.Error()
			}
		}
		dbAction = protomsg.DbAction_Update
		dbId = reqBody.Id
	}

	tx.Commit()
	//var camE models.Camera
	//camE.ReSetCamerasRun(reqBody.CameraIds) //实时或者轮询摄像机有变化
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_Camera,
		Id:     dbId,
		Action: dbAction,
		Info:   dbId,
	})
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_CameraRule,
		Id:     dbId,
		Action: dbAction,
		Info:   dbId,
	})

	return true, ""
}

func (sv CameraRuleService) UpdateAlarmLevel(groupId string, alarmLevel int) bool {
	var g models.CameraRuleGroup
	if g.UpdateAlarmLevel(groupId, alarmLevel) {
		sv.addDbMessage(&protomsg.DbChangeMessage{
			Table:  protomsg.TableChanged_T_CameraRule,
			Id:     groupId,
			Action: protomsg.DbAction_Update,
			Info:   groupId,
		})
		return true
	} else {
		return false
	}
}

func (sv CameraRuleService) DeleteByGroup(groupId string) bool {
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()
	if err = tx.Exec("delete from "+models.CameraRuleGroupArg{}.TableName()+" where group_id=?", groupId).Error; err != nil {
		return false
	}
	if err = tx.Exec("delete from "+models.CameraRuleGroup{}.TableName()+" where id=?", groupId).Error; err != nil {
		return false
	}
	if err = tx.Exec("delete from "+models.CameraTaskLink{}.TableName()+" where link_task_id=?", groupId).Error; err != nil {
		return false
	}

	tx.Commit()
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_CameraRule,
		Id:     groupId,
		Action: protomsg.DbAction_Delete,
		Info:   groupId,
	})
	return true
}

func (sv CameraRuleService) FindAllCameraLink() []models.CameraTaskLink {
	var model models.CameraTaskLink
	list, _ := model.FindAll()
	if list != nil {
		return list
	}
	return []models.CameraTaskLink{}
}

func (sv CameraRuleService) FindAll() []vo.CameraAndRules {

	wg := &sync.WaitGroup{}
	wg.Add(3)

	var sysconf *protomsg.LocalConfig
	go func() {
		defer wg.Done()
		var sysApi bhomedbapi.SysSetApi
		flag, sconf := sysApi.GetServerInfo()
		if flag {
			sysconf = &sconf
		}
	}()

	var clusterInfo *protomsg.ClusterAndNodes
	go func() {
		defer wg.Done()
		var clusterApi bhomedbapi.ClusterApi
		if b, info := clusterApi.FindCluster(); b {
			clusterInfo = &info
		}
	}()

	var sdkMap map[string]protomsg.Sdk
	go func() {
		defer wg.Done()
		var sdkApi bhomedbapi.SdkApi
		sdkMap = sdkApi.FindAllMap()
	}()
	wg.Wait()

	allRuleGs := make([]vo.CameraAndRules, 0)
	wg.Add(3)
	go func() {
		defer wg.Done()
		//查所有的本地摄像机
		var camApi bhomedbapi.CameraApi
		localCameras := camApi.FindAll("", "", "", "")
		logger.Debug("len(localCams):", len(localCameras))

		for _, c := range localCameras {
			var camSInfo vo.CameraSInfo
			camSInfo.Id = c.Id
			camSInfo.Name = c.Name
			camSInfo.RunType = int(c.RunType)
			camSInfo.ResolutionWidth = int(c.ResolutionWidth)
			camSInfo.ResolutionHeight = int(c.ResolutionHeight)
			camSInfo.RunServerName = sv.GetRunServerName(c.RunServerId, sysconf, clusterInfo)
			if cgs, err := sv.GetAllByCid(c.Id, "", &camSInfo, sysconf, clusterInfo, sdkMap); err == nil {
				allRuleGs = append(allRuleGs, cgs)
			}
		}
	}()

	allRuleGB := make([]vo.CameraAndRules, 0)

	go func() {
		defer wg.Done()
		var gbApi bhomedbapi.Gb28181Api
		gbCams := gbApi.FindAll("", "", "", "")
		logger.Debug("len(gbCams):", len(gbCams))

		for _, c := range gbCams {
			var camSInfo vo.CameraSInfo
			camSInfo.Id = c.Id
			camSInfo.Name = c.Name
			camSInfo.RunType = int(c.RunType)
			camSInfo.ResolutionWidth = int(c.ResolutionWidth)
			camSInfo.ResolutionHeight = int(c.ResolutionHeight)
			if cgs, err := sv.GetAllByCid(c.Id, "", &camSInfo, sysconf, clusterInfo, sdkMap); err == nil {
				allRuleGB = append(allRuleGB, cgs)
			}
		}
	}()

	//查所有的国标摄像机

	//加上数据栈
	allRuleStk := make([]vo.CameraAndRules, 0)
	go func() {
		defer wg.Done()
		var stackApi bhomedbapi.FileStackApi
		flag, scks := stackApi.FindAll()
		logger.Debug("flag:", flag, "scks:", scks)
		if flag && scks != nil {
			for _, f := range scks {
				var camSInfo vo.CameraSInfo
				camSInfo.Id = f.Id
				camSInfo.Name = f.Name
				camSInfo.RunType = bhomeclient.TYPE_RUNTYPE_REALTIME
				camSInfo.ResolutionWidth = int(f.ResolutionWidth)
				camSInfo.ResolutionHeight = int(f.ResolutionHeight)
				if sysconf != nil {
					camSInfo.RunServerName = sysconf.ServerName
				}
				if cgs, err := sv.GetAllByCid(f.Id, "", &camSInfo, sysconf, clusterInfo, sdkMap); err == nil {
					allRuleStk = append(allRuleStk, cgs)
				}
			}
		}
	}()
	wg.Wait()
	allRuleGs = append(allRuleGs, allRuleGB...)
	allRuleGs = append(allRuleGs, allRuleStk...)

	return allRuleGs
}

func (sv CameraRuleService) GetAllByCid(cid string, setType string, targetInfo *vo.CameraSInfo, sysconf *protomsg.LocalConfig, clusterInfo *protomsg.ClusterAndNodes, sdkMap map[string]protomsg.Sdk) (vo.CameraAndRules, error) {
	var crg models.CameraRuleGroup
	var rga models.CameraRuleGroupArg
	var result vo.CameraAndRules
	var camSInfo vo.CameraSInfo

	if targetInfo != nil {
		camSInfo = *targetInfo
	} else {
		if models.IsStack(cid) {
			var stackApi bhomedbapi.FileStackApi
			b, fileS := stackApi.Show(cid)
			if !b {
				return result, errors.New("数据栈已删除")
			}
			camSInfo.Id = fileS.Id
			camSInfo.Name = fileS.Name
			camSInfo.RunType = bhomeclient.TYPE_RUNTYPE_REALTIME
			camSInfo.ResolutionWidth = int(fileS.ResolutionWidth)
			camSInfo.ResolutionHeight = int(fileS.ResolutionHeight)

			if sysconf != nil {
				camSInfo.RunServerName = sysconf.ServerName
			}

		} else {
			var localCamApi bhomedbapi.CameraApi
			localCam, err := localCamApi.GetCameraById(cid)
			var targetCam *protomsg.Camera
			if localCam.Id != "" {
				logger.Debug("localCam:", localCam, "e:", err)
				targetCam = &localCam
			} else {
				var gbCamApi bhomedbapi.Gb28181Api
				gbCam, err := gbCamApi.GetCameraById(cid)
				logger.Debug("gbCam:", gbCam, " err:", err)
				if err == nil {
					targetCam = &gbCam
				}
			}

			if targetCam != nil {
				camSInfo.Id = targetCam.Id
				camSInfo.Name = targetCam.Name
				camSInfo.RunType = int(targetCam.RunType)
				camSInfo.ResolutionWidth = int(targetCam.ResolutionWidth)
				camSInfo.ResolutionHeight = int(targetCam.ResolutionHeight)
				camSInfo.RunServerName = sv.GetRunServerName(targetCam.RunServerId, sysconf, clusterInfo)
			}
		}
	}

	result.CameraInfo = camSInfo
	groupArr, err := crg.FindByCameraId(cid, setType)
	if err == nil && groupArr != nil {
		var t models.CameraTimerule
		timeMap := t.FindAllMap()
		for _, group := range groupArr {
			g := vo.GroupRuleVo{
				Id:         group.Id,
				GroupText:  group.GroupText,
				AlarmLevel: group.AlarmLevel,
				SetType:    group.SetType,
				TemplateId: group.TemplateId,
				TimeRuleId: group.TimeRuleId,
				SceneName:  group.SceneName,
				Desc:       group.Desc,
				Enable:     group.Enable,
				VoiceId:    group.VoiceId,
			}
			if g.TimeRuleId != "" {
				if t, exi := timeMap[g.TimeRuleId]; exi {
					g.TimeName = t.Name
				}
			}
			args := rga.FindByGroupId(group.Id)
			for _, argModel := range args {
				crbv := vo.CameraRuleBaseVo{
					Id:           argModel.Id,
					CameraId:     argModel.CameraId,
					SdkId:        argModel.SdkId,
					PolygonId:    argModel.PolygonId,
					RuleWithPre:  argModel.RuleWithPre,
					IsSaveAnyhow: argModel.IsSaveAnyhow,
					GroupId:      argModel.GroupId,
					Sort:         argModel.Sort,
				}
				if sdkMap != nil {
					if s, ok := sdkMap[crbv.SdkId]; ok {
						crbv.Icon = s.Icon
						crbv.IconBlob = s.IconBlob
						crbv.IconBlob2 = s.IconBlob2
					}
				}

				var setArr []vo.TemplateArg
				json.Unmarshal([]byte(argModel.SdkSet), &setArr)
				crbv.SdkSet = setArr
				g.Rules = append(g.Rules, crbv)
			}

			result.AllGroupRules = append(result.AllGroupRules, g)
		}
	}

	return result, nil
}

func (sv CameraRuleService) GetRunServerName(runServerId string, sysconf *protomsg.LocalConfig, clusterInfo *protomsg.ClusterAndNodes) string {
	var runServerName = ""

	if sysconf != nil {
		if runServerId == sysconf.ServerId {
			runServerName = sysconf.ServerName
		} else { //属于其他服务器
			if clusterInfo != nil && clusterInfo.Nodes != nil {
				for _, n := range clusterInfo.Nodes {
					if n.NodeId == runServerId {
						runServerName = n.NodeName
					}
				}
			}
		}
	}

	return runServerName
}

func (sv CameraRuleService) ExistRunningTask(cameraId string) bool {
	var rga models.CameraRuleGroupArg
	return rga.ExistRunningTask(cameraId)
}

func (sv CameraRuleService) GetLinkRulesByCameraIds(cameraIds []string) (bool, []vo.GroupRuleVo) {
	var cameraTasklinkE models.CameraTaskLink
	var rga models.CameraRuleGroupArg

	linkList, err := cameraTasklinkE.FindByCameraIds(cameraIds)
	if err != nil {
		return false, nil
	}

	resultRules := make([]vo.GroupRuleVo, 0)
	if linkList != nil {
		cameraIdNameMap := GetAllCamIdNameMap()
		var sdkApi bhomedbapi.SdkApi
		sdkMap := sdkApi.FindAllMap()
		var t models.CameraTimerule
		timeMap := t.FindAllMap()

		for _, linkModel := range linkList {
			var linkG models.CameraRuleGroup
			rows, err := linkG.SelectById(linkModel.LinkTaskId)
			if rows <= 0 || err != nil {
				continue
			}
			linkCameraIdArr := strings.Split(linkModel.CameraIds, ",")
			linkCameraNameArr := make([]string, 0)
			for _, linkCameraId := range linkCameraIdArr {
				if cameraName, ok := cameraIdNameMap[linkCameraId]; ok {
					linkCameraNameArr = append(linkCameraNameArr, cameraName)
				}
			}

			voModel := vo.GroupRuleVo{
				CameraIds:   linkCameraIdArr,
				CameraNames: strings.Join(linkCameraNameArr, ","),
				Id:          linkG.Id,
				GroupText:   linkG.GroupText,
				AlarmLevel:  linkG.AlarmLevel,
				SetType:     linkG.SetType,
				TemplateId:  linkG.TemplateId,
				TimeRuleId:  linkG.TimeRuleId,
				SceneName:   linkG.SceneName,
				Desc:        linkG.Desc,
				Enable:      linkG.Enable,
				VoiceId:     linkG.VoiceId,
			}
			if voModel.TimeRuleId != "" {
				if t, exi := timeMap[voModel.TimeRuleId]; exi {
					voModel.TimeName = t.Name
				}
			}
			argList := rga.FindByGroupId(linkG.Id)
			if argList != nil {
				for _, argModel := range argList {
					crbv := vo.CameraRuleBaseVo{
						Id:           argModel.Id,
						CameraId:     argModel.CameraId,
						SdkId:        argModel.SdkId,
						PolygonId:    argModel.PolygonId,
						RuleWithPre:  argModel.RuleWithPre,
						IsSaveAnyhow: argModel.IsSaveAnyhow,
						GroupId:      argModel.GroupId,
						Sort:         argModel.Sort,
					}
					if s, ok := sdkMap[crbv.SdkId]; ok {
						crbv.Icon = s.Icon
						crbv.IconBlob = s.IconBlob
						crbv.IconBlob2 = s.IconBlob2
					}
					var setArr []vo.TemplateArg
					json.Unmarshal([]byte(argModel.SdkSet), &setArr)
					crbv.SdkSet = setArr
					voModel.Rules = append(voModel.Rules, crbv)
				}
			}
			resultRules = append(resultRules, voModel)
		}
	}

	return true, resultRules
}

func (sv CameraRuleService) PasteRules(sourceId string, targetIds []string) bool {
	logger.Debug("PasteRules sourceId:", sourceId, "targetIds:", targetIds)
	var sdkApi bhomedbapi.SdkApi
	sdkMap := sdkApi.FindAllMap()
	sourceRules, cErr := sv.GetAllByCid(sourceId, models.Type_SetType_Batch, nil, nil, nil, sdkMap)
	if cErr != nil || sourceRules.AllGroupRules == nil || len(sourceRules.AllGroupRules) == 0 {
		logger.Debug("PasteRules sourceRules is nil")
		return false
	}

	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()

	var cpgn models.CameraPolygon
	polygonMap := cpgn.FindAllMap()

	cameraMap := GetAllCamIdNameMap()

	for _, tId := range targetIds {
		if tId != sourceId {
			for _, targetG := range sourceRules.AllGroupRules {
				newGId := uuid.NewV4().String()
				//处理每一组规则
				//1.如果是全部区域，则copy过来之后也用目标摄像机的全部区域
				//2.如果不是全部区域，则将区域置为空，并将对应的区域文字也置为NULL
				var repNullPolygon = make(map[string]models.CameraPolygon, 0)
				for sort, baseRule := range targetG.Rules {
					rulePolygonId := ""
					if baseRule.PolygonId != "" { //判断此条规则有没有设置区域
						if _, ok := cameraMap[baseRule.PolygonId]; ok { //是全部区域
							rulePolygonId = tId
						} else { //非全部区域
							if targetP, okP := polygonMap[baseRule.PolygonId]; okP {
								//是从其他摄像机拷贝过来的规则
								//不需要拷贝区域，置为空，区域名称替换
								rulePolygonId = ""
								repNullPolygon[baseRule.PolygonId] = targetP
							}
						}
					}

					rga := models.CameraRuleGroupArg{
						Id: uuid.NewV4().String(),
					}
					rga.CameraRuleBase = models.CameraRuleBase{
						CameraId:     tId,
						SdkId:        baseRule.SdkId,
						PolygonId:    rulePolygonId,
						RuleWithPre:  baseRule.RuleWithPre,
						IsSaveAnyhow: baseRule.IsSaveAnyhow,
						Sort:         sort,
					}
					setB, _ := json.Marshal(baseRule.SdkSet)
					rga.SdkSet = string(setB)
					rga.GroupId = newGId
					if err = tx.Table(rga.TableName()).Create(&rga).Error; err != nil {
						return false
					}
				}

				crg := models.CameraRuleGroup{
					Id:         newGId,
					GroupText:  targetG.GroupText,
					SetType:    "batchTask",
					AlarmLevel: targetG.AlarmLevel,
					TemplateId: targetG.TemplateId,
					TimeRuleId: targetG.TimeRuleId,
					SceneName:  targetG.SceneName,
					Desc:       targetG.Desc,
					Enable:     true,
					VoiceId:    targetG.VoiceId,
				}
				logger.Debug("repNullPolygon len:", len(repNullPolygon))
				if len(repNullPolygon) > 0 {
					for _, tp := range repNullPolygon {
						logger.Debug("repNullPolygon name:", tp.Name)
						reg := regexp.MustCompile(`(` + tp.Name + `)`)
						crg.GroupText = reg.ReplaceAllString(crg.GroupText, `<span style="color:RGB(255,0,0);">NULL</span>`)
					}
				}

				if err = tx.Table(crg.TableName()).Create(&crg).Error; err != nil {
					return false
				}
			}
		}
	}

	tx.Commit()
	//发布缓存更改通知
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_Camera,
		Action: protomsg.DbAction_Update,
	})
	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_CameraPolygon,
		Action: protomsg.DbAction_Update,
	})

	sv.addDbMessage(&protomsg.DbChangeMessage{
		Table:  protomsg.TableChanged_T_CameraRule,
		Action: protomsg.DbAction_Insert,
	})
	return true
}

func (sv CameraRuleService) FindLinksByCameraIds(camIds []string) []models.CameraTaskLink {
	var ctl models.CameraTaskLink
	list, err := ctl.FindByCameraIds(camIds)
	if err != nil {
		return []models.CameraTaskLink{}
	}
	return list
}

func GetAllCamIdNameMap() map[string]string {
	m := make(map[string]string)
	var camApi bhomedbapi.CameraApi

	localCams := camApi.FindAll("", "", "", "")

	if localCams != nil {
		for _, c := range localCams {
			m[c.Id] = c.Name
		}
	}

	var gbApi bhomedbapi.Gb28181Api
	gbCams := gbApi.FindAll("", "", "", "")
	if gbCams != nil {
		for _, c := range gbCams {
			m[c.Id] = c.Name
		}
	}

	var sckApi bhomedbapi.FileStackApi
	_, scks := sckApi.FindAll()
	if scks != nil {
		for _, sck := range scks {
			m[sck.Id] = sck.Name
		}
	}
	return m
}

func (sv CameraRuleService) addDbMessage(msg *protomsg.DbChangeMessage) {
	b, _ := json.Marshal(*msg)
	sv.Broker.Publish(ProcName, b)
}