package util

import (
	"basic.com/pubsub/protomsg.git"
	"bufio"
	"fmt"
	"gocv.io/x/gocv"
	"image"
	"image/color"
	"os"
	"ruleprocess/cache"
	"ruleprocess/logger"
	"ruleprocess/ruleserver"
	"strings"
)

func CvRTSP() {
	url := `rtsp://admin:a1234567@192.168.1.188:554/h264/ch1/main/av_stream`

	webcam, _ := gocv.OpenVideoCapture(url)
	window := gocv.NewWindow("Hello")
	img := gocv.NewMat()
	for {
		webcam.Read(&img)
		window.IMShow(img)
		window.WaitKey(1)
	}
}

func cvFaceDetect() {
	// set to use a video capture device 0
	deviceID := 0
	url := `rtsp://admin:a1234567@192.168.1.188:554/h264/ch1/main/av_stream`

	// open webcam
	webcam, err := gocv.OpenVideoCapture(url)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer webcam.Close()

	// open display window
	window := gocv.NewWindow("Face Detect")
	defer window.Close()

	// prepare image matrix
	img := gocv.NewMat()
	defer img.Close()

	// color for the rect when faces detected
	blue := color.RGBA{0, 0, 255, 0}

	// load classifier to recognize faces
	classifier := gocv.NewCascadeClassifier()
	defer classifier.Close()

	if !classifier.Load("data/haarcascade_frontalface_default.xml") {
		fmt.Println("Error reading cascade file: data/haarcascade_frontalface_default.xml")
		return
	}

	fmt.Printf("start reading camera device: %v\n", deviceID)
	for {
		if ok := webcam.Read(&img); !ok {
			fmt.Printf("cannot read device %v\n", deviceID)
			return
		}
		if img.Empty() {
			continue
		}

		// detect faces
		rects := classifier.DetectMultiScale(img)
		fmt.Printf("found %d faces\n", len(rects))

		// draw a rectangle around each face on the original image
		for _, r := range rects {
			gocv.Rectangle(&img, r, blue, 3)
		}

		// show the image in the window, and wait 1 millisecond
		window.IMShow(img)
		window.WaitKey(1)
	}
}

var w = 400

// CVDraw demo
func CVDraw() {
	windowA := gocv.NewWindow("basic drawing: atom")
	windowR := gocv.NewWindow("basic drawing: rook")
	defer windowA.Close()
	defer windowR.Close()

	atom := gocv.NewMatWithSize(w, w, gocv.MatTypeCV8UC3)
	defer atom.Close()

	rook := gocv.NewMatWithSize(w, w, gocv.MatTypeCV8UC3)
	defer rook.Close()

	black := color.RGBA{0, 0, 0, 0}
	blue := color.RGBA{0, 0, 255, 0}
	red := color.RGBA{255, 0, 0, 0}
	white := color.RGBA{255, 255, 255, 0}
	yellow := color.RGBA{255, 255, 0, 0}

	// draw the atom
	gocv.Ellipse(&atom, image.Pt(w/2., w/2.), image.Pt(w/4.0, w/16.0), 90., 0, 360, blue, 2)
	gocv.Ellipse(&atom, image.Pt(w/2., w/2.), image.Pt(w/4.0, w/16.0), 0., 0, 360, blue, 2)
	gocv.Ellipse(&atom, image.Pt(w/2., w/2.), image.Pt(w/4.0, w/16.0), 45., 0, 360, blue, 2)
	gocv.Ellipse(&atom, image.Pt(w/2., w/2.), image.Pt(w/4.0, w/16.0), -45., 0, 360, blue, 2)
	gocv.Circle(&atom, image.Pt(w/2., w/2.), w/32., red, -1)

	// draw the rook
	points := [][]image.Point{
		{
			image.Pt(w/4., 7*w/8.),
			image.Pt(3*w/4., 7*w/8.),
			image.Pt(3*w/4., 13*w/16.),
			image.Pt(11*w/16., 13*w/16.),
			image.Pt(19*w/32., 3*w/8.),
			image.Pt(3*w/4., 3*w/8.),
			image.Pt(3*w/4., w/8.),
			image.Pt(26*w/40., w/8.),
			image.Pt(26*w/40., w/4.),
			image.Pt(22*w/40., w/4.),
			image.Pt(22*w/40., w/8.),
			image.Pt(18*w/40., w/8.),
			image.Pt(18*w/40., w/4.),
			image.Pt(14*w/40., w/4.),
			image.Pt(14*w/40., w/8.),
			image.Pt(w/4., w/8.),
			image.Pt(w/4., 3*w/8.),
			image.Pt(13*w/32., 3*w/8.),
			image.Pt(5*w/16., 13*w/16.),
			image.Pt(w/4., 13*w/16.),
		},
	}
	gocv.FillPoly(&rook, points, white)
	gocv.Rectangle(&rook, image.Rect(0, 7*w/8.0, w, w), yellow, -1)
	gocv.Line(&rook, image.Pt(0, 15*w/16), image.Pt(w, 15*w/16), black, 2)
	gocv.Line(&rook, image.Pt(w/4, 7*w/8), image.Pt(w/4, w), black, 2)
	gocv.Line(&rook, image.Pt(w/2, 7*w/8), image.Pt(w/2, w), black, 2)
	gocv.Line(&rook, image.Pt(3*w/4, 7*w/8), image.Pt(3*w/4, w), black, 2)

	for {
		windowA.IMShow(atom)
		windowR.IMShow(rook)

		if windowA.WaitKey(10) >= 0 || windowR.WaitKey(10) >= 0 {
			break
		}
	}
}

