package util

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"image"
	"image/color"
	"image/jpeg"

	"basic.com/pubsub/protomsg.git"
	"github.com/llgcode/draw2d/draw2dimg"
)

// 按尺寸去切图
func SubCutImg(src *protomsg.Image, rect *protomsg.Rect, enlarge int) ([]byte, error) {
	bkImg, _ := ToImage(src.Data, int(src.Width), int(src.Height), 3)

	rectNew := image.Rect(EnlargeCut(rect, int(src.Width), int(src.Height), enlarge))
	subImg := bkImg.(*image.RGBA).SubImage(rectNew)

	bytes, err := ImageToJpeg(subImg, nil)
	if err != nil {
		return nil, err
	}
	return bytes, nil
}

// 长宽变为一比一，每边各扩百分之...
func EnlargeCut(rect *protomsg.Rect, maxW, maxH int, enlargePer int) (x0_new, y0_new, x1_new, y1_new int) {
	// 先把长宽变为一比一
	x0 := int(rect.Left)
	y0 := int(rect.Top)
	x1 := int(rect.Right)
	y1 := int(rect.Bottom)

	chazhi := (y1 - y0) - (x1 - x0)
	x0 = x0 - chazhi/2
	if x0 < 0 {
		x0 = 0
	}
	x1 = x1 + chazhi/2
	if x1 > maxW {
		x1 = maxW
	}

	// 再把每边各扩大百分之...
	enlarge := float32(enlargePer / 100)
	x0_new = int((1+enlarge)*float32(x0) - enlarge*float32(x1))
	if x0_new < 0 {
		x0_new = 0
	}
	x1_new = int((1+enlarge)*float32(x1) - enlarge*float32(x0))
	if x1_new > maxW {
		x1_new = maxW
	}
	y0_new = int((1+enlarge)*float32(y0) - enlarge*float32(y1))
	if y0_new < 0 {
		y0_new = 0
	}
	y1_new = int((1+enlarge)*float32(y1) - enlarge*float32(y0))
	if y1_new > maxH {
		y1_new = maxH
	}

	return x0_new, y0_new, x1_new, y1_new
}

// 长宽变为一比一，每边各扩百分之20
func EnlargeSizeForCar(x0, y0, x1, y1 int, i protomsg.Image) (x0_new, y0_new, x1_new, y1_new int) {
	// 先把长宽变为一比一
	chazhi := (y1 - y0) - (x1 - x0)
	x0 = x0 - chazhi/2
	if x0 < 0 {
		x0 = 0
	}
	x1 = x1 + chazhi/2
	if x1 > int(i.Width) {
		x1 = int(i.Width)
	}

	// 再把每边各扩大百分之20
	enlarge := float32(0.2)
	x0_new = int((1+enlarge)*float32(x0) - enlarge*float32(x1))
	if x0_new < 0 {
		x0_new = 0
	}
	x1_new = int((1+enlarge)*float32(x1) - enlarge*float32(x0))
	if x1_new > int(i.Width) {
		x1_new = int(i.Width)
	}
	y0_new = int((1+enlarge)*float32(y0) - enlarge*float32(y1))
	if y0_new < 0 {
		y0_new = 0
	}
	y1_new = int((1+enlarge)*float32(y1) - enlarge*float32(y0))
	if y1_new > int(i.Height) {
		y1_new = int(i.Height)
	}
	return
}

// 不扩边
func EnlargeSize(x0, y0, x1, y1 int, i protomsg.Image) (int, int, int, int) {

	// 先把长宽变为一比一
	chazhi := (y1 - y0) - (x1 - x0)
	x0 = x0 - chazhi/2
	if x0 < 0 {
		x0 = 0
	}
	x1 = x1 + chazhi/2
	if x1 > int(i.Width) {
		x1 = int(i.Width)
	}

	if y0 < 0 {
		y0 = 0
	}

	if y1 > int(i.Height) {
		y1 = int(i.Height)
	}

	return x0, y0, x1, y1
}

// 长宽变为一比一，每边各扩百分之50
func EnlargeSizeForTem(x0, y0, x1, y1 int, i protomsg.Image) (x0_new, y0_new, x1_new, y1_new int) {
	// 先把长宽变为一比一
	chazhi := (y1 - y0) - (x1 - x0)
	x0 = x0 - chazhi/2
	if x0 < 0 {
		x0 = 0
	}
	x1 = x1 + chazhi/2
	if x1 > int(i.Width) {
		x1 = int(i.Width)
	}

	// 再把每边各扩大百分之50
	enlarge := float32(0.5)
	x0_new = int((1+enlarge)*float32(x0) - enlarge*float32(x1))
	if x0_new < 0 {
		x0_new = 0
	}
	x1_new = int((1+enlarge)*float32(x1) - enlarge*float32(x0))
	if x1_new > int(i.Width) {
		x1_new = int(i.Width)
	}
	y0_new = int((1+enlarge)*float32(y0) - enlarge*float32(y1))
	if y0_new < 0 {
		y0_new = 0
	}
	y1_new = int((1+enlarge)*float32(y1) - enlarge*float32(y0))
	if y1_new > int(i.Height) {
		y1_new = int(i.Height)
	}
	return
}

