func CheckGLErrors() {
	glerror := gl.GetError()
	if glerror == gl.NO_ERROR {
		return
	}

	fmt.Printf("gl.GetError() reports")
	for glerror != gl.NO_ERROR {
		fmt.Printf(" ")
		switch glerror {
		case gl.INVALID_ENUM:
			fmt.Printf("GL_INVALID_ENUM")
		case gl.INVALID_VALUE:
			fmt.Printf("GL_INVALID_VALUE")
		case gl.INVALID_OPERATION:
			fmt.Printf("GL_INVALID_OPERATION")
		case gl.STACK_OVERFLOW:
			fmt.Printf("GL_STACK_OVERFLOW")
		case gl.STACK_UNDERFLOW:
			fmt.Printf("GL_STACK_UNDERFLOW")
		case gl.TABLE_TOO_LARGE:
			fmt.Printf("GL_TABLE_TOO_LARGE")
		case gl.OUT_OF_MEMORY:
			fmt.Printf("GL_OUT_OF_MEMORY")
		default:
			fmt.Printf("%d", glerror)
		}
		glerror = gl.GetError()
	}
	fmt.Printf("\n")
}

func (shaders Shaders) Serve(ref ShaderRef) (gl.Shader, error) {
	shader, ok := shaders[ref]
	if ok {
		return shader, nil
	}

	shader_seed, ok := SHADER_SOURCES[ref]
	if !ok {
		return 0, fmt.Errorf("Shader Reference '%#v' not found.", ref)
	}

	shader = gl.CreateShader(gl.GLenum(shader_seed.Type))
	if err := CheckGlError(); err != nil {
		if shader == 0 {
			err.Description = "CreateShader failed."
		} else {
			err.Description = "CreateShader succeeded but OpenGL reports an error."
		}
		return shader, err
	} else {
		if shader == 0 {
			return 0, fmt.Errorf("CreateShader failed but OpenGL reports no error.")
		}
	}

	shader.Source(shader_seed.Source)
	if err := CheckGlError(); err != nil {
		shader.Delete()
		gl.GetError() // Delete may also raise an error, ignore.
		err.Description = "Shader.Source failed."
		return 0, err
	}

	shader.Compile()
	if err := CheckGlError(); err != nil {
		infolog := shader.GetInfoLog()
		shader.Delete()
		gl.GetError() // GetInfoLog and delete may raise an error.
		err.Description = fmt.Sprintf("Shader.Compile failed. Log: %v", infolog)
		return 0, err
	}
	compileStatus := shader.Get(gl.COMPILE_STATUS)
	if err := CheckGlError(); err != nil {
		shader.Delete()
		gl.GetError()
		err.Description = "shader.Get(gl.COMPILE_STATUS) failed."
		return 0, err
	}
	if compileStatus == gl.FALSE {
		infolog := shader.GetInfoLog()
		shader.Delete()
		gl.GetError()
		err := fmt.Errorf("Shader compiling failed.  Log: %v", infolog)
		return 0, err
	}
	shaders[ref] = shader
	return shader, nil
}

func (self *OpenGLRenderer) checkErrors() {
	e := gl.GetError()
	for e != gl.NO_ERROR {
		errString, err := glu.ErrorString(e)
		if err != nil {
			log.Println("Invalid error code found", err)
		} else {
			log.Printf("GLError %v => %s", e, errString)
		}

		e = gl.GetError()
	}
}

func main() {
	runtime.LockOSThread()

	if !glfw.Init() {
		fmt.Fprintf(os.Stderr, "Can't open GLFW")
		return
	}
	defer glfw.Terminate()

	glfw.WindowHint(glfw.Samples, 4)
	glfw.WindowHint(glfw.ContextVersionMajor, 3)
	glfw.WindowHint(glfw.ContextVersionMinor, 3)
	glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
	glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs

	window, err := glfw.CreateWindow(1024, 768, "Tutorial 1", nil, nil)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return
	}

	window.MakeContextCurrent()

	gl.Init()
	gl.GetError() // Ignore error
	window.SetInputMode(glfw.StickyKeys, 1)

	gl.ClearColor(0., 0., 0.4, 0.)
	// Equivalent to a do... while
	for ok := true; ok; ok = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
		window.SwapBuffers()
		glfw.PollEvents()
	}

}

