/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "common/textconsole.h"
#include "common/debug.h"
#include "common/system.h"
#include "common/config-manager.h"

#include "graphics/tinygl/tinygl.h"

#include "engines/util.h"

#include "tetraedge/te/te_renderer_tinygl.h"
#include "tetraedge/te/te_light.h"
#include "tetraedge/te/te_light_tinygl.h"
#include "tetraedge/te/te_mesh_tinygl.h"

namespace Tetraedge {

TeRendererTinyGL::TeRendererTinyGL() {
}

void TeRendererTinyGL::clearBuffer(TeRenderer::Buffer buf) {
	TGLenum glBuf = 0;
	if (buf & StencilBuffer)
		glBuf |= TGL_STENCIL_BUFFER_BIT;
	if (buf & DepthBuffer)
		glBuf |= TGL_DEPTH_BUFFER_BIT;
	if (buf & ColorBuffer)
		glBuf |= TGL_COLOR_BUFFER_BIT;
	tglClear(glBuf);
}

void TeRendererTinyGL::colorMask(bool r, bool g, bool b, bool a) {
	tglColorMask(r, g, b, a);
}

void TeRendererTinyGL::disableAllLights() {
	TeLightTinyGL::disableAll();
}

void TeRendererTinyGL::disableTexture() {
	tglDisable(TGL_TEXTURE_2D);
	_textureEnabled = false;
}

void TeRendererTinyGL::disableWireFrame() {
	tglPolygonMode(TGL_FRONT_AND_BACK, TGL_FILL);
}

void TeRendererTinyGL::disableZBuffer() {
	tglDisable(TGL_DEPTH_TEST);
	tglDepthMask(TGL_FALSE);
}

void TeRendererTinyGL::drawLine(const TeVector3f32 &from, const TeVector3f32 &to) {
	error("TODO: Implement TeRendererTinyGL::drawLine");
}

void TeRendererTinyGL::enableAllLights() {
	TeLightTinyGL::enableAll();
}

void TeRendererTinyGL::enableTexture() {
	tglEnable(TGL_TEXTURE_2D);
	_textureEnabled = true;
}

void TeRendererTinyGL::enableWireFrame() {
	tglPolygonMode(TGL_FRONT_AND_BACK, TGL_LINE);
}

void TeRendererTinyGL::enableZBuffer() {
	tglEnable(TGL_DEPTH_TEST);
	tglDepthMask(TGL_TRUE);
}

void TeRendererTinyGL::init(uint width, uint height) {
	initGraphics(width, height, nullptr);

	const Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
	debug(2, "INFO: TinyGL front buffer pixel format: %s", pixelFormat.toString().c_str());
	TinyGL::createContext(width, height, pixelFormat, 256, true, ConfMan.getBool("dirtyrects"), 7 * 1024 * 1024);

	tglViewport(0, 0, width, height);

	tglDisable(TGL_CULL_FACE);
	TeLightTinyGL::disableAll();
	tglDisable(TGL_COLOR_MATERIAL);
	tglEnable(TGL_DEPTH_TEST);
	tglDepthMask(TGL_TRUE);
	tglShadeModel(TGL_SMOOTH);
	tglEnable(TGL_BLEND);
	tglBlendFunc(TGL_SRC_ALPHA, TGL_ONE_MINUS_SRC_ALPHA);
	tglDepthFunc(TGL_LEQUAL);
	// Original does this, probably not needed?
	//tglHint(TGL_PERSPECTIVE_CORRECTION_HINT, TGL_DONT_CARE);
	tglClearDepthf(1.0f);
	//tglClearStencil(0);
	_clearColor = TeColor(0, 0, 0, 255);
	tglClearColor(0, 0, 0, 1.0);
	//TeOpenGLExtensions::loadExtensions(); // this does nothing in the game?
	_currentColor = TeColor(255, 255, 255, 255);
	_scissorEnabled = false;
	_scissorX = _scissorY = _scissorWidth = _scissorHeight = 0;
}


void TeRendererTinyGL::loadMatrixToGL(const TeMatrix4x4 &matrix) {
	//int mmode;
	//glGetIntegerv(TGL_MATRIX_MODE, &mmode);
	//debug("loadMatrixToGL[0x%x]: %s", mmode, matrix.toString().c_str());
	tglLoadMatrixf(matrix.getData());
}

void TeRendererTinyGL::loadProjectionMatrix(const TeMatrix4x4 &matrix) {
	tglMatrixMode(TGL_PROJECTION);
	_matrixMode = MM_GL_PROJECTION;
	_matriciesStacks[_matrixMode].loadIdentity();
	_matriciesStacks[_matrixMode].loadMatrix(matrix);
	tglMatrixMode(TGL_MODELVIEW);
	_matrixMode = MM_GL_MODELVIEW;
	_matriciesStacks[_matrixMode].loadIdentity();
}

Common::String TeRendererTinyGL::renderer() {
	return "TinyGL";
}


void TeRendererTinyGL::renderTransparentMeshes() {
	if (!_numTransparentMeshes)
		return;

	tglDepthMask(TGL_FALSE);

	// Note: some code moved to optimiseTransparentMeshProperties to minimise
	// non-OGL-speicifc code.
	optimiseTransparentMeshProperties();

	tglEnableClientState(TGL_VERTEX_ARRAY);
	tglEnableClientState(TGL_NORMAL_ARRAY);
	tglEnableClientState(TGL_TEXTURE_COORD_ARRAY);
	tglEnableClientState(TGL_COLOR_ARRAY);

	tglVertexPointer(3, TGL_FLOAT, sizeof(TeVector3f32), _transparentMeshVertexes.data());
	tglNormalPointer(TGL_FLOAT, sizeof(TeVector3f32), _transparentMeshNormals.data());
	tglTexCoordPointer(2, TGL_FLOAT, sizeof(TeVector2f32), _transparentMeshCoords.data());
	tglColorPointer(4, TGL_UNSIGNED_BYTE, sizeof(TeColor), _transparentMeshColors.data());

	TeMaterial lastMaterial;
	TeMatrix4x4 lastMatrix;

	int vertsDrawn = 0;
	for (uint i = 0; i < _transparentMeshProps.size(); i++) {
		const TransparentMeshProperties &meshProperties = _transparentMeshProps[i];
		if (!meshProperties._shouldDraw)
			continue;

		const TeMaterial &material = meshProperties._material;

		meshProperties._camera->applyProjection();
		tglMatrixMode(TGL_MODELVIEW);
		_matrixMode = MM_GL_MODELVIEW;
		tglPushMatrix();
		_matriciesStacks[_matrixMode].pushMatrix();
		_matriciesStacks[_matrixMode].loadMatrix(meshProperties._matrix);
		tglPushMatrix();
		loadCurrentMatrixToGL();
		if (material._texture) {
			tglEnable(TGL_TEXTURE_2D);
			_textureEnabled = true;
		}
		if (material._isShadowTexture) {
			tglDisableClientState(TGL_TEXTURE_COORD_ARRAY);
			tglDisableClientState(TGL_COLOR_ARRAY);
		}

		if (material != lastMaterial) {
			applyMaterial(material);
			lastMaterial = material;
		}

		if (meshProperties._scissorEnabled) {
			tglEnable(TGL_SCISSOR_TEST);
			// TODO: No scissoring in TGL..
			/*
			tglScissor(meshProperties._scissorX,
					  meshProperties._scissorY,
					  meshProperties._scissorWidth,
					  meshProperties._scissorHeight);*/
		}
		tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, meshProperties._glTexEnvMode);
		tglDrawElements(TGL_TRIANGLES, meshProperties._vertexCount, TGL_UNSIGNED_SHORT,
				   _transparentMeshVertexNums.data() + vertsDrawn);

		vertsDrawn += meshProperties._vertexCount;

		if (material._isShadowTexture) {
			tglEnableClientState(TGL_TEXTURE_COORD_ARRAY);
			tglEnableClientState(TGL_COLOR_ARRAY);
		}
		tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_MODULATE);
		if (meshProperties._scissorEnabled) {
			tglDisable(TGL_SCISSOR_TEST);
		}
		if (material._texture) {
			tglDisable(TGL_TEXTURE_2D);
			_textureEnabled = false;
		}
		tglPopMatrix();
		tglPopMatrix();
		_matriciesStacks[_matrixMode].popMatrix();
		TeCamera::restore();
	}
	tglDisableClientState(TGL_VERTEX_ARRAY);
	tglDisableClientState(TGL_NORMAL_ARRAY);
	tglDisableClientState(TGL_COLOR_ARRAY);
	tglDisableClientState(TGL_TEXTURE_COORD_ARRAY);
	_numTransparentMeshes = 0;
	_pendingTransparentMeshProperties = 0;
	tglDepthMask(TGL_TRUE);
	_transparentMeshProps.clear();
}