func drawLine(img *image.RGBA, x0, y0, x1, y1 int, c color.Color) {
	var dx int
	if x1 > x0 {
		dx = x1 - x0
	} else {
		dx = x0 - x1
	}
	var dy int
	if y1 > y0 {
		dy = y1 - y0
	} else {
		dy = y0 - y1
	}

	sx, sy := 1, 1
	if x0 >= x1 {
		sx = -1
	}
	if y0 >= y1 {
		sy = -1
	}
	err := dx - dy

	for {
		img.Set(x0, y0, c)
		if x0 == x1 && y0 == y1 {
			return
		}
		e2 := err * 2
		if e2 > -dy {
			err -= dy
			x0 += sx
		}
		if e2 < dx {
			err += dx
			y0 += sy
		}
	}
}

func DrawRect(img *image.RGBA, x0, y0, x1, y1 int, c color.Color) {
	drawLine(img, x0, y0, x1, y0, c)
	drawLine(img, x1, y0, x1, y1, c)
	drawLine(img, x1, y1, x0, y1, c)
	drawLine(img, x0, y1, x0, y0, c)
}

// ToImage bgr -> image.Image
func ToImage(data []byte, w, h, channels int) (image.Image, error) {
	if len(data) != w*h*channels {
		return nil, fmt.Errorf("data length does not match dimensions and channels. data %d, w %d, h %d, channels %d", len(data), w, h, channels)
	}

	img := image.NewRGBA(image.Rect(0, 0, w, h))
	step := w * channels

	for y := 0; y < h; y++ {
		for x := 0; x < w; x++ {
			i := y*step + x*channels
			var c color.RGBA

			switch channels {
			case 3: // BGR 格式
				c = color.RGBA{
					R: data[i+2], // 红色通道
					G: data[i+1], // 绿色通道
					B: data[i],   // 蓝色通道
					A: 255,       // 不透明
				}
			case 4: // BGRA 格式
				c = color.RGBA{
					R: data[i+2], // 红色通道
					G: data[i+1], // 绿色通道
					B: data[i],   // 蓝色通道
					A: data[i+3], // Alpha 通道
				}
			default:
				return nil, errors.New("unsupported number of channels")
			}

			img.Set(x, y, c)
		}
	}

	return img, nil
}

// Image2BGR img->bgr
func Image2BGR(img image.Image) []byte {
	bounds := img.Bounds()
	x := bounds.Dx()
	y := bounds.Dy()
	data := make([]byte, 0, x*y*3)
	for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
		for i := bounds.Min.X; i < bounds.Max.X; i++ {
			r, g, b, _ := img.At(i, j).RGBA()
			data = append(data, byte(b>>8), byte(g>>8), byte(r>>8))
		}
	}
	return data
}

// DrawRectangle draw rect
func DrawRectangle(img image.Image, rc image.Rectangle, clr color.RGBA, lw float64) error {

	l, t, r, b := rc.Min.X, rc.Min.Y, rc.Max.X, rc.Max.Y

	pt := []image.Point{
		image.Pt(l, t),
		image.Pt(l, r),
		image.Pt(r, b),
		image.Pt(r, l),
	}

	return DrawPolygon(img, pt, clr, lw)
}

// DrawPolygon draw polygon
func DrawPolygon(img image.Image, pt []image.Point, clr color.RGBA, lw float64) error {
	rgba, ok := img.(*image.RGBA)
	if !ok {
		return errors.New("IMAGE CONVERT TO RGBA ERROR")
	}

	pt = append(pt, pt[0])

	gc := draw2dimg.NewGraphicContext(rgba)
	gc.SetStrokeColor(clr)
	gc.SetLineWidth(lw)

	gc.BeginPath()
	start := pt[0]
	pt = pt[1:]
	gc.MoveTo((float64)(start.X), (float64)(start.Y))
	for _, v := range pt {
		gc.LineTo((float64)(v.X), (float64)(v.Y))
	}
	// gc.QuadCurveTo(100, 10, 10, 10)
	gc.Close()
	gc.Stroke()
	return nil
}

// ToJpeg bgr -> jpeg file
func ToJpeg(bgr []byte, w, h int, quality *int) ([]byte, error) {
	img, err := ToImage(bgr, w, h, 3)
	if err != nil {
		return nil, err
	}
	return ImageToJpeg(img, quality)
}

// ImageToJpeg save to jpeg data
func ImageToJpeg(img image.Image, quality *int) ([]byte, error) {
	var o *jpeg.Options

	if quality != nil {
		o = &jpeg.Options{Quality: *quality}
	}
	var b bytes.Buffer
	w := bufio.NewWriter(&b)
	err := jpeg.Encode(w, img, o)
	if err != nil {
		return nil, err
	}
	return b.Bytes(), err
}