// NewRenderer creates a new Renderer with the given window size and title.
func NewRenderer(window *Window) (*Renderer, error) {
	logger.Debug("Initializing GLEW")

	// Init glew
	if gl.Init() != 0 {
		return nil, errors.New("Could not initialise glew.")
	}
	gl.GetError()

	if window.Settings.ClearColor != nil {
		color := window.Settings.ClearColor
		gl.ClearColor(
			gl.GLclampf(color.R()),
			gl.GLclampf(color.G()),
			gl.GLclampf(color.B()),
			0.,
		)
	}

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

	gl.Enable(gl.CULL_FACE)

	// Vertex buffers
	vertexArray := gl.GenVertexArray()
	vertexArray.Bind()

	renderer := Renderer{
		vertexArray: vertexArray,
		window:      window,
	}
	return &renderer, nil
}

func RunIn3DContext(example func()) {
	if !glfw.Init() {
		log.Panic("glfw Error")
	}
	defer glfw.Terminate()

	glfw.WindowHint(glfw.ContextVersionMajor, 3)
	glfw.WindowHint(glfw.ContextVersionMinor, 3)
	glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True)
	glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)

	w, h := 100, 100
	window, err := glfw.CreateWindow(w, h, "Test", nil, nil)
	if err != nil {
		log.Panic(err)
	}
	window.MakeContextCurrent()

	if gl.Init() != 0 {
		log.Panic("gl error")
	}
	gl.GetError()

	vertexArray := gl.GenVertexArray()
	vertexArray.Bind()

	example()
}

func main() {
	if err := glfw.Init(); err != nil {
		fmt.Fprintf(os.Stderr, "%s\n", err.Error())
		return
	}
	defer glfw.Terminate()

	glfw.OpenWindowHint(glfw.FsaaSamples, 4)
	glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
	glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3)
	glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)

	if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil {
		fmt.Fprintf(os.Stderr, "%s\n", err.Error())
		return
	}

	gl.Init()
	gl.GetError() // Ignore error

	glfw.SetWindowTitle("Tutorial 01")
	glfw.Enable(glfw.StickyKeys)

	gl.ClearColor(0., 0., 0.4, 0.)
	// Equivalent to a do... while
	for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) {
		glfw.SwapBuffers()
	}

}

// CheckGLError returns an opengl error if one exists.
func CheckGLError() error {
	errno := gl.GetError()

	if errno == gl.NO_ERROR {
		return nil
	}
	return fmt.Errorf("Unknown GL error: %d", errno)
}

func CheckGlError() *GlError {
	ec := gl.GetError()
	if ec == gl.NO_ERROR {
		return nil
	}
	err := GlError{
		Error_code: ec,
		Stack:      retreiveStackTrace(),
	}
	return &err
}

// Used as "defer OpenGLSentinel()()" checks the gl error code on call and exit
func OpenGLSentinel() func() {
	check := func() {
		e := gl.GetError()
		if e != gl.NO_ERROR {
			s, err := glu.ErrorString(e)
			if err != nil {
				log.Panic("Invalid error code: ", err)
			}
			log.Panic("Encountered GLError: ", e, " = ", s)
		}
	}
	check()
	return check
}

// CheckGLError returns an opengl error if one exists.
func CheckGLError() error {
	errno := gl.GetError()

	if errno == gl.NO_ERROR {
		return nil
	}

	str, err := glu.ErrorString(errno)
	if err != nil {
		return fmt.Errorf("Unknown GL error: %d", errno)
	}

	return fmt.Errorf(str)
}

func checkGlError(expeced ...gl.GLenum) error {
	gle := gl.GetError()
	if gle != gl.NO_ERROR {
		str, err := glu.ErrorString(gle)
		if err != nil {
			str = err.Error()
		}
		for _, v := range expeced {
			if v == gle {
				return Error(fmt.Sprintf("[gl][expected] %v: %v", gle, str))
			}
		}
		return Error(fmt.Sprintf("[gl][unexpected] %v: %v", gle, str))
	}
	return nil
}

