package repository

import (
	"encoding/base64"
	"encoding/json"
	"gat1400Exchange/client"
	"time"

	"gat1400Exchange/config"
	"gat1400Exchange/models"
	"gat1400Exchange/pkg/logger"
	"gat1400Exchange/util"
	"gat1400Exchange/vo"

	uuid "github.com/satori/go.uuid"
)

type CaptureRepository struct {
}

func NewCaptureRepository() CaptureRepository {
	return CaptureRepository{}
}

func (c CaptureRepository) FaceForward(faceList []vo.FaceObject) {
	var err error

	if faceList == nil || len(faceList) == 0 {
		logger.Warn("FaceList is nil")
		return
	}

	for _, face := range faceList {
		if face.SubImageList.SubImageInfoObject == nil {
			logger.Warn("SubImageInfoObject is nil")
			continue
		}

		var deviceId = face.DeviceID
		var faceId = face.FaceID
		var bgImageStr, imageType string
		var bgImageBytes, faceImageBytes []byte = nil, nil

		// 获取大图, 目前海康的小图分辨率太低
		for _, image := range face.SubImageList.SubImageInfoObject {
			if len(image.Data) > len(bgImageStr) {
				bgImageStr = image.Data
				imageType = image.Type
			}
		}

		bgImageBytes, err = base64.StdEncoding.DecodeString(bgImageStr)
		if err != nil {
			logger.Warn("Decode Image Base64 String failure, %s", err.Error())
			continue
		}

		// 判断图片类型是否为场景图, 根据人脸坐标切小图.
		if imageType == "14" && config.ForwardConf.CutFaceImage {
			faceRect := &vo.Rect{
				Left:   face.LeftTopX,
				Top:    face.LeftTopY,
				Right:  face.RightBtmX,
				Bottom: face.RightBtmY,
			}

			faceImageBytes, err = util.SubCutImg(bgImageBytes, faceRect, 90)
			if err != nil {
				logger.Warn("Cut face image failure, %s", err.Error())
			}
		}

		// 转发图像
		logger.Debug("Prepare forward image, deviceId:%s, image len:%d, server:%s", deviceId, len(bgImageStr), config.ForwardConf.SyncServer)
		if deviceId != "" && bgImageStr != "" && config.ForwardConf.SyncServer != "" {
			pd := c.PackPushDataV2(deviceId, faceId, face.FaceAppearTime, bgImageBytes, faceImageBytes)
			if pd == nil {
				return
			}

			// 部署在服务端的1400代理, 仅接收1400信息, 楼层信息暂存在oherFeature字段
			if config.ServeConf.Role == "proxy" {
				if face.OtherFeature != "" {
					pd.CameraFloor = face.OtherFeature
				}
			}

			payload, err := json.Marshal(pd)
			if err != nil {
				logger.Warn("Marshal error, %s", err.Error())
				return
			}

			if !util.SendData(payload, config.ForwardConf.SyncServer) {
				cacheItem, _ := json.Marshal(pd)
				c.CacheData(cacheItem, "basic")
				logger.Warn("The data forwarding failed, adding to local cache.")
			} else {
				logger.Debug("The data forwarding successful. deviceId:%s", deviceId)
			}
		}
	}

	return
}

