package game

import (
	"fmt"
	"image/color"
	"log"
	"os"
	"runtime"
	"time"

	"edgaru089.ml/go/gl01/internal/asset"
	"edgaru089.ml/go/gl01/internal/igwrap"
	"edgaru089.ml/go/gl01/internal/io"
	"edgaru089.ml/go/gl01/internal/render"
	"edgaru089.ml/go/gl01/internal/util/itype"
	"edgaru089.ml/go/gl01/internal/world"
	"edgaru089.ml/go/gl01/internal/world/worldgen"
	"github.com/go-gl/gl/all-core/gl"
	"github.com/go-gl/glfw/v3.3/glfw"
	"github.com/go-gl/mathgl/mgl64"
	"github.com/inkyblackness/imgui-go/v4"
)

var logs string

type actions struct {
	loadChunkFile string
	loadChunkID   [2]int32

	saveChunkFile string
	saveChunkID   [2]int32
}

var action *actions
var logFollow *bool

func init() {
	action = &actions{
		loadChunkFile: "chunk.gob",
		loadChunkID:   [2]int32{0, 0},
		saveChunkFile: "chunk.gob",
		saveChunkID:   [2]int32{0, 0},
	}
	logFollow = new(bool)
	(*logFollow) = true
}

type logger struct{}

func (logger) Write(b []byte) (n int, err error) {
	logs = logs + string(b)
	n, err = os.Stderr.Write(b)
	return
}

func init() {
	log.Default().SetOutput(logger{})
}

// Init initializes the game.
func (g *Game) Init(win *glfw.Window) {

	g.world = world.NewWorld()
	g.view = &render.View{}
	g.worldrender = &render.WorldRenderer{}

	err := g.worldrender.Init(g.world)
	if err != nil {
		panic(err)
	}

	var seed int64 = time.Now().Unix()
	gensync := make(chan struct{})
	gensynccnt := 0
	for i := -4; i <= 4; i++ {
		for j := -4; j <= 4; j++ {
			c := &world.Chunk{}
			g.world.SetChunk(i, j, c)
			go func() {
				worldgen.Chunk(c, g.world, seed)
				gensync <- struct{}{}
			}()
			gensynccnt++
		}
	}

	for i := 0; i < gensynccnt; i++ {
		<-gensync
	}

	width, height := win.GetSize()
	g.view.Aspect(float32(width)/float32(height)).FovY(itype.Degrees(60)).LookAt(g.cameraPos.ToFloat32(), g.rotY, itype.Degrees(g.rotZ))

	io.DisplaySize[0], io.DisplaySize[1] = win.GetFramebufferSize()
	win.SetSizeCallback(func(w *glfw.Window, width, height int) {
		win.SetCursorPos(float64(width)/2, float64(height)/2)
		g.view.Aspect(float32(width) / float32(height))
		io.DisplaySize = itype.Vec2i{width, height}
	})

	err = render.Framewire.Init()
	if err != nil {
		panic(err)
	}

	imgui.CreateContext(nil)
	g.io = imgui.CurrentIO()

	cfg := imgui.NewFontConfig()
	cfg.SetOversampleH(1)
	cfg.SetOversampleV(1)
	cfg.SetPixelSnapH(true)
	g.io.Fonts().AddFontFromMemoryTTFV(asset.Unifont, 16, cfg, g.io.Fonts().GlyphRangesChineseFull())
	igwrap.Init(win)

	win.SetCursorPos(float64(width)/2, float64(height)/2)

	g.paused = true
	//win.SetInputMode(glfw.CursorMode, glfw.CursorDisabled)
	win.SetCursorPosCallback(func(w *glfw.Window, xpos, ypos float64) {
		if g.paused { // GUI
			return
		}

		width, height := w.GetSize()
		centerX, centerY := float64(width)/2, float64(height)/2
		deltaX, deltaY := xpos-centerX, ypos-centerY
		g.rotY -= itype.Degrees(float32(deltaX) / 10)
		g.rotZ -= float32(deltaY) / 10
		if g.rotZ > 89.99 {
			g.rotZ = 89.99
		}
		if g.rotZ < -89.99 {
			g.rotZ = -89.99
		}
		win.SetCursorPos(centerX, centerY)
	})

	win.SetMouseButtonCallback(func(w *glfw.Window, button glfw.MouseButton, action glfw.Action, mods glfw.ModifierKey) {
		if g.paused {
			igwrap.MouseButtonCallback(button, action)
		}
	})

	win.SetKeyCallback(func(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
		if g.paused {
			igwrap.KeyCallback(key, action)
		}
		if action == glfw.Press {
			if g.paused {
				if key == glfw.KeyEscape && !g.io.WantCaptureKeyboard() {
					g.paused = false
					win.SetInputMode(glfw.CursorMode, glfw.CursorDisabled)
					width, height := w.GetSize()
					win.SetCursorPos(float64(width)/2, float64(height)/2)
				}
			} else {
				if key == glfw.KeyEscape {
					g.paused = true
					win.SetInputMode(glfw.CursorMode, glfw.CursorNormal)
					width, height := w.GetSize()
					win.SetCursorPos(float64(width)/2, float64(height)/2)
				}
			}
		}
	})

	win.SetCharCallback(func(w *glfw.Window, char rune) {
		if g.paused {
			igwrap.InputCallback(char)
		}
	})

	win.SetScrollCallback(func(w *glfw.Window, xpos, ypos float64) {
		if g.paused {
			igwrap.MouseScrollCallback(xpos, ypos)
		}
	})
}