func loadShader(shaderType gl.GLenum, source string) gl.Shader {
	shader := gl.CreateShader(shaderType)
	if err := gl.GetError(); err != gl.NO_ERROR {
		panic(fmt.Errorf("gl error: %v", err))
	}

	shader.Source(source)
	shader.Compile()

	if shader.Get(gl.COMPILE_STATUS) != gl.TRUE {
		log := shader.GetInfoLog()
		panic(fmt.Errorf("Failed to compile shader: %v, shader: %v", log, source))
	}

	return shader
}

//-----------------------------------------------------------------------------
func validateProgram(program gl.Program) {
	program.Validate()
	if err := CheckGlError(); err != nil {
		err.Description = "program.Validate failed"
		panic(err)
	}
	status := program.Get(gl.VALIDATE_STATUS)
	if err := CheckGlError(); err != nil {
		err.Description = "program.Get(VALIDATE_STATUS) failed"
		panic(err)
	}
	if status == gl.FALSE {
		infolog := program.GetInfoLog()
		gl.GetError() // Clear error flag if infolog derped.
		panic(fmt.Errorf("program validation failed with log: %v", infolog))
	}
}

func (h *Hex) Render(alpha float32, drawFromCenter bool) {
	gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
	if h.Kind == HexFlower {
		gl.TexEnvf(gl.TEXTURE_ENV, gl.TEXTURE_ENV_MODE, gl.REPLACE)
		starTex.Bind(gl.TEXTURE_2D)
	} else {
		gl.TexEnvf(gl.TEXTURE_ENV, gl.TEXTURE_ENV_MODE, gl.MODULATE)
		hexTex.Bind(gl.TEXTURE_2D)
		gl.GetError()
		var r, g, b uint8
		r = uint8(colors.Colors[h.Kind-1][0])
		g = uint8(colors.Colors[h.Kind-1][1])
		b = uint8(colors.Colors[h.Kind-1][2])
		if alpha < 1 {
			gl.Color4ub(r, g, b, uint8(alpha*255))
		} else {
			gl.Color3ub(r, g, b)
		}
	}
	gl.Begin(gl.QUADS)
	gl.TexCoord2f(0, 0)
	if drawFromCenter {
		gl.Vertex2i(HEX_WIDTH/2, HEX_HEIGHT/2)
	} else {
		gl.Vertex2i(HEX_WIDTH, HEX_HEIGHT)
	}
	gl.TexCoord2f(0, 1)
	if drawFromCenter {
		gl.Vertex2i(HEX_WIDTH/2, -HEX_HEIGHT/2)
	} else {
		gl.Vertex2i(HEX_WIDTH, 0)
	}
	gl.TexCoord2f(1, 1)
	if drawFromCenter {
		gl.Vertex2i(-HEX_WIDTH/2, -HEX_HEIGHT/2)
	} else {
		gl.Vertex2i(0, 0)
	}
	gl.TexCoord2f(1, 0)
	if drawFromCenter {
		gl.Vertex2i(-HEX_WIDTH/2, HEX_HEIGHT/2)
	} else {
		gl.Vertex2i(0, HEX_HEIGHT)
	}
	gl.End()
}

func uploadTexture_RGBA32(w, h int, data []byte) gl.Texture {

	id := gl.GenTexture()
	id.Bind(gl.TEXTURE_2D)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int(w), int(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, data)

	if gl.GetError() != gl.NO_ERROR {
		id.Delete()
		panic("Failed to load a texture")
		return 0
	}
	return id
}

func (batch UniformBatch) Enter() {
	batch.modelMatrixUniform.UniformMatrix4f(false, &batch.modelMatrix)

	batch.context.Program.Validate()
	if err := glw.CheckGlError(); err != nil {
		err.Description = "Program.Validate failed."
		panic(err)
	}
	status := batch.context.Program.Get(gl.VALIDATE_STATUS)
	if err := glw.CheckGlError(); err != nil {
		err.Description = "Program.Get(VALIDATE_STATUS) failed."
		panic(err)
	}
	if status == gl.FALSE {
		infolog := batch.context.Program.GetInfoLog()
		gl.GetError() // Clear error flag if infolog derped.
		panic(fmt.Errorf("Program validation failed. Log: %v", infolog))
	}
}