func DrawPolygonOnImage(cameraId string, img protomsg.Image, results []ruleserver.Result) (maps map[string]interface{}, err0 error) {

	rook, _ := gocv.NewMatFromBytes(int(img.Height), int(img.Width), gocv.MatTypeCV8UC3, img.Data)
	//rook := gocv.IMRead("/home/user/workspace/ruleprocess/util/105.jpg",gocv.IMReadColor)
	defer rook.Close()

	red := color.RGBA{255, 0, 0, 0}
	green := color.RGBA{0, 255, 0, 0}

	// 分割区域id集合并根据id查询区域然后画框
	for _,result := range results  {
		polygonIds := strings.Split(result.AlarmPolygon,",")
		logger.Info("-----------------------看看报警区域id：",polygonIds)
		for i := 0; i < len(polygonIds)-1; i++ {
			polygon := getPolygonById(polygonIds[i],cameraId)
			if polygon.Polygon != "" {
				DrawAPolygon(&rook,polygon.Polygon,red)
			}
		}
	}
	// 把目标框出来
	for _,result := range results  {
		for _,rect := range result.Location {
			gocv.Rectangle(&rook, image.Rect(int(rect.X), int(rect.Y), int(rect.X+rect.Width), int(rect.Y+rect.Height)), green, 1)
		}
	}
	//return nil,nil
	maps,err0 = UploadFromMat(rook)
	return
}

// 把图片转成二进制流
func RetrieveROM(filename string) ([]byte, error) {
	file, err := os.Open(filename)

	if err != nil {
		return nil, err
	}
	defer file.Close()

	stats, statsErr := file.Stat()
	if statsErr != nil {
		return nil, statsErr
	}

	var size int64 = stats.Size()
	bytes := make([]byte, size)

	bufr := bufio.NewReader(file)
	_, err = bufr.Read(bytes)

	return bytes, err
}
// 根据id去缓存里查询多边形
func getPolygonById(polygonId string, cameraId string) (protomsg.CameraPolygon){
	// 查到摄像机所有的区域并画框
	var cameraPolygons []protomsg.CameraPolygon
	cameraPolygons = cache.GetPolygonsByCameraId(cameraId)
	for _, polygon := range cameraPolygons {
		if polygon.Id == polygonId {
			return polygon
		}
	}
	return protomsg.CameraPolygon{}
}
// 在图上画一个框
func DrawAPolygon(rook *gocv.Mat,polygonString string, color color.RGBA) {
	points := ruleserver.Json2points(polygonString)
	for index := 0; index < len(points); index++ {
		if index == len(points)-1 { // 闭合图形
			gocv.Line(rook, image.Pt(int(points[index].X), int(points[index].Y)), image.Pt(int(points[0].X), int(points[0].Y)), color, 2)
		} else {
			gocv.Line(rook, image.Pt(int(points[index].X), int(points[index].Y)), image.Pt(int(points[index+1].X), int(points[index+1].Y)), color, 2)
		}
	}
}