package main

import (
	"context"
	"unsafe"

	"basic.com/libgowrapper/sdkhelper.git"
	"basic.com/valib/gogpu.git"

	"basic.com/pubsub/protomsg.git"

	"basic.com/valib/deliver.git"
	"github.com/gogo/protobuf/proto"
)

type reid struct {
	handle   *ReID
	fnLogger func(...interface{})

	gpu int
	ipc string
}

// Create Reid
func Create(config string, typ, id string, gpu int, shm bool, ipc2Rule string, ruleMaxSize int, fn func(...interface{}), reserved map[string]interface{}) interface{} {

	cfg, err := sdkhelper.ReadConfig(config)
	if err != nil {
		fn("Reid SDK Create Error When Read Config: ", err)
		return nil
	}

	sModel, sGPU, sIPC :=
		"reid-model",
		"gpu-memory",
		"ipc-url"

	params := []string{sModel, sGPU, sIPC}

	for _, v := range params {
		if _, ok := cfg.Param[v]; !ok {
			fn("Reid SDK Create Error Because of Param Not Found: ", v)
			return nil
		}
	}

	gpuM := sdkhelper.Atoi(cfg.Param[sGPU])

	rGPU := gpu

	if rGPU == -1 {
		rGPU = gogpu.ValidGPU(gpuM + 512)
	}

	handle := NewSDK(rGPU, cfg.Param[sModel])
	if handle == nil {
		fn("Reid SDK Create Error When New SDK")
		return nil
	}

	return &reid{
		handle:   handle,
		fnLogger: fn,

		gpu: rGPU,
		ipc: cfg.Param[sIPC],
	}
}

// Run run
func Run(ctx context.Context, i interface{}) {
	s := i.(*reid)

	c := deliver.NewClient(deliver.ReqRep, s.ipc)

	var msg []byte
	var err error

	for {
		select {
		case <-ctx.Done():
			return
		default:

			msg, err = c.Recv()
			if err != nil {
				continue
			}

			i := &protomsg.Image{}
			err := proto.Unmarshal(msg, i)
			if err != nil {
				s.fnLogger("REID~~~~~~protobuf decode CameraImage error: ", err)
				continue
			}
			if i.Data == nil {
				s.fnLogger("REID~~~~~~protomsg.Image data null")
				continue
			}
			s.fnLogger("REID~~~~~~Recv Image:", len(i.Data))

			feat := s.handle.Extract2(unsafe.Pointer(&i.Data[0]), int(i.Width), int(i.Height), 3)
			if feat == nil {
				// feat = make([]float32, 1)
			} else {
				for k := 0; k < 3; k++ {
					s.fnLogger("REID~~~~~~extractor---human_feats------%f", feat[k+2000])
				}
				s.fnLogger("REID~~~~~~Run Reid Use GPU: ", s.gpu)
			}
			buf := float32SliceAsByteSlice(feat)
			c.Send(buf)
		}

	}
}

func float32SliceAsByteSlice(src []float32) []byte {
	if len(src) == 0 {
		return nil
	}

	l := len(src) * 4
	ptr := unsafe.Pointer(&src[0])
	return (*[1 << 26]byte)((*[1 << 26]byte)(ptr))[:l:l]
}