// main
package main

import (
	"image"
	_ "image/png"
	"os"
	"time"

	"github.com/faiface/pixel"
	"github.com/faiface/pixel/pixelgl"
	"golang.org/x/image/colornames"
)

//something like this should handle everything within the game.
//this is not the final form. I was just testing things.
type Handler struct {
	s *pixel.Sprite
	x, y float64
}

func loadPicture(path string) (pixel.Picture, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	defer file.Close()
	img, _, err := image.Decode(file)
	if err != nil {
		return nil, err
	}
	return pixel.PictureDataFromImage(img), nil
}

func run() {
	cfg := pixelgl.WindowConfig{
		Title:  "Pixel Rocks!",
		Bounds: pixel.R(0, 0, 1024, 768),
		//Going to use different method then vsync
	}

	win, err := pixelgl.NewWindow(cfg)
	if err != nil {
		panic(err)
	}

	pic, err := loadPicture("hiking.png")
	if err != nil {
		panic(err)
	}

	sprite := pixel.NewSprite(pic, pic.Bounds())

	//Create handler
	var handler Handler
	handler.s = sprite
	handler.x = 0
	handler.y = 0

	//Game Loop -- Should be 60 fps
	var timePerFrame int64 = 1000000000/60
	last := time.Now().UnixNano()
	var now, dt int64
	for !win.Closed() {
		
		now = time.Now().UnixNano()
		dt += now-last
		last = now
		
		if (dt >= timePerFrame) {
			dt -= 0

			update(&handler)
			render(handler, win)
		}
		
	}
}

func main() {
	pixelgl.Run(run)
}


func update(handler *Handler) {
	handler.x += 0.5
	handler.y += 0.5
}

func render(handler Handler, win *pixelgl.Window) {
	win.Clear(colornames.Skyblue)

	//Draw here---
	handler.s.Draw(win, pixel.IM.Moved(pixel.V(handler.x,handler.y)))

	//---DrawEnd

	//update
	win.Update()
}