package main

import (
	"flag"
	"log"
	"math"
	"os"

	"github.com/hajimehoshi/ebiten/v2"

	"code.ur.gs/lupine/ordoor/internal/assetstore"
	"code.ur.gs/lupine/ordoor/internal/config"
	"code.ur.gs/lupine/ordoor/internal/flow"
	"code.ur.gs/lupine/ordoor/internal/scenario"
	"code.ur.gs/lupine/ordoor/internal/ship"
	"code.ur.gs/lupine/ordoor/internal/ui"
)

var (
	configFile = flag.String("config", "config.toml", "Config file")
	engine     = flag.String("engine", "", "Override engine to use")

	gameMap = flag.String("map", "", "Name of a map, e.g., Chapter01")

	winX = flag.Int("win-x", 1280, "Pre-scaled window X dimension")
	winY = flag.Int("win-y", 1024, "Pre-scaled window Y dimension")
)

type env struct {
	flow     *flow.Flow
	scenario *scenario.Scenario
}

func main() {
	flag.Parse()

	if *configFile == "" || *gameMap == "" {
		flag.Usage()
		os.Exit(1)
	}

	cfg, err := config.Load(*configFile, *engine)
	if err != nil {
		log.Fatalf("Failed to load config: %v", err)
	}

	assets, err := assetstore.New(cfg.DefaultEngine())
	if err != nil {
		log.Fatalf("Failed to scan root directory: %v", err)
	}

	scenario, err := scenario.NewScenario(assets, *gameMap)
	if err != nil {
		log.Fatalf("Failed to load scenario %v: %v", *gameMap, err)
	}

	var realEnv *env
	if cfg.DefaultEngineName == "ordoor" {
		ship := &ship.Ship{}

		flow, err := flow.New(assets, cfg, ship)
		if err != nil {
			log.Fatalf("Failed to setup flow: %v", err)
		}
		flow.SetScenario(scenario)
		realEnv = &env{flow: flow, scenario: scenario}
	} else {
		realEnv = &env{scenario: scenario}
	}

	win, err := ui.NewWindow(realEnv, "View Map "+*gameMap, *winX, *winY)
	if err != nil {
		log.Fatalf("Couldn't create window: %v", err)
	}

	for i := 0; i <= 6; i++ {
		win.OnKeyUp(ebiten.Key1+ebiten.Key(i), realEnv.setZIdx(i))
	}

	win.OnMouseClick(realEnv.showCellData)
	win.OnMouseWheel(realEnv.changeZoom)

	if realEnv.flow == nil {
		step := 32
		win.WhileKeyDown(ebiten.KeyLeft, realEnv.changeOrigin(-step, +0))
		win.WhileKeyDown(ebiten.KeyRight, realEnv.changeOrigin(+step, +0))
		win.WhileKeyDown(ebiten.KeyUp, realEnv.changeOrigin(+0, -step))
		win.WhileKeyDown(ebiten.KeyDown, realEnv.changeOrigin(+0, +step))
	}

	if err := win.Run(); err != nil {
		log.Fatal(err)
	}
}

func (e *env) Update(screenX, screenY int) error {
	if e.flow != nil {
		return e.flow.Update(screenX, screenY)
	} else {
		return e.scenario.Update(screenX, screenY)
	}
}

func (e *env) Draw(screen *ebiten.Image) error {
	if e.flow != nil {
		return e.flow.Draw(screen)
	} else {
		return e.scenario.Draw(screen)
	}
}

func (e *env) changeOrigin(byX, byY int) func() {
	return func() {
		e.scenario.Viewpoint.X += byX
		e.scenario.Viewpoint.Y += byY
	}
}

func (e *env) changeZoom(_, byY float64) {
	e.scenario.Zoom *= math.Pow(1.2, byY)
}

func (e *env) setZIdx(to int) func() {
	return func() {
		e.scenario.ZIdx = to
	}
}

func (e *env) showCellData() {
	screenX, screenY := ebiten.CursorPosition()
	viewX, viewY := e.scenario.Viewpoint.X+screenX, e.scenario.Viewpoint.Y+screenY

	log.Printf("Click registered at (%d,%d) screen, (%d,%d) virtual", screenX, screenY, viewX, viewY)

	cell, pos := e.scenario.CellAtCursor()
	log.Printf("Viewpoint: %#+v z=%v", e.scenario.Viewpoint, e.scenario.ZIdx)
	log.Printf("Cell under cursor: (%.2f,%.2f,%d): %#+v", pos.X, pos.Y, pos.Z, cell)
}