package lines

import (
	"image"
	"image/color"
	"image/draw"
	"image/png"
	"os"
)

const sizesimpix = 20

const (
	white = iota
	darks
	bered
)

type BreLines struct {
	img     *image.RGBA
	col     map[byte]color.Color
	pngfile *os.File
	imgsize int
	pixsize int
}

func (p *BreLines) GetIMG() *image.RGBA { return p.img }

func NewBreLine(size int, path string) (*BreLines, error) {
	imageRGBA := image.NewRGBA(image.Rect(0, 0, size, size))
	cols := make(map[byte]color.Color)
	cols[darks] = color.Gray16{0xdada}
	cols[white] = color.White
	cols[bered] = color.RGBA{255, 0, 0, 255}

	file, err := os.Create(path)
	if err != nil {
		return nil, err
	}

	return &BreLines{
		img: imageRGBA, col: cols, pngfile: file,
		pixsize: int(size / sizesimpix), imgsize: size}, err
}

func (p *BreLines) DrawMesh() {
	draw.Draw(
		p.img, p.img.Bounds(),
		&image.Uniform{p.col[white]}, image.Point{}, draw.Src,
	)

	var locx int
	var icor byte
	for currx := 0; currx < p.img.Bounds().Max.X; currx++ {
		var locy int
		for curr_y := 0; curr_y < sizesimpix; curr_y++ {
			fg := image.Rect(locx, locy, locx+p.pixsize, locy+p.pixsize)
			un := &image.Uniform{p.col[icor]}
			draw.Draw(p.img, fg, un, image.Point{}, draw.Src)
			locy += p.pixsize
			icor = 1 - icor
		}
		locx += p.pixsize
		icor = 1 - icor
	}
}

func (p *BreLines) setPixel(x, y int) {
	x = x * p.pixsize
	y = (sizesimpix - 1 - y) * p.pixsize
	draw.Draw(
		p.img, image.Rect(x, y, x+p.pixsize, y+p.pixsize),
		&image.Uniform{p.col[bered]}, image.Point{}, draw.Src,
	)

}

func (p *BreLines) WriteToFile() error {
	defer p.pngfile.Close()
	return png.Encode(p.pngfile, newXAndYAxis(p.imgsize).drawXandY(p.img))
}

func (p *BreLines) lessThanOrEqOne(x1, y1 int, x2, y2 int, dx, dy int) {
	dx = abs(dx)
	dy = abs(dy)

	Po := (2 * dy) - dx
	p.setPixel(x1, y1)
	xk, yk := x1, y1
	for k := x1; k < x2; k++ {
		if Po < 0 {
			xk++
			p.setPixel(xk, yk)
			Po = Po + (2 * dy)
		} else {
			xk++
			yk++
			p.setPixel(xk, yk)
			Po = Po + (2 * dy) - (2 * dx)
		}
	}
}

func (p *BreLines) greaterThanOne(x1, y1 int, x2, y2 int, dx, dy int) {
	dx = abs(dx)
	dy = abs(dy)
	Po := (2 * dx) - dy
	p.setPixel(x1, y1)
	xk, yk := x1, y1

	for k := y1; k < y2; k++ {
		if Po < 0 {
			yk++
			p.setPixel(xk, yk)
			Po = Po + (2 * dx)
		} else {
			xk++
			yk++
			p.setPixel(xk, yk)
			Po = Po + (2 * dx) - (2 * dy)
		}
	}
}

func (p *BreLines) lessThanOrEqNegOne(x1, y1 int, x2, y2 int, dx, dy int) {
	dx = abs(dx)
	dy = abs(dy)
	Po := (2 * dy) - dx
	p.setPixel(x1, y1)
	xk, yk := x1, y1

	for k := x1; k < x2; k++ {
		if Po < 0 {
			xk++
			p.setPixel(xk, yk)
			Po = Po + (2 * dy)
		} else {
			xk++
			yk--
			p.setPixel(xk, yk)
			Po = Po + (2 * dy) - (2 * dx)
		}
	}
}

func (p *BreLines) greaterThanNegOne(x1, y1 int, x2, y2 int, dx, dy int) {
	dx = abs(dx)
	dy = abs(dy)
	Po := (2 * dy) - dx
	p.setPixel(x1, y1)

	xk, yk := x1, y1

	for k := y1; k > y2; k-- {
		if Po < 0 {
			yk--
			p.setPixel(xk, yk)
			Po = Po + (2 * dx)
		} else {
			xk++
			yk--
			p.setPixel(xk, yk)
			Po = Po + (2 * dx) - (2 * dy)
		}
	}

}

func (p *BreLines) BresenhamLine(x1, y1 int, x2, y2 int) {

	// swap if point start is greater than point end
	if x1 > x2 {
		tempx := x2
		tempy := y2
		x2 = x1
		y2 = y1
		x1 = tempx
		y1 = tempy
	}

	dx := x2 - x1 // delat X
	dy := y2 - y1 // delta Y

	// for 0 < M <= 1, constant increment on x axis
	if dy <= dx && dy > 0 {
		p.lessThanOrEqOne(x1, y1, x2, y2, dx, dy)
		return

	}

	// for M > 1, constant increment on y axis
	if dy > dx && dy > 0 {
		p.greaterThanOne(x1, y1, x2, y2, dx, dy)
		return

	}

	// for 0 > M > -1 constant increment on x axis
	// decrement on y axis
	if dy >= -dx {
		p.lessThanOrEqNegOne(x1, y1, x2, y2, dx, dy)
		return

	}

	// for M < -1 constant decrement on y axis
	// increment on x axis
	if dy < -dx {
		p.greaterThanNegOne(x1, y1, x2, y2, dx, dy)
	}
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}