package render

import (
	"edgaru089.ml/go/gl01/internal/asset"
	"edgaru089.ml/go/gl01/internal/io"
	"edgaru089.ml/go/gl01/internal/util/itype"
	"edgaru089.ml/go/gl01/internal/world"
	"github.com/go-gl/gl/all-core/gl"
	"github.com/go-gl/mathgl/mgl32"
	"github.com/inkyblackness/imgui-go/v4"
)

var (
	ShadowmapSize = itype.Vec2i{6144, 6144} // Size of the shadow mapping
)

// WorldRenderer holds texture/shader resource and viewport
// information for world rendering.
type WorldRenderer struct {
	lastDisplaySize itype.Vec2i

	depthmap struct {
		fbo, tex uint32  // Framebuffer Object and Texture.
		shader   *Shader // Shader.
	}

	gbuffer struct {
		fbo uint32 // The Framebuffer object.

		// Textures. Position/Lightspace Depth;   Normal/Specular Intensity;  Diffuse Color.
		pos, norm, color uint32
		depth            uint32
		shader           *Shader // Geometry pass shaders.
	}

	shader  *Shader  // Deffered lighting pass shaders
	texture *Texture // World texture atlas
}

// The default WorldRenderer.
var DefaultWorldRenderer WorldRenderer

// Init initializes the WorldRenderer.
func (r *WorldRenderer) Init(w *world.World) (err error) {

	r.shader, err = NewShader(asset.WorldShaderVert, asset.WorldShaderFrag)
	if err != nil {
		return err
	}
	r.depthmap.shader, err = NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag)
	if err != nil {
		return err
	}
	r.gbuffer.shader, err = NewShader(asset.WorldShaderGeometryVert, asset.WorldShaderGeometryFrag)
	if err != nil {
		return err
	}

	asset.InitWorldTextureAtlas()
	r.texture = NewTextureRGBA(asset.WorldTextureAtlas.Image)
	r.texture.GenerateMipMap()
	r.gbuffer.shader.SetUniformTexture("tex", r.texture)

	r.depthmap.shader.SetUniformMat4("model", mgl32.Ident4())
	r.gbuffer.shader.SetUniformMat4("model", mgl32.Ident4())
	// and view and projection uniforms not yet set
	gl.BindFragDataLocation(r.shader.Handle(), 0, gl.Str("outputColor\x00"))

	// generate the depthmap and depthmap FBO
	gl.GenFramebuffers(1, &r.depthmap.fbo)
	gl.GenTextures(1, &r.depthmap.tex)
	gl.BindTexture(gl.TEXTURE_2D, r.depthmap.tex)
	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, int32(ShadowmapSize[0]), int32(ShadowmapSize[1]), 0, gl.DEPTH_COMPONENT, gl.FLOAT, nil)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER)
	borderColor := []float32{1, 1, 1, 1}
	gl.TexParameterfv(gl.TEXTURE_2D, gl.TEXTURE_BORDER_COLOR, &borderColor[0])
	// attach depth texture as FBO's depth buffer
	gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmap.fbo)
	gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, r.depthmap.tex, 0)
	gl.DrawBuffer(gl.NONE)
	gl.ReadBuffer(gl.NONE)
	// attach the shadowmap to the shader
	r.shader.SetUniformTextureHandle("shadowmap", r.depthmap.tex)

	// generate G-buffer and friends
	gl.GenFramebuffers(1, &r.gbuffer.fbo)
	gl.BindFramebuffer(gl.FRAMEBUFFER, r.gbuffer.fbo)
	// position
	gl.GenTextures(1, &r.gbuffer.pos)
	gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.pos)
	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
	gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, r.gbuffer.pos, 0)
	// normal
	gl.GenTextures(1, &r.gbuffer.norm)
	gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.norm)
	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
	gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, r.gbuffer.norm, 0)
	// diffuse color
	gl.GenTextures(1, &r.gbuffer.color)
	gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.color)
	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
	gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, r.gbuffer.color, 0)
	// depth
	gl.GenRenderbuffers(1, &r.gbuffer.depth)
	gl.BindRenderbuffer(gl.RENDERBUFFER, r.gbuffer.depth)
	gl.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
	gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, r.gbuffer.depth)
	// tell OpenGL which color attachments we'll use (of this framebuffer)
	attachments := [...]uint32{gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2}
	gl.DrawBuffers(int32(len(attachments)), &attachments[0])
	// attach the textures
	r.shader.SetUniformTextureHandle("gPos", r.gbuffer.pos)
	r.shader.SetUniformTextureHandle("gNorm", r.gbuffer.norm)
	r.shader.SetUniformTextureHandle("gColor", r.gbuffer.color)

	gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
	r.lastDisplaySize = io.DisplaySize

	initScreenQuad()

	return nil
}