func (c CaptureRepository) PackPushData(deviceId, faceId, faceImage, appearTime string) *vo.PushDataInfo {
	var pd = new(vo.PushDataInfo)
	var device models.Device

	if err := device.FindById(deviceId); err != nil {
		logger.Warn("Can't find device in database, device:%s, %s", deviceId, err.Error())
		return pd
	}

	// 匹配楼层
	faceAppearTime, err := time.ParseInLocation("20060102150405", appearTime, time.Local)
	if err != nil {
		logger.Warn("Parse face appear time error, %s", err.Error())
		faceAppearTime = time.Now()
	}

	// 电梯停止的时间
	devStopTime := time.Now().Format("2006-01-02 15:04:05")
	var devPos models.Positions
	_ = devPos.FindDevicePosition(deviceId, faceAppearTime.Unix()+5) // 加5秒电梯关门的时间
	if devPos.TimeString != "" {
		devStopTime = devPos.TimeString
	}

	imageBytes, err := base64.StdEncoding.DecodeString(faceImage)
	if err != nil {
		logger.Warn("Decode Image Base64 String failure, %s", err.Error())
		return pd
	}

	pd.PicMaxImages = append(pd.PicMaxImages, imageBytes)

	tr := vo.TaskResultInfo{
		Id:            uuid.NewV4().String(),
		CameraId:      deviceId,
		CameraAddr:    device.Addr + devPos.Pos,
		CameraName:    device.Name,
		PicMaxUrl:     []string{""},
		PicDate:       faceAppearTime.Format("2006-01-02 15:04:05"),
		LikeDate:      devStopTime,
		AnalyServerId: deviceId,
		DataSource:    "camera",
		TargetInfo:    []vo.TargetInfo{{TargetId: faceId}},
	}

	pd.SourceData = vo.ESInfo{
		TaskResultInfo: tr,
		Version:        "3.3",
		UpdateTime:     time.Now().Format("2006-01-02 15:04:05"),
	}

	return pd
}

func (c CaptureRepository) PackPushDataV2(deviceId, faceId, appearTime string, bgImgBytes, faceImgBytes []byte) *vo.PushDataInfoV2 {
	var pd = new(vo.PushDataInfoV2)
	var floor string

	faceAppearTime, err := time.ParseInLocation("20060102150405", appearTime, time.Local)
	if err != nil {
		logger.Warn("Parse face appear time error, %s", err.Error())
		faceAppearTime = time.Now()
	}

	if config.ServeConf.Role == "server" {
		var device models.Device

		if err := device.FindById(deviceId); err != nil {
			logger.Warn("Can't find device in database, device:%s, %s", deviceId, err.Error())
			return pd
		}

		// 匹配楼层
		var devPos models.Positions
		_ = devPos.FindDevicePosition(deviceId, faceAppearTime.Unix()+5) // 加5秒电梯关门的时间
		if devPos.Pos == "" {
			devPos.Pos = device.Floor
		}

		floor = devPos.Pos
	}

	pd.PicMaxImages = append(pd.PicMaxImages, bgImgBytes)

	if faceImgBytes != nil {
		pd.PicSmImages = append(pd.PicSmImages, faceImgBytes)
	}

	pd.PicId = faceId
	pd.PicDate = faceAppearTime.Format("2006-01-02 15:04:05")
	pd.DataSource = "camera"
	pd.CameraFloor = floor
	pd.CameraId = deviceId

	return pd
}

func (c CaptureRepository) CacheData(payload []byte, msgType string) {
	var cacheItem = models.Cache{
		Type:       msgType,
		Data:       string(payload),
		CreateTime: time.Now().Unix(),
		Retry:      0,
	}

	cacheItem.Save()
}

func (c CaptureRepository) VIIDMsgForward(msg *vo.RequestFaceList) {
	faceInfo := msg.FaceListObject.FaceObject[0]
	// 匹配楼层
	faceAppearTime, err := time.ParseInLocation("20060102150405", faceInfo.FaceAppearTime, time.Local)
	if err != nil {
		logger.Warn("Parse face appear time error, %s", err.Error())
		faceAppearTime = time.Now()
	}

	var devPos models.Positions
	_ = devPos.FindPositionByTime(faceAppearTime.Unix() + 5) // 加5秒电梯关门的时间
	if devPos.Pos == "" {
		devPos.Pos = "1F"
	}

	for idx, _ := range msg.FaceListObject.FaceObject {
		msg.FaceListObject.FaceObject[idx].OtherFeature = devPos.Pos
	}

	b, _ := json.Marshal(msg)
	if client.FaceCapture(b) != vo.StatusSuccess {
		cacheItem, _ := json.Marshal(msg)
		c.CacheData(cacheItem, "1400")
		logger.Warn("The data forwarding failed, adding to local cache.")
	}

	return
}