package util

import (
	"bufio"
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"gocv.io/x/gocv"
	"image"
	"image/color"
	"io"
	"log"
	"mime/multipart"
	"net/http"
	"os"
	"time"
)

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()(maps map[string]interface{}, err0 error){
	// draw the rook
	//rook := gocv.NewMatWithSize(w, w, gocv.MatTypeCV8UC3)
	//imgs := gocv.NewMat()
	//ddd, err := RetrieveROM("/home/user/workspace/ruleprocess/util/105.jpg")
	//if err != nil {
	//	fmt.Println("解码有误",err)
	//}
	//bbb := bytes.NewBuffer(ddd)  // 必须加一个buffer 不然没有read方法就会报错
	//rook, _ := gocv.NewMatFromBytes(500, 500, gocv.MatTypeCV8UC3, gocv.IMRead())
	rook := gocv.IMRead("/home/user/workspace/ruleprocess/util/105.jpg",gocv.IMReadColor)
	defer rook.Close()

	green := color.RGBA{0, 255, 0, 0}
	//points := [][]image.Point{
	//	{
	//		image.Pt(100., 100),
	//		image.Pt(100., 400),
	//		image.Pt(400, 400),
	//		image.Pt(400, 100),
	//	},
	//}
	//gocv.FillPoly(&rook, points, green)
	gocv.Line(&rook, image.Pt(100, 100), image.Pt(100, 400), green, 2)
	gocv.Line(&rook, image.Pt(100, 400), image.Pt(400, 400), green, 2)
	gocv.Line(&rook, image.Pt(400, 400), image.Pt(400, 100), green, 2)
	gocv.Line(&rook, image.Pt(400, 100), image.Pt(100, 100), green, 2)

	//return nil,nil
	// 上传
	fdata,_ := gocv.IMEncode(".jpg",rook)
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	_, err1 := writer.CreateFormFile("file", "fasjuierf")
	if err1 != nil {
		return nil, err1
	}
	boundary := writer.Boundary()
	//close_string := fmt.Sprintf("\r\n--%s--\r\n", boundary)
	close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
	file := bytes.NewBuffer(fdata)
	request_reader := io.MultiReader(body, file, close_buf)
	//_, err = io.Copy(part, file)
	//writer.WriteField(key, val)
	request, err := http.NewRequest("POST", "http://192.168.1.182:6333/submit", request_reader)
	request.Header.Add("Content-Type", writer.FormDataContentType())
	timeout := time.Duration(5 * time.Second) //超时时间50ms
	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(request)
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("panic的内容%v\n", r)
			msg := "上传图片服务器异常"
			if _, ok := r.(error); ok {
				msg = r.(error).Error()
				fmt.Println("panic--recover()得到的是error类型")
			}
			if _, ok := r.(string); ok {
				msg = r.(string)
				fmt.Println("panic--recover()得到的是string类型")
			}
			err0 = errors.New(msg)
		}
	}()
	defer resp.Body.Close()
	{
		body := &bytes.Buffer{}
		_, err := body.ReadFrom(resp.Body)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(resp.StatusCode)
		//fmt.Println(resp.Header)
		fmt.Println(body)
		//decoder := json.NewDecoder(strings.NewReader(body.String()))
		decoder := make(map[string]interface{})
		if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
			return nil, err
		}
		return decoder, nil
	}
}

// 把图片转成二进制流
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
}