// ResizeDisplay resizes the size of the internal buffers dependent on the window size.
// It is called automatically most of the time.
func (r *WorldRenderer) ResizeDisplay(newSize itype.Vec2i) {
}

var sun = [3]float32{0.2, 0.4, 0.3}

func (r *WorldRenderer) Render(world *world.World, view *View) {

	// re-generate the G-buffers if the display size changed
	if r.lastDisplaySize != io.DisplaySize {
		gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.pos)
		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
		gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.norm)
		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
		gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.color)
		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
		gl.BindRenderbuffer(gl.RENDERBUFFER, r.gbuffer.norm)
		gl.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
		r.lastDisplaySize = io.DisplaySize
	}

	imgui.SliderFloat3("Sun", &sun, -1, 1)
	normalSun := itype.Vec3f(sun).Normalize()

	gl.Enable(gl.CULL_FACE)
	gl.Enable(gl.DEPTH_TEST)
	gl.DepthFunc(gl.LESS)

	// 1. Render to depth map
	gl.Viewport(0, 0, int32(ShadowmapSize[0]), int32(ShadowmapSize[1]))
	gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmap.fbo)
	gl.Clear(gl.DEPTH_BUFFER_BIT)

	lightPos := view.EyePos.Add(normalSun.Multiply(50))
	lightView := mgl32.LookAt(lightPos[0], lightPos[1], lightPos[2], view.EyePos[0], view.EyePos[1], view.EyePos[2], 0, 1, 0)
	lightProjection := mgl32.Ortho(-50, 50, -50, 50, 1, 100)
	lightspace := lightProjection.Mul4(lightView)

	r.depthmap.shader.UseProgram()
	r.depthmap.shader.SetUniformMat4("lightspace", lightspace)

	world.Render()

	// 2. Geometry pass, render to G-buffer
	gl.Viewport(0, 0, int32(r.lastDisplaySize[0]), int32(r.lastDisplaySize[1]))
	gl.BindFramebuffer(gl.FRAMEBUFFER, r.gbuffer.fbo)
	gl.ClearColor(0, 0, 0, 1)
	gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
	gl.Disable(gl.BLEND)

	r.gbuffer.shader.UseProgram()
	r.gbuffer.shader.BindTextures()
	r.gbuffer.shader.SetUniformMat4("lightspace", lightspace)
	r.gbuffer.shader.SetUniformMat4("view", view.View())
	r.gbuffer.shader.SetUniformMat4("projection", view.Perspective())
	r.gbuffer.shader.SetUniformVec3f("viewPos", view.EyePos)

	world.Render()

	gl.BindFramebuffer(gl.FRAMEBUFFER, 0)

	// 3. Render the actual output with deferred lighting
	gl.Clear(gl.DEPTH_BUFFER_BIT)
	r.shader.UseProgram()
	r.shader.BindTextures()

	r.shader.SetUniformMat4("lightspace", lightspace)
	r.shader.SetUniformVec3f("viewPos", view.EyePos)
	r.shader.SetUniformVec4f("fogColor", itype.Vec4f{0.6, 0.8, 1.0, 1.0})
	r.shader.SetUniformVec3f("sun", normalSun)

	r.drawScreenQuad()
}