package service

import (
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/bhomeclient.git"
	"basic.com/valib/bhomedbapi.git"
	"encoding/json"
	"errors"
	"github.com/satori/go.uuid"
	"vamicro/extend/util"
	"vamicro/push-service/models"
	"vamicro/push-service/vo"
	sysModel "vamicro/system-service/models"
)

type EventPushService struct {
	bk bhomeclient.Broker
}

const (
	ProcName = "push-service"
)

func NewEventPushService(broker bhomeclient.Broker) *EventPushService {
	return &EventPushService{
		bk: broker,
	}
}

func (sv EventPushService) FindAll(name string) (bool, []models.EventPush) {
	var epE models.EventPush
	return epE.FindAll(name)
}

func (sv EventPushService) FindAllDetails() []vo.EventPushVo {
	var epE models.EventPush
	flag, list := epE.FindAll("")
	if flag {
		all := make([]vo.EventPushVo, 0)
		for _, ep := range list {
			b, pushVo := sv.GetById(ep.Id)
			if b {
				all = append(all, pushVo)
			}
		}
		return all
	}
	return nil
}

func (sv EventPushService) Save(body *vo.EventPushVo) bool {
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()

	dbAction := protomsg.DbAction_Insert
	eventPushE := body.CopyToEventPush()
	//事件推送名称不能重复
	var et models.EventPush
	er, _ := et.Exist(eventPushE.Name)
	if eventPushE.Id != "" { //更新
		if er > 0 && et.Id != eventPushE.Id {
			err = errors.New("名称不允许重复")
			return false
		}
		//先删除此事件的相关信息
		if err = tx.Exec("delete from event_push_server where event_push_id=?", eventPushE.Id).Error; err != nil {
			return false
		}
		if err = tx.Exec("delete from event_push_rule where event_push_id=?", eventPushE.Id).Error; err != nil {
			return false
		}
		data := util.Struct2Map(eventPushE)
		if err = tx.Table("event_push").Where("id=?", eventPushE.Id).Updates(data).Error; err != nil {
			return false
		}
		dbAction = protomsg.DbAction_Update
	} else { //新增
		if er > 0 {
			err = errors.New("名称不允许重复")
			return false
		}
		eventPushE.Id = uuid.NewV4().String()
		if err = tx.Table("event_push").Create(&eventPushE).Error; err != nil {
			return false
		}
	}
	body.Id = eventPushE.Id

	for _, ipPortVo := range body.IpPorts {
		var ipPortE = models.EventPushServer{
			Id:          uuid.NewV4().String(),
			Enable:      ipPortVo.Enable,
			ServerIp:    ipPortVo.ServerIp,
			Port:        ipPortVo.Port,
			Type:        models.PUSH_IP_PORT_TYPE,
			EventPushId: eventPushE.Id,
		}
		if err = tx.Table("event_push_server").Create(&ipPortE).Error; err != nil {
			return false
		}
	}
	for _, urlVo := range body.Urls {
		var urlE = models.EventPushServer{
			Id:          uuid.NewV4().String(),
			Enable:      urlVo.Enable,
			Url:         urlVo.Url,
			Type:        models.PUSH_URL_TYPE,
			EventPushId: eventPushE.Id,
		}
		if err = tx.Table("event_push_server").Create(&urlE).Error; err != nil {
			return false
		}
	}

	for _, rule := range body.Rules {
		rule.Id = uuid.NewV4().String()
		rule.EventPushId = eventPushE.Id
		if err = tx.Table("event_push_rule").Create(&rule).Error; err != nil {
			return false
		}
	}
	tx.Commit()
	sv.addDbChangeMsg(protomsg.TableChanged_T_EventPush, eventPushE.Id, dbAction, "")
	return true
}

