package wallpaper

import (
	"bytes"
	"image"
	"image/draw"
	"os"
	"path/filepath"
	"runtime"
	"strings"

	"git.kirsle.net/apps/doodle/pkg/bindata"
	"git.kirsle.net/go/render"
)

// Wallpaper is a repeatable background image to go behind levels.
type Wallpaper struct {
	Name   string
	Format string // image file format
	Image  *image.RGBA

	// Ready status is set to true if the wallpaper loaded itself properly.
	// Notably in WASM, wallpapers don't load currently.
	ready bool

	// Parsed values.
	quarterWidth  int
	quarterHeight int

	// The four parsed images.
	corner *image.RGBA // Top Left corner
	top    *image.RGBA // Top repeating
	left   *image.RGBA // Left repeating
	repeat *image.RGBA // Main repeating

	// Cached textures.
	tex struct {
		corner render.Texturer
		top    render.Texturer
		left   render.Texturer
		repeat render.Texturer
	}
}

// FromImage creates a Wallpaper from an image.Image.
// If the renger.Engine is nil it will compute images but not pre-cache any
// textures yet.
func FromImage(e render.Engine, img *image.RGBA, name string) (*Wallpaper, error) {
	wp := &Wallpaper{
		Name:  name,
		Image: img,
	}
	wp.cache(e)
	return wp, nil
}

// FromFile creates a Wallpaper from a file on disk.
// If the renger.Engine is nil it will compute images but not pre-cache any
// textures yet.
func FromFile(e render.Engine, filename string) (*Wallpaper, error) {
	// WASM: no support yet for wallpapers.
	if runtime.GOOS == "js" {
		return &Wallpaper{
			Name:  strings.Split(filepath.Base(filename), ".")[0],
			ready: false,
		}, nil
	}

	// Try and get an image object by any means.
	var (
		img    image.Image
		format string
		imgErr error
	)

	// Try the bindata store.
	if data, err := bindata.Asset(filename); err == nil {
		fh := bytes.NewBuffer(data)
		img, format, imgErr = image.Decode(fh)
	} else {
		fh, err := os.Open(filename)
		if err != nil {
			return nil, err
		}
		img, format, imgErr = image.Decode(fh)
	}

	// Image loading error?
	if imgErr != nil {
		return nil, imgErr
	}

	// Ugly hack: make it an image.RGBA because the thing we get tends to be
	// an image.Paletted, UGH!
	var b = img.Bounds()
	rgba := image.NewRGBA(b)
	for x := b.Min.X; x < b.Max.X; x++ {
		for y := b.Min.Y; y < b.Max.Y; y++ {
			rgba.Set(x, y, img.At(x, y))
		}
	}

	wp := &Wallpaper{
		Name:   strings.Split(filepath.Base(filename), ".")[0],
		Format: format,
		Image:  rgba,
		ready:  true,
	}
	wp.cache(e)
	return wp, nil
}

// cache the bitmap images.
func (wp *Wallpaper) cache(e render.Engine) {
	// Zero-bound the rect cuz an image.Rect doesn't necessarily contain 0,0
	var rect = wp.Image.Bounds()
	if rect.Min.X < 0 {
		rect.Max.X += rect.Min.X
		rect.Min.X = 0
	}
	if rect.Min.Y < 0 {
		rect.Max.Y += rect.Min.Y
		rect.Min.Y = 0
	}

	// Our quarter rect size.
	wp.quarterWidth = int(float64((rect.Max.X - rect.Min.X) / 2))
	wp.quarterHeight = int(float64((rect.Max.Y - rect.Min.Y) / 2))
	quarter := image.Rect(0, 0, wp.quarterWidth, wp.quarterHeight)

	// Slice the image into the four corners.
	slice := func(dx, dy int) *image.RGBA {
		slice := image.NewRGBA(quarter)
		draw.Draw(
			slice,
			image.Rect(0, 0, wp.quarterWidth, wp.quarterHeight),
			wp.Image,
			image.Point{dx, dy},
			draw.Over,
		)
		return slice
	}
	wp.corner = slice(0, 0)
	wp.top = slice(wp.quarterWidth, 0)
	wp.left = slice(0, wp.quarterHeight)
	wp.repeat = slice(wp.quarterWidth, wp.quarterHeight)

}

// QuarterSize returns the width and height of the quarter images.
func (wp *Wallpaper) QuarterSize() (int, int) {
	return wp.quarterWidth, wp.quarterHeight
}

// Corner returns the top left corner image.
func (wp *Wallpaper) Corner() *image.RGBA {
	return wp.corner
}

// Top returns the top repeating image.
func (wp *Wallpaper) Top() *image.RGBA {
	return wp.top
}

// Left returns the left repeating image.
func (wp *Wallpaper) Left() *image.RGBA {
	return wp.left
}

// Repeat returns the main repeating image.
func (wp *Wallpaper) Repeat() *image.RGBA {
	return wp.repeat
}