package main

import (
	"context"
	"sync"
	"time"

	"basic.com/libgowrapper/sdkhelper.git"

	"basic.com/libgowrapper/sdkstruct.git"
	"basic.com/pubsub/protomsg.git"
	"basic.com/valib/gogpu.git"
)

type face struct {
	handle *SDKFace

	maxChannel      int
	ftrackChans     map[string]chan protomsg.SdkMessage
	ftrackChannels  map[string]int
	ftrackChanStats []bool
	chnLock         sync.Mutex

	fnLogger func(...interface{})

	typ                 string
	id                  string
	shm                 bool
	ipc2Rule            string
	ruleMsgMaxCacheSize int
	reserved            map[string]interface{}
}

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

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

	// 此处与传入的配置文件param必须一一对应,否则出错
	dt, dn, da, pt, et, ti, ts, mc, gm :=
		"detect_thread",
		"detect_num",
		"detect_angle",
		"property_thread",
		"extract_thread",
		"track_interval",
		"track_sample",
		"max_channel",
		"gpu-memory"

	params := []string{dt, dn, da, pt, et, ti, ts, mc, gm}

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

	w, h, detThrd, detNum, detAngle, propThrd, extThrd, trckInterval, trckSmpl, maxChan, gpuM :=
		1280, 720, sdkhelper.Atoi(cfg.Param[dt]), sdkhelper.Atoi(cfg.Param[dn]), sdkhelper.Atoi(cfg.Param[da]),
		sdkhelper.Atoi(cfg.Param[pt]), sdkhelper.Atoi(cfg.Param[et]), sdkhelper.Atoi(cfg.Param[ti]), sdkhelper.Atoi(cfg.Param[ts]),
		sdkhelper.Atoi(cfg.Param[mc]), sdkhelper.Atoi(cfg.Param[gm])

	if detAngle > 0 {
	}

	rGPU := gpu

	if rGPU == -1 {
		rGPU = gogpu.ValidGPU(gpuM + 512)
	}
	if rGPU == -1 {
		fn("Face SDK Create Error When Find GPU")
		return nil
	}

	if !handle.Tracker(w, h, detNum, trckInterval, trckSmpl, detThrd, rGPU) {
		fn("Face SDK Create Error When Init Tracker")
		return nil
	}
	if !handle.Extractor(extThrd, rGPU) {
		fn("Face SDK Create Error When Init Extractor")
		return nil
	}

	if !handle.Propertizer(propThrd) {
		fn("Face SDK Create Error When Init Propertizer")
		return nil
	}

	return &face{
		handle: handle,

		maxChannel:      maxChan,
		ftrackChans:     make(map[string]chan protomsg.SdkMessage, maxChan),
		ftrackChannels:  make(map[string]int, maxChan),
		ftrackChanStats: make([]bool, maxChan, maxChan),

		fnLogger: fn,

		typ:                 typ,
		id:                  id,
		shm:                 shm,
		ipc2Rule:            ipc2Rule,
		ruleMsgMaxCacheSize: ruleMaxSize,
		reserved:            reserved,
	}
}

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

	const (
		postPull = `_1`
		postPush = `_2`
	)
	ipcRcv := sdkhelper.GetIpcAddress(s.shm, s.id+postPull)
	ipcSnd := sdkhelper.GetIpcAddress(s.shm, s.id+postPush)
	chRcv := make(chan []byte)
	chSnd := make(chan sdkstruct.MsgSDK)

	rcver := sdkhelper.NewReciever(ipcRcv, chRcv, s.shm, s.fnLogger)
	snder := sdkhelper.NewSender(ipcSnd, chSnd, s.shm, s.fnLogger)
	torule := sdkhelper.NewToRule(s.ipc2Rule, s.ruleMsgMaxCacheSize, s.fnLogger)

	snder.ApplyCallbackFunc(torule.Push)

	go rcver.Run(ctx)
	go snder.Run(ctx)
	go torule.Run(ctx)

	go s.run(ctx, chRcv, chSnd)
}

//////////////////////////////////////////////////////////////////
const (
	cacheFrameNum   = 3
	trackChnTimeout = time.Duration(10)
)

func (f *face) cleanChnStat() {
	f.chnLock.Lock()
	for i := 0; i < f.maxChannel; i++ {
		f.ftrackChanStats[i] = false
	}
	f.chnLock.Unlock()
}

