package service

import (
	"basic.com/pubsub/protomsg.git"
	"errors"
	"github.com/satori/go.uuid"
	"strconv"
	"vamicro/compTable-service/models"
	"vamicro/compTable-service/vo"
	"vamicro/config"
)

type DbTablePersonService struct {
}

func (sv DbTablePersonService) Add(dbp models.Dbtablepersons) (bool, error) {
	//车牌号不能重复
	var dt models.Dbtables
	rows, _ := dt.SelectById(dbp.TableId)
	if rows == 0 {
		return false, errors.New("所属底库已不存在")
	}
	if dt.TableType == "car" {
		var tmp models.Dbtablepersons
		i, _ := tmp.SelectByCarNo(dbp.TableId, dbp.CarNo)
		if i > 0 {
			return false, errors.New("车牌号不允许重复")
		}
	}
	return dbp.Add()
}

func (sv DbTablePersonService) Update(dbp models.Dbtablepersons) (bool, error) {
	//车牌号不能重复
	var dt models.Dbtables
	rows, _ := dt.SelectById(dbp.TableId)
	if rows == 0 {
		return false, errors.New("所属底库已不存在")
	}
	if dt.TableType == "car" {
		var tmp models.Dbtablepersons
		i, _ := tmp.SelectByCarNo(dbp.TableId, dbp.CarNo)
		if i > 0 && tmp.Id != dbp.Id {
			return false, errors.New("车牌号不允许重复")
		}
	}
	return dbp.Update()
}

func (sv DbTablePersonService) DeleteById(id string) (bool, error) {
	var dbp models.Dbtablepersons
	return dbp.DeleteById(id)
}

func (sv DbTablePersonService) UpdateFace(arg *vo.FaceUpdateVo) (bool, error) {
	var dbp models.Dbtablepersons
	return dbp.UpdateFace(arg.Id, arg.FaceFeature, arg.PersonPicUrl)
}

func (sv DbTablePersonService) SelectById(id string) (dbp models.Dbtablepersons, err error) {
	var dbpE models.Dbtablepersons
	rows, err := dbpE.SelectById(id)
	if rows > 0 && err == nil {
		return dbpE, nil
	}
	return dbp, errors.New("dbtableperson not found")
}

func (sv DbTablePersonService) FindByPersonIds(ids []string) (arr []models.Dbtablepersons, err error) {
	var dbp models.Dbtablepersons
	return dbp.FindByPersonIds(ids)
}

func (sv DbTablePersonService) DeleteByPersonIds(ids []string) (b bool, err error) {
	n := len(ids)
	k := 0
	for _, id := range ids {
		b, _ := sv.DeleteById(id)
		if b {
			k++
		}
	}
	if n == k {
		return true, nil
	} else {
		return false, errors.New("delete persons err")
	}
	//return dbp.DeleteByPersonIds(ids)
}

func (sv DbTablePersonService) DeletePersonsByTbId(tableId string) (bool, error) {
	var dbp models.Dbtablepersons
	return dbp.DeletePersonsByTbId(tableId)
}

func (sv DbTablePersonService) FindPersons(tableId string, orderName string, orderType string, contentValue string, from int, size int) ([]models.Dbtablepersons, error) {
	var dbp models.Dbtablepersons
	return dbp.FindPersons(tableId, orderName, orderType, contentValue, from, size)
}

func (sv DbTablePersonService) GetPersonTotal(tableId string) (total int64, err error) {
	var dbp models.Dbtablepersons
	return dbp.GetPersonTotal(tableId)
}

func (sv DbTablePersonService) GetPersonsCompareCacheBase(from int, size int) (arr []vo.FeatureCacheBase, err error) {
	var persons []models.Dbtablepersons
	sql := "select id,faceFeature,tableId,enable,carNo from dbtablepersons where isDelete=0 and tableId in (select id from dbtables where isDelete=0)"
	sql += " order by id asc limit " + strconv.Itoa(from) + "," + strconv.Itoa(size)
	err = models.GetDB().Raw(sql).Find(&persons).Error
	if err != nil {
		return nil, err
	}
	for _, p := range persons {
		if p.FaceFeature != "" {
			arr = append(arr, vo.FeatureCacheBase{
				Id:          p.Id,
				TableId:     p.TableId,
				FaceFeature: p.FaceFeature,
				Enable:      int32(p.Enable),

				CarNo: p.CarNo,
			})
		}
	}
	return
}

func (sv DbTablePersonService) JoinDbTable(tableIds []string, faceFeature string, pic string) bool {
	var flag = false
	for _, tableId := range tableIds {
		var dbp = new(models.Dbtablepersons)
		dbp.Id = uuid.NewV4().String()
		dbp.TableId = tableId
		dbp.FaceFeature = faceFeature
		dbp.PersonPicUrl = pic
		dbp.Enable = 1
		dbp.PriInsert()
		dbp.FromServerId = config.Server.AnalyServerId //入库位置
		b, _ := dbp.Add()
		if b {
			flag = true
		}
	}
	return flag
}

func (sv DbTablePersonService) Move(personId string, tableIds []string) bool {
	if len(tableIds) != 1 {
		return false
	}
	tableId := tableIds[0]

	var dtTmp models.Dbtables
	var dbpTmp models.Dbtablepersons
	r0, _ := dbpTmp.SelectById(personId)
	r1, _ := dtTmp.SelectById(tableId)

	if r0 > 0 && r1 > 0 {
		if dbpTmp.TableId == tableId { //本库移动不做操作
			return true
		}
		var oldDt models.Dbtables
		r2, _ := oldDt.SelectById(dbpTmp.TableId)
		if r2 > 0 {
			//移动到其他底库
			dbpTmp.TableId = tableId
			if b, _ := dbpTmp.Update(); b {
				go models.SyncSdkCompareCache(oldDt.AnalyServerId, protomsg.EsCacheChanged_T_DbTablePerson, oldDt.Id, personId, "", protomsg.DbAction_Delete, 0, "")
				return true
			}
		}

	}
	return false
}

func (sv DbTablePersonService) Copy(personId string, tableIds []string) bool {
	var dbpTmp models.Dbtablepersons
	r, _ := dbpTmp.SelectById(personId)
	if r > 0 {
		for _, tableId := range tableIds {
			dbpTmp.Id = uuid.NewV4().String()
			dbpTmp.TableId = tableId
			dbpTmp.Add()
		}
		return true
	}
	return false
}

func (sv DbTablePersonService) MultiUploadCardNo(tableId string, carNos []string) bool {
	var dbpTmp models.Dbtablepersons
	b := false
	for _, no := range carNos {
		rows, err := dbpTmp.SelectByCarNo(tableId, no)
		if err == nil && rows == 0 {
			if dbpTmp.InsertCarNo(tableId, no) {
				b = true
			}
		}
	}

	return b
}