void TeRendererTinyGL::reset() {
	clearBuffer(AllBuffers);
	tglMatrixMode(TGL_PROJECTION);
	_matrixMode = MM_GL_PROJECTION;
	_matriciesStacks[MM_GL_PROJECTION].loadIdentity();
	tglMatrixMode(TGL_MODELVIEW);
	_matrixMode = MM_GL_MODELVIEW;
	_matriciesStacks[MM_GL_MODELVIEW].loadIdentity();
}

void TeRendererTinyGL::setClearColor(const TeColor &col) {
	_clearColor = col;
	tglClearColor(col.r() / 255.0f, col.g() / 255.0f, col.b() / 255.0f, col.a() / 255.0f);
}

void TeRendererTinyGL::setCurrentColor(const TeColor &col) {
	if (col == _currentColor)
		return;

	tglColor4ub(col.r(), col.g(), col.b(), col.a());
	_currentColor = col;
}

void TeRendererTinyGL::setMatrixMode(enum MatrixMode mode) {
	TGLenum glmode = 0;
	if (mode == MM_GL_TEXTURE)
		glmode = TGL_TEXTURE;
	else if (mode == MM_GL_MODELVIEW)
		glmode = TGL_MODELVIEW;
	else if (mode == MM_GL_PROJECTION)
		glmode = TGL_PROJECTION;

	if (glmode)
		tglMatrixMode(glmode);
	_matrixMode = mode;
}