const airAccel = 0.1

// Update updates the game state, not necessarily in the main thread.
func (g *Game) Update(win *glfw.Window, delta time.Duration) {
	igwrap.NewFrame()
	imgui.ShowDemoWindow(nil)

	if !g.paused {

		if win.GetKey(glfw.KeyLeft) == glfw.Press {
			g.rotY += itype.Degrees(float32(delta.Seconds()) * 100)
		}
		if win.GetKey(glfw.KeyRight) == glfw.Press {
			g.rotY -= itype.Degrees(float32(delta.Seconds()) * 100)
		}
		if win.GetKey(glfw.KeyUp) == glfw.Press {
			g.rotZ += float32(delta.Seconds()) * 100
			if g.rotZ > 89.99 {
				g.rotZ = 89.99
			}
		}
		if win.GetKey(glfw.KeyDown) == glfw.Press {
			g.rotZ -= float32(delta.Seconds()) * 100
			if g.rotZ < -89.99 {
				g.rotZ = -89.99
			}
		}

		//forward := itype.Vec3f(mgl32.Rotate3DY(mgl32.DegToRad(g.rotY)).Mul3(mgl32.Rotate3DZ(mgl32.DegToRad(g.rotZ))).Mul3x1(mgl32.Vec3{1, 0, 0})).ToFloat64().Multiply(delta.Seconds()*8)
		var walkaccel float64
		if g.player.OnGround() {
			walkaccel = 48
		} else {
			walkaccel = 16
		}

		forward := itype.Vec3d(mgl64.Rotate3DY(float64(g.rotY.Radians())).Mul3x1(mgl64.Vec3{1, 0, 0}))
		right := forward.Cross(itype.Vec3d{0, 1, 0})
		accel := itype.Vec3d{0, 0, 0}
		if win.GetKey(glfw.KeyW) == glfw.Press {
			accel = accel.Add(forward.Multiply(walkaccel * delta.Seconds()))
		}
		if win.GetKey(glfw.KeyS) == glfw.Press {
			accel = accel.Add(forward.Multiply(walkaccel * delta.Seconds()).Negative())
		}
		if win.GetKey(glfw.KeyD) == glfw.Press {
			accel = accel.Add(right.Multiply(walkaccel * delta.Seconds()))
		}
		if win.GetKey(glfw.KeyA) == glfw.Press {
			accel = accel.Add(right.Multiply(walkaccel * delta.Seconds()).Negative())
		}

		if win.GetKey(glfw.KeySpace) == glfw.Press && g.player.OnGround() {
			//log.Print("Jump!")
			accel = accel.Addv(0, 8, 0)
		}

		g.player.Accelerate(accel[0], accel[1], accel[2])
	}

	g.player.Update(g.world, delta)

	g.view.LookAt(g.player.EyePosition().ToFloat32(), g.rotY, itype.Degrees(g.rotZ))

	render.Framewire.PushBox(g.player.WorldHitbox().ToFloat32(), color.White)

	if g.player.Position()[1] < -100 {
		g.player.SetPosition(itype.Vec3d{18, 80, 18})
		g.player.SetSpeed(itype.Vec3d{})
	}

	if imgui.BeginV("Player", nil, imgui.WindowFlagsAlwaysAutoResize) {
		pos := g.player.Position()
		vel := g.player.Speed()
		imgui.Text(fmt.Sprintf("Pos: (%.5f, %.5f, %.5f), Vel: (%.5f, %.5f, %.5f)", pos[0], pos[1], pos[2], vel[0], vel[1], vel[2]))
	}
	imgui.End()

	if imgui.BeginV("Go Runtime", nil, imgui.WindowFlagsAlwaysAutoResize) {
		imgui.Text(fmt.Sprintf("%s/%s, compiler: %s", runtime.GOOS, runtime.GOARCH, runtime.Compiler))
		imgui.Text(fmt.Sprintf("NumCPU=%d, NumGOMAXPROCS=%d", runtime.NumCPU(), runtime.GOMAXPROCS(0)))
		imgui.Text(fmt.Sprintf("NumCgoCalls=%d, NumGoroutine=%d", runtime.NumCgoCall(), runtime.NumGoroutine()))
		imgui.Spacing()
		if imgui.ButtonV("!!! PANIC !!!", imgui.Vec2{X: -2, Y: 0}) {
			panic("Manual Panic")
		}
	}
	imgui.End()

	if imgui.BeginV("Logs", nil, imgui.WindowFlagsMenuBar) {
		if imgui.BeginMenuBar() {
			if imgui.Button("Clear") {
				logs = ""
			}
			if imgui.RadioButton("Follow", *logFollow) {
				(*logFollow) = !(*logFollow)
			}
			imgui.EndMenuBar()
		}

		var size *float32
		if size == nil {
			size = new(float32)
		}
		imgui.BeginChildV("LogScroll", imgui.Vec2{}, true, 0)
		imgui.Text(logs)
		if (*size) != imgui.ScrollMaxY() && (*logFollow) {
			imgui.SetScrollY(imgui.ScrollMaxY())
		}
		(*size) = imgui.ScrollMaxY()
		imgui.EndChild()
	}
	imgui.End()

	if imgui.Begin("Actions") {

		imgui.Text("Chunks")
		imgui.Separator()
		imgui.InputText("Load Filename", &action.loadChunkFile)
		imgui.SliderInt2("Load ID", &action.loadChunkID, -10, 10)
		if imgui.ButtonV("Load", imgui.Vec2{X: -2, Y: 0}) {
			c := &world.Chunk{}
			f, err := os.Open(action.loadChunkFile)
			if err != nil {
				log.Print("LoadChunk: ", err)
			} else {
				c.LoadFromGobIndexed(f, int(action.loadChunkID[0]), int(action.loadChunkID[1]))
				g.world.SetChunk(int(action.loadChunkID[0]), int(action.loadChunkID[1]), c)
			}
		}
		imgui.Separator()
		imgui.InputText("Save Filename", &action.saveChunkFile)
		imgui.SliderInt2("Save ID", &action.saveChunkID, -10, 10)
		if imgui.ButtonV("Save", imgui.Vec2{X: -2, Y: 0}) {
			c := g.world.Chunks[itype.Vec2i{int(action.saveChunkID[0]), int(action.saveChunkID[1])}]
			f, _ := os.Create(action.saveChunkFile)
			c.WriteToGob(f)
			f.Close()
		}
		imgui.Separator()

	}
	imgui.End()
}

// Render, called with a OpenGL context, renders the game.
func (g *Game) Render(win *glfw.Window) {
	gl.Viewport(0, 0, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
	g.worldrender.Render(g.world, g.view)
	render.Framewire.Render(g.view)

	igwrap.Render(win)
}