// Create a *Texture containing a rendering of `str` with `size`.
// TODO: allow for alternative fonts
func MakeText(str string, size float64) *Text {
	if str == "" {
		panic("Trying to build empty text")
	}

	defer OpenGLSentinel()()

	// TODO: Something if font doesn't exist
	fontBytes, err := ioutil.ReadFile(FontFile)
	if err != nil {
		log.Panic(err)
	}
	font, err := freetype.ParseFont(fontBytes)
	if err != nil {
		log.Panic(err)
	}

	fg, bg := image.White, image.Black

	c := freetype.NewContext()
	c.SetDPI(72)
	c.SetFont(font)
	c.SetFontSize(size)

	pt := freetype.Pt(0, int(c.PointToFix32(size)>>8))
	s, err := c.DrawString(str, pt)
	if err != nil {
		log.Panic("Error: ", err)
	}

	spacing, offset := 1.5, 3

	w := int(s.X >> 8)
	h := int(c.PointToFix32(size*spacing)>>8) - offset

	text := &Text{str: str, Texture: NewTexture(w, h)}

	if text.W > 4096 {
		text.W = 4096
	}

	rgba := image.NewRGBA(image.Rect(0, 0, text.W, text.H))
	draw.Draw(rgba, rgba.Bounds(), bg, image.ZP, draw.Src)
	c.SetClip(rgba.Bounds())
	c.SetDst(rgba)
	c.SetSrc(fg)

	_, err = c.DrawString(text.str, pt)
	if err != nil {
		log.Panic("Error: ", err)
	}

	With(text, func() {
		gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, text.W, text.H, 0, gl.RGBA,
			gl.UNSIGNED_BYTE, rgba.Pix)
	})

	if gl.GetError() != gl.NO_ERROR {
		log.Panic("Failed to load a texture, err = ", gl.GetError(),
			" str = ", str, " w = ", text.W, " h = ", text.H)
	}

	return text
}

func (self Programs) Serve(srefs ShaderRefs) (gl.Program, error) {
	pref := makeProgramRef(srefs)
	program, ok := self.programs[pref]
	if ok {
		return program, nil
	}

	// Make sure that all the shaders are available and compile.
	nb_shaders := len(srefs)
	shaders := make([]gl.Shader, nb_shaders, nb_shaders)
	for i, sref := range srefs {
		shader, err := self.shaders.Serve(sref)
		if err != nil {
			return 0, err
		}
		shaders[i] = shader
	}

	program = gl.CreateProgram()
	if err := CheckGlError(); err != nil {
		if program == 0 {
			err.Description = "CreateProgram failed."
		} else {
			err.Description = "CreateProgram succeeded but OpenGL reports an error."
		}
		return program, err
	} else {
		if program == 0 {
			return 0, fmt.Errorf("CreateProgram failed but OpenGL reports no error.")
		}
	}

	for _, shader := range shaders {
		program.AttachShader(shader)
		if err := CheckGlError(); err != nil {
			program.Delete()
			gl.GetError() // Ignore Delete error.
			err.Description = "Program.AttachShader failed."
			return 0, err
		}
	}

	program.Link()
	if err := CheckGlError(); err != nil {
		infolog := program.GetInfoLog()
		program.Delete()
		gl.GetError() // Ignore Delete error.
		err.Description = fmt.Sprintf("Program.Link failed. Log: %v", infolog)
		return 0, err
	}
	link_status := program.Get(gl.LINK_STATUS)
	if err := CheckGlError(); err != nil {
		program.Delete()
		gl.GetError()
		err.Description = "Program.Get(LINK_STATUS) failed."
		return 0, err
	}
	if link_status == gl.FALSE {
		infolog := program.GetInfoLog()
		program.Delete()
		gl.GetError()
		err := fmt.Errorf("Program linking failed.  Log: %v", infolog)
		return 0, err
	}
	self.programs[pref] = program
	return program, nil
}