void TeRendererTinyGL::setViewport(int x, int y, int w, int h) {
	tglViewport(x, y, w, h);
}

void TeRendererTinyGL::shadowMode(enum ShadowMode mode) {
	_shadowMode = mode;
	if (mode == ShadowModeNone) {
		tglDisable(TGL_CULL_FACE);
		tglShadeModel(TGL_SMOOTH);
		return;
	}

	if (mode == ShadowModeCreating) {
		tglEnable(TGL_CULL_FACE);
		tglCullFace(TGL_BACK);
	} else { // ShadowModeDrawing
		tglDisable(TGL_CULL_FACE);
	}
	tglEnable(TGL_BLEND);
	tglBlendFunc(TGL_SRC_ALPHA, TGL_ONE_MINUS_SRC_ALPHA);
	tglShadeModel(TGL_FLAT);
	TeLightTinyGL::disableAll();
}

void TeRendererTinyGL::applyMaterial(const TeMaterial &m) {
	//debug("TeMaterial::apply (%s)", dump().c_str());
	static const float constColor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
	if (_shadowMode == TeRenderer::ShadowModeNone) {
		if (m._enableLights)
			TeLightTinyGL::enableAll();
		else
			TeLightTinyGL::disableAll();

		if (m._texture) {
			enableTexture();
			tglEnableClientState(TGL_TEXTURE_COORD_ARRAY);
			m._texture->bind();
		}

		tglDisable(TGL_ALPHA_TEST);
		if (m._mode == TeMaterial::MaterialMode0) {
			tglTexEnvfv(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_COLOR, constColor);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_COMBINE);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_RGB, TGL_MODULATE);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_RGB, TGL_TEXTURE);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_RGB, TGL_SRC_COLOR);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_ALPHA, TGL_REPLACE);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_ALPHA, TGL_CONSTANT);
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_ALPHA, TGL_SRC_ALPHA);
			
		} else {
			tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_MODULATE);
			if (m._mode != TeMaterial::MaterialMode1) {
				tglEnable(TGL_ALPHA_TEST);
				tglAlphaFunc(TGL_GREATER, 0.5);
			}
		}
		const float ambient[4] = { m._ambientColor.r() / 255.0f, m._ambientColor.g() / 255.0f,
			m._ambientColor.b() / 255.0f, m._ambientColor.a() / 255.0f };
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_AMBIENT, ambient);

		const float specular[4] = { m._specularColor.r() / 255.0f, m._specularColor.g() / 255.0f,
			m._specularColor.b() / 255.0f, m._specularColor.a() / 255.0f };
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_SPECULAR, specular);

		const float emission[4] = { m._emissionColor.r() / 255.0f, m._emissionColor.g() / 255.0f,
			m._emissionColor.b() / 255.0f, m._emissionColor.a() / 255.0f };
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_EMISSION, emission);

		tglMaterialf(TGL_FRONT, TGL_SHININESS, m._shininess);

		const float diffuse[4] = { m._diffuseColor.r() / 255.0f, m._diffuseColor.g() / 255.0f,
			m._diffuseColor.b() / 255.0f, m._diffuseColor.a() / 255.0f };
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_DIFFUSE, diffuse);

		setCurrentColor(m._diffuseColor);
	} else if (_shadowMode == TeRenderer::ShadowModeCreating) {
		// NOTE: Diverge from original here, it sets 255.0 but the
		// colors should be scaled -1.0 .. 1.0.
		static const float fullColor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
		TeLightTinyGL::disableAll();
		tglDisable(TGL_ALPHA_TEST);
		tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_MODULATE);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_AMBIENT, fullColor);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_DIFFUSE, fullColor);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_SPECULAR, fullColor);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_EMISSION, fullColor);
	}

	if (!m._isShadowTexture) {
		tglDisable(TGL_TEXTURE_GEN_S);
		tglDisable(TGL_TEXTURE_GEN_T);
		tglDisable(TGL_TEXTURE_GEN_R);
		tglDisable(TGL_TEXTURE_GEN_Q);
	} else {
		tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_MODULATE);
		tglEnable(TGL_TEXTURE_GEN_S);
		tglEnable(TGL_TEXTURE_GEN_T);
		tglEnable(TGL_TEXTURE_GEN_R);
		tglEnable(TGL_TEXTURE_GEN_Q);
		tglEnable(TGL_TEXTURE_2D);
		TeLightTinyGL::disableAll();
		tglDisable(TGL_ALPHA_TEST);
		enableTexture();
		tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_MODULATE);

		const float diffuse[4] = { m._diffuseColor.r() / 255.0f, m._diffuseColor.g() / 255.0f,
			m._diffuseColor.b() / 255.0f, m._diffuseColor.a() / 255.0f };

		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_AMBIENT, diffuse);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_DIFFUSE, diffuse);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_SPECULAR, diffuse);
		tglMaterialfv(TGL_FRONT_AND_BACK, TGL_EMISSION, diffuse);
	}
}

void TeRendererTinyGL::updateGlobalLight() {
	TeLightTinyGL::updateGlobal();
}

void TeRendererTinyGL::updateScreen() {
      Common::List<Common::Rect> dirtyAreas;
      TinyGL::presentBuffer(dirtyAreas);

      Graphics::Surface glBuffer;
      TinyGL::getSurfaceRef(glBuffer);

      if (!dirtyAreas.empty()) {
          for (Common::List<Common::Rect>::iterator itRect = dirtyAreas.begin(); itRect != dirtyAreas.end(); ++itRect) {
              g_system->copyRectToScreen(glBuffer.getBasePtr((*itRect).left, (*itRect).top), glBuffer.pitch,
                                         (*itRect).left, (*itRect).top, (*itRect).width(), (*itRect).height());
          }
      }

      g_system->updateScreen();
}

Common::String TeRendererTinyGL::vendor() {
	return "TinyGL vendor";
}

} // end namespace Tetraedge