package proc

import (
	"analysis/logo"
	"analysis/util"
	"analysis/work"
	"analysis/work/sdk"
	"context"
)

type infoSDK struct {
	name string
	ipc  string
	s    sdk.Engine
	shm  bool
}

var (
	mapFunc = make(map[string]sdk.Engine)
	infos   []infoSDK
	fn      func([]byte, bool)
)

const (
	postPull = `_1`
	postPush = `_2`

	reservedGMem = 512
	yoloGMem     = 2048
	faceGMem     = 1024
	faceMustGPU0 = 0

	cfg     = "./data/yolo/cfg/yolov3.cfg"
	weights = "./data/yolo/yolov3.weights"
	name    = "./data/yolo/data/coco.names"
)

const (
	FDetect = "FaceDetect"
	// FExtract  = "FaceExtract"
	// FProperty = "FaceProperty"
	FCompare = "FaceCompare"
	FtTract  = "FaceTrack"
	FtDetect = "FaceTrackDetect"
	FtOnly   = "FaceTrackOnly"
	YDetect  = "Yolo"
	PlateID  = "Plate"
)

var (
	SDK = []string{
		YDetect,
		FDetect,
		FCompare,
		PlateID,
		// FtTract,
		// FtOnly,
	}
)

func prepare(name string, gpu int) (string, bool) {

	return initSDK(name, gpu)
}

func initSDK(name string, gpu int) (string, bool) {

	sdkType := name

	if s, f := util.FindStringInArray(sdkType, SDK); f {
		sdkType = s
	} else {
		logo.Errorln("THERE IS NO THIS SDK TYPE: ", sdkType)
		return sdkType, false
	}

	thrds := util.SFI.DetectThrd
	if thrds < util.SFI.PropThrd {
		thrds = util.SFI.PropThrd
	}
	if thrds < util.SFI.ExtractThrd {
		thrds = util.SFI.ExtractThrd
	}

	logo.Infoln("PASS GPU INDEX: ", gpu)

	var e sdk.Engine
	ret := true

	if sdkType == FDetect {
		e, ret = createFaceDetect(gpu, thrds, util.SFI.DetectNum, util.SFI.DetectAngle, util.SFI.TrackInterval, util.SFI.SampleSize)

	} else if sdkType == YDetect {
		e, ret = createYolo(gpu)

	} else if sdkType == FtTract {
		e, ret = createFaceTrack(gpu, thrds, util.SFI.DetectNum, util.SFI.DetectAngle, util.SFI.TrackInterval, util.SFI.SampleSize)

	} else if sdkType == FCompare {
		e = sdk.NewEFExtract(100)
	} else if sdkType == PlateID {
		e = sdk.NewPlateIDDetector(util.SCI.LicenseServerPath, util.SCI.Model, util.SCI.MaxImageWidth, util.SCI.MaxImageHeight)
	}

	if ret {
		mapFunc[sdkType] = e
	}
	return sdkType, ret
}

func build(fname, id string, shm bool) {
	f, ok := mapFunc[fname]
	if !ok {
		logo.Errorln("sdk has no this func : ", fname)
		return
	}

	if flag := f.Init(); !flag {
		logo.Errorln("create sdk : ", fname, " error")
		return
	}

	s := infoSDK{fname, id, f, shm}
	infos = append(infos, s)
}

func runAll(ctx context.Context) {

	rule := work.NewToRule(30)
	url := util.ToRuleIPC
	go rule.Run(ctx, url)

	fn = func(data []byte, valid bool) {
		if rule != nil {
			rule.Push(data, valid)
		}
	}

	for _, v := range infos {
		go run(ctx, v.s, v.name, v.ipc, v.shm)
	}
}

func run(ctx context.Context, s sdk.Engine, fname, id string, shm bool) {
	chRcv := make(chan work.MsgRS)
	chSnd := make(chan work.MsgRS)

	ipcRcv := util.GetIpcAddress(shm, id+postPull)
	recv := work.NewReciever(ipcRcv, chRcv, shm)
	logo.Infoln("RECV IPC: ", ipcRcv)
	go recv.Run(ctx)

	ipcSnd := util.GetIpcAddress(shm, id+postPush)
	snd := work.NewSender(ipcSnd, chSnd, shm)
	snd.ApplyCallbackFunc(fn)
	logo.Infoln("SND IPC: ", ipcSnd)
	go snd.Run(ctx)

	s.Run(ctx, chRcv, chSnd, fname)
}

////////////////////////////////////////////////////////////////
////////////// test
////////////////////////////////////////////////////////////////
// single run
func runSDK(ctx context.Context, fname, id string, shm bool) {

	f, ok := mapFunc[fname]
	if !ok {
		logo.Errorln("sdk has no this func : ", fname)
		return
	}

	if flag := f.Init(); !flag {
		logo.Errorln("create sdk : ", fname, " error")
		return
	}

	chRcv := make(chan work.MsgRS)
	chSnd := make(chan work.MsgRS)

	ipcS := `ipc:///tmp/`

	ipcRcv := ipcS + id + postPull
	recv := work.NewReciever(ipcRcv, chRcv, shm)
	logo.Infoln("\nrecv ipc: ", ipcRcv)
	go recv.Run(ctx)

	ipcSnd := ipcS + id + postPush
	snd := work.NewSender(ipcSnd, chSnd, shm)
	logo.Infoln("\nsnd ipc: ", ipcSnd)
	go snd.Run(ctx)

	f.Run(ctx, chRcv, chSnd, fname)

}