func (f *face) getAvailableChn() int {
	f.chnLock.Lock()
	defer f.chnLock.Unlock()

	for i := 0; i < f.maxChannel; i++ {
		if f.ftrackChanStats[i] == false {
			f.ftrackChanStats[i] = true
			return i
		}
	}
	return -1
}

func (f *face) releaseChn(chn int) {
	f.chnLock.Lock()
	f.ftrackChanStats[chn] = false
	f.chnLock.Unlock()
}

func (f *face) run(ctx context.Context, in <-chan []byte, out chan<- sdkstruct.MsgSDK) {

	chMsg := make(chan protomsg.SdkMessage)
	go sdkhelper.UnserilizeProto(ctx, in, chMsg, f.fnLogger)

	for {
		select {
		case <-ctx.Done():
			f.handle.Free()
			return
		case rMsg := <-chMsg:
			if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
				f.fnLogger("FACE TRACK VALIDREMOTEMESSAGE INVALID")
				sdkhelper.EjectResult(nil, rMsg, out)
				continue
			}

			if _, ok := f.ftrackChans[rMsg.Cid]; ok {
				f.ftrackChans[rMsg.Cid] <- rMsg
			} else {

				f.ftrackChans[rMsg.Cid] = make(chan protomsg.SdkMessage, cacheFrameNum)
				chn := f.getAvailableChn()
				if chn < 0 {
					f.fnLogger("TOO MUCH CHANNEL")
					sdkhelper.EjectResult(nil, rMsg, out)
					continue
				}
				f.ftrackChannels[rMsg.Cid] = chn

				i := sdkhelper.UnpackImage(rMsg, f.typ, f.fnLogger)
				if i == nil {
					sdkhelper.EjectResult(nil, rMsg, out)
					continue
				}
				// conv to bgr24 and resize
				imgW, imgH := int(i.Width), int(i.Height)
				ret := f.handle.TrackerResize(imgW, imgH, chn)
				f.fnLogger("ResizeFaceTracker: cid: ", rMsg.Cid, " chan: ", chn, " wXh: ", imgW, "x", imgH, " result:", ret)
				go f.detectTrackOneChn(ctx, f.ftrackChans[rMsg.Cid], out, chn)
				f.ftrackChans[rMsg.Cid] <- rMsg
			}
		default:
			time.Sleep(time.Millisecond * 100)
		}
	}
}

func (f *face) detectTrackOneChn(ctx context.Context, in <-chan protomsg.SdkMessage, out chan<- sdkstruct.MsgSDK, dtchn int) {
	tm := time.Now()
	sc := 0
	f.fnLogger("DETECTTRACKONECHN DTCHN: ", dtchn)
	var curCid string

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

		case rMsg := <-in:

			if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
				sdkhelper.EjectResult(nil, rMsg, out)
				continue
			}

			i := sdkhelper.UnpackImage(rMsg, f.typ, f.fnLogger)
			if i == nil || i.Data == nil || i.Width <= 0 || i.Height <= 0 {
				sdkhelper.EjectResult(nil, rMsg, out)
				continue
			}

			curCid = i.Cid

			// conv to bgr24 and resize
			imgW, imgH := int(i.Width), int(i.Height)

			count, data, _ := f.handle.Run(i.Data, imgW, imgH, 3, dtchn)

			sdkhelper.EjectResult(data, rMsg, out)
			var id, name string
			if rMsg.Tasklab != nil {
				id, name = rMsg.Tasklab.Taskid, rMsg.Tasklab.Taskname
			}
			f.fnLogger("Chan:", dtchn, "CAMERAID: ", rMsg.Cid, " TASKID: ", id, " TASKNAME: ", name, " DETECT ", f.typ, " COUNT: ", count)

			sc++
			if sc == 25 {
				f.fnLogger("CHAN:%d, FACE RUN 25 FRAME USE TIME: ", dtchn, time.Since(tm))
				sc = 0
				tm = time.Now()
			}

			if time.Since(tm) > time.Second {
				f.fnLogger("CHAN: ", dtchn, " FACE RUN ", sc, " FRAME USE TIME: ", time.Since(tm))
				sc = 0
				tm = time.Now()
			}
		case <-time.After(trackChnTimeout * time.Second):
			f.fnLogger("Timeout to get image, curCid:", curCid)
			if curCid != "" {
				delete(f.ftrackChans, curCid)
				f.releaseChn(dtchn)
			}
			return

		}
	}
}