package main

import (
	"flag"
	"image"
	"log"
	"math"
	"os"
	"path/filepath"

	"github.com/hajimehoshi/ebiten"

	"ur.gs/ordoor/internal/conv"
	"ur.gs/ordoor/internal/data"
	"ur.gs/ordoor/internal/sets"
	"ur.gs/ordoor/internal/ui"
)

var (
	gamePath = flag.String("game-path", "./orig", "Path to a WH40K: Chaos Gate installation")
	setFile  = flag.String("set", "", "Path to a .set file, e.g. ./orig/Sets/map01.set")
)

type env struct {
	set     *sets.MapSet
	objects map[string]*conv.Object

	step      int
	state     state
	lastState state
}

type state struct {
	objIdx    int
	spriteIdx int

	zoom   float64
	origin image.Point
}

func main() {
	flag.Parse()

	if *gamePath == "" || *setFile == "" {
		flag.Usage()
		os.Exit(1)
	}

	mapSet, err := sets.LoadSet(*setFile)
	if err != nil {
		log.Fatalf("Couldn't load set file %s: %v", *setFile, err)
	}

	rawObjs := make([]*data.Object, 0, len(mapSet.Palette))
	for _, name := range mapSet.Palette {
		objFile := filepath.Join(*gamePath, "Obj", name+".obj")
		obj, err := data.LoadObject(objFile)
		if err != nil {
			log.Fatalf("Failed to load %s: %v", name, err)
		}
		obj.Name = name

		rawObjs = append(rawObjs, obj)
	}

	objs := make([]*conv.Object, 0, len(rawObjs))
	for _, rawObj := range rawObjs {
		obj, err := conv.ConvertObject(rawObj, rawObj.Name)
		if err != nil {
			log.Fatal(err)
		}

		objs = append(objs, obj)
	}

	win, err := ui.NewWindow("View Set: " + *setFile)
	if err != nil {
		log.Fatal("Couldn't create window: %v", err)
	}

	state := state{zoom: 8.0}
	env := &env{
		set:       mapSet,
		objects:   conv.MapByName(objs),
		state:     state,
		lastState: state,
	}

	win.OnKeyUp(ebiten.KeyLeft, env.changeObjIdx(-1))
	win.OnKeyUp(ebiten.KeyRight, env.changeObjIdx(+1))

	win.OnKeyUp(ebiten.KeyUp, env.changeSpriteIdx(+1))
	win.OnKeyUp(ebiten.KeyDown, env.changeSpriteIdx(-1))

	win.OnMouseWheel(env.changeZoom)

	// Main thread now belongs to ebiten
	if err := win.Run(env.Update, env.Draw); err != nil {
		log.Fatal(err)
	}
}

func (e *env) Update() error {
	if e.step == 0 || e.lastState != e.state {
		log.Printf(
			"new state: numObj=%d object=%d (%s) numFrames=%d sprite=%d zoom=%.2f",
			e.set.Count(),
			e.state.objIdx,
			e.set.Palette[e.state.objIdx], // FIXME: palette is a confusing name
			len(e.curObject().Sprites),
			e.state.spriteIdx,
			e.state.zoom,
		)
	}

	e.step += 1
	e.lastState = e.state

	return nil
}

func (e *env) Draw(screen *ebiten.Image) error {
	obj := e.curObject()
	sprite := obj.Sprites[e.state.spriteIdx]

	cam := ebiten.GeoM{}
	cam.Scale(e.state.zoom, e.state.zoom) // apply current zoom factor

	// TODO: centre the image

	return screen.DrawImage(sprite.Image, &ebiten.DrawImageOptions{GeoM: cam})
}

func (e *env) changeObjIdx(by int) func() {
	return func() {
		old := e.state.objIdx
		e.state.objIdx += by

		if e.state.objIdx < 0 {
			e.state.objIdx = 0
		}

		if e.state.objIdx > e.set.Count()-1 {
			e.state.objIdx = e.set.Count() - 1
		}

		// reset sprite index when object changes
		if old != e.state.objIdx {
			e.state.spriteIdx = 0
		}
	}
}

func (e *env) changeSpriteIdx(by int) func() {
	return func() {
		e.state.spriteIdx += by

		if e.state.spriteIdx < 0 {
			e.state.spriteIdx = 0
		}

		count := len(e.curObject().Sprites)
		if e.state.spriteIdx > count-1 {
			e.state.spriteIdx = count - 1
		}
	}
}

func (e *env) changeZoom(_, y float64) {
	// Zoom in and out with the mouse wheel
	e.state.zoom *= math.Pow(1.2, y)
}

func (e *env) curObject() *conv.Object {
	name := e.set.Palette[e.state.objIdx]
	return e.objects[name]
}