func (sv EventPushService) FindByEventTopic(topic string, childType string) (list []vo.KeyValueVo, err error) {
	list = append(list, vo.KeyValueVo{
		Value: "all*all",
		Name:  "全部",
	})
	var dicApi bhomedbapi.DicApi
	switch topic {
	case sysModel.EVENTRULETOPIC_CAMERA:
		if childType == sysModel.EVENTRULETOPIC_CAMERA_NAME {
			var camApi bhomedbapi.CameraApi
			localCams := camApi.FindAll("", "", "", "")
			if localCams != nil {
				for _, camE := range localCams {
					list = append(list, vo.KeyValueVo{
						Value: camE.Name,
						Name:  camE.Name,
					})
				}
			}

			var gbApi bhomedbapi.Gb28181Api
			gbCams := gbApi.FindAll("", "", "", "")
			if gbCams != nil {
				for _, c := range gbCams {
					list = append(list, vo.KeyValueVo{
						Value: c.Name,
						Name:  c.Name,
					})
				}
			}
		} else if childType == sysModel.EVENTRULETOPIC_CAMERA_ADDR {
			var camApi bhomedbapi.CameraApi
			localCams := camApi.FindAll("", "", "", "")
			if localCams != nil {
				for _, camE := range localCams {
					list = append(list, vo.KeyValueVo{
						Value: camE.Addr,
						Name:  camE.Addr,
					})
				}
			}

			var gbApi bhomedbapi.Gb28181Api
			gbCams := gbApi.FindAll("", "", "", "")
			if gbCams != nil {
				for _, c := range gbCams {
					list = append(list, vo.KeyValueVo{
						Value: c.Addr,
						Name:  c.Addr,
					})
				}
			}
		}
	case sysModel.EVENTRULETOPIC_DBTABLE:
		list = append(list, vo.KeyValueVo{
			Value: "null*null",
			Name:  "空",
		})
		//查找底库列表
		var dbtApi bhomedbapi.DbTableApi
		dbtList, _ := dbtApi.FindAllDbTablesByCurServer("0")
		if dbtList != nil {
			for _, dt := range dbtList {
				list = append(list, vo.KeyValueVo{
					Value: dt.Id,
					Name:  dt.TableName,
				})
			}
		}
	case sysModel.EVENTRULETOPIC_TASK:
		//查找任务列表
		//var taskE models.Task
		//tasks, err := taskE.FindAll()
		//if err !=nil{
		//	return nil,err
		//}
		//for _,taskE :=range tasks {
		//	list = append(list,vo.KeyValueVo{
		//		Value:taskE.Taskid,
		//		Name:taskE.Taskname,
		//	})
		//}

	case sysModel.EVENTRULETOPIC_PERSON:
		var flag bool
		var dics []protomsg.Dic
		if childType == sysModel.EVENTRULETOPIC_PERSON_MONITORLEVEL {
			flag, dics = dicApi.ListByType(sysModel.TYPE_MONITORLEVEL)
		} else if childType == sysModel.EVENTRULETOPIC_PERSON_AGE {
			flag, dics = dicApi.ListByType(sysModel.TYPE_AGEDESC)
		} else if childType == sysModel.EVENTRULETOPIC_PERSON_SEX {
			flag, dics = dicApi.ListByType(sysModel.TYPE_PERSONSEX)
		} else if childType == sysModel.EVENTRULETOPIC_PERSON_RACE {
			flag, dics = dicApi.ListByType(sysModel.TYPE_PERSONRACE)
		}
		if !flag {
			return nil, errors.New("listByType ret false")
		}
		for _, d := range dics {
			list = append(list, vo.KeyValueVo{
				Value: d.Value,
				Name:  d.Name,
			})
		}
	case sysModel.EVENTRULETOPIC_ALARMLEVEL:
		b, dcs := dicApi.ListByType(sysModel.TYPE_ALARMLEVEL)
		if !b {
			return nil, errors.New("listByType ret false")
		}
		for _, d := range dcs {
			list = append(list, vo.KeyValueVo{
				Value: d.Value,
				Name:  d.Name,
			})
		}
	}
	return list, nil
}

func (sv EventPushService) GetById(id string) (bool, vo.EventPushVo) {
	var resultVo = vo.EventPushVo{}
	var epE models.EventPush
	var eps models.EventPushServer
	var epr models.EventPushRule
	if flag, err := epE.GetById(id); !flag && err == nil {
		resultVo.CopyFromEventPush(&epE)
		if serverList, err := eps.FindByEventPushId(epE.Id); err == nil {
			for _, pushServer := range serverList {
				if pushServer.Type == models.PUSH_IP_PORT_TYPE {
					resultVo.IpPorts = append(resultVo.IpPorts, vo.EventPushServerPortVo{
						ServerIp: pushServer.ServerIp,
						Port:     pushServer.Port,
						Enable:   pushServer.Enable,
					})
				} else if pushServer.Type == models.PUSH_URL_TYPE {
					resultVo.Urls = append(resultVo.Urls, vo.EventUrlVo{
						Enable: pushServer.Enable,
						Url:    pushServer.Url,
					})
				}
			}
		} else {
			resultVo.IpPorts = []vo.EventPushServerPortVo{}
			resultVo.Urls = []vo.EventUrlVo{}
		}
		if ruleList, err := epr.FindByEventPushId(epE.Id); err == nil {
			for _, ruleE := range ruleList {
				resultVo.Rules = append(resultVo.Rules, ruleE)
			}
		} else {
			resultVo.Rules = []models.EventPushRule{}
		}

		resultVo.SetFiltRename()
	} else {
		return false, resultVo
	}
	return true, resultVo
}

func (sv EventPushService) ChangeStatus(id string, enable bool) bool {
	var epE models.EventPush
	if epE.ChangeStatus(id, enable) {
		sv.addDbChangeMsg(protomsg.TableChanged_T_EventPush, id, protomsg.DbAction_Update, "")
		return true
	}
	return false
}

func (sv EventPushService) DeleteById(id string) bool {
	var err error
	tx := models.GetDB().Begin()
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()
	if err = tx.Exec("delete from event_push_server where event_push_id=?", id).Error; err != nil {
		return false
	}
	if err = tx.Exec("delete from event_push_rule where event_push_id=?", id).Error; err != nil {
		return false
	}
	if err = tx.Exec("delete from event_push where id=?", id).Error; err != nil {
		return false
	}
	tx.Commit()
	sv.addDbChangeMsg(protomsg.TableChanged_T_EventPush, id, protomsg.DbAction_Delete, "")
	return true
}

func (sv EventPushService) addDbChangeMsg(tChanged protomsg.TableChanged, id string, action protomsg.DbAction, info string) {
	dbMsg := protomsg.DbChangeMessage{
		Table:  tChanged,
		Id:     id,
		Action: action,
		Info:   info,
	}
	pb, _ := json.Marshal(dbMsg)
	sv.bk.Publish(ProcName, pb)
}