/*******************************************************************************
 * Copyright 2011 See AUTHORS file.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

package com.badlogic.gdx.graphics.g3d.utils;

import java.nio.IntBuffer;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GLTexture;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.utils.BufferUtils;
import com.badlogic.gdx.utils.GdxRuntimeException;

/** Class that you assign a range of texture units and binds textures for you within that range.
 * It does some basic usage tracking to avoid unnessecary bind calls. 
 * @author xoppa */
public final class DefaultTextureBinder implements TextureBinder {
	public final static int ROUNDROBIN = 0;
	public final static int WEIGHTED = 1;
	/** GLES only supports up to 32 textures */
	public final static int MAX_GLES_UNITS = 32;
	/** The index of the first exclusive texture unit */
	private final int offset;
	/** The amount of exclusive textures that may be used */
	private final int count;
	/** The weight added to a texture when its reused */
	private final int reuseWeight;
	/** The textures currently exclusive bound */
	private final GLTexture[] textures;
	/** The weight (reuseWeight * reused - discarded) of the textures */
	private final int[] weights;
	/** The method of binding to use */
	private final int method;
	/** Flag to indicate the current texture is reused */
	private boolean reused;
	
	private int reuseCount = 0; // TODO remove debug code
	private int bindCount = 0; // TODO remove debug code
	
	/** Uses all available texture units and reuse weight of 3 */
	public DefaultTextureBinder(final int method) {
		this(method, 0);
	}
	
	/** Uses all remaining texture units and reuse weight of 3 */
	public DefaultTextureBinder(final int method, final int offset) {
		this(method, offset,  -1);
	}
	
	/** Uses reuse weight of 10 */
	public DefaultTextureBinder(final int method, final int offset, final int count) {
		this(method, offset, count, 10);
	}
	
	public DefaultTextureBinder(final int method, final int offset, int count, final int reuseWeight) {
		final int max = Math.min(getMaxTextureUnits(), MAX_GLES_UNITS);
		if (count < 0)
			count = max - offset;
		if (offset < 0 || count < 0 || (offset + count) > max || reuseWeight < 1)
			throw new GdxRuntimeException("Illegal arguments");
		this.method = method;
		this.offset = offset;
		this.count = count;
		this.textures = new GLTexture[count];
		this.reuseWeight = reuseWeight;
		this.weights = (method == WEIGHTED) ? new int[count] : null;
	}

	private static int getMaxTextureUnits () {
		IntBuffer buffer = BufferUtils.newIntBuffer(16);
		if (Gdx.graphics.isGL20Available())
			Gdx.gl.glGetIntegerv(GL20.GL_MAX_TEXTURE_IMAGE_UNITS, buffer);
		else
			Gdx.gl.glGetIntegerv(GL10.GL_MAX_TEXTURE_UNITS, buffer);
		return buffer.get(0);
	}

	@Override
	public void begin () {
		for(int i = 0; i < count; i++) {
			textures[i] = null;
			if(weights != null) weights[i] = 0;
		}
	}

	@Override
	public void end () {
		/* No need to unbind and textures are set to null in begin()
		for(int i = 0; i < count; i++) {
			if (textures[i] != null) {
				Gdx.gl.glActiveTexture(GL20.GL_TEXTURE0 + offset + i);
				Gdx.gl.glBindTexture(GL20.GL_TEXTURE_2D, 0);
				textures[i] = null;
			}
		}*/
		Gdx.gl.glActiveTexture(GL20.GL_TEXTURE0);
	}
	
	@Override
	public final int bind(final TextureDescriptor textureDesc) {
		return bindTexture(textureDesc, false);
	}
	
	private final TextureDescriptor tempDesc = new TextureDescriptor();
	@Override
	public final int bind(final GLTexture texture) {
		tempDesc.set(texture, null, null, null, null);
		return bindTexture(tempDesc, false);
	}
	
	private final int bindTexture(final TextureDescriptor textureDesc, final boolean rebind) {
		final int idx, result;
		final GLTexture texture = textureDesc.texture;
		reused = false;
		
		switch (method) {
		case ROUNDROBIN: result = offset + (idx = bindTextureRoundRobin(texture)); break;
		case WEIGHTED: result = offset + (idx = bindTextureWeighted(texture)); break;
		default: return -1; 
		}
		
		if (reused) {
			reuseCount++;
			if (rebind)
				texture.bind(result);
			else
				Gdx.gl.glActiveTexture(GL10.GL_TEXTURE0 + result);
		} else
			bindCount++;
		texture.unsafeSetWrap(textureDesc.uWrap, textureDesc.vWrap);
		texture.unsafeSetFilter(textureDesc.minFilter, textureDesc.magFilter);
		return result;
	}

	private int currentTexture = 0;
	private final int bindTextureRoundRobin(final GLTexture texture) {
		for (int i = 0; i < count; i++) {
			final int idx = (currentTexture + i) % count;
			if (textures[idx] == texture) {
				reused = true;
				return idx;
			}
		}
		currentTexture = (currentTexture + 1) % count;
		textures[currentTexture] = texture;
		texture.bind(offset + currentTexture);
		return currentTexture;
	}
	
	private final int bindTextureWeighted(final GLTexture texture) {
		int result = -1;
		int weight = weights[0];
		int windex = 0;
		for (int i = 0; i < count; i++) {
			if (textures[i] == texture) {
				result = i;
				weights[i]+=reuseWeight;
			} else if (weights[i] < 0 || --weights[i] < weight) {
				weight = weights[i];
				windex = i;
			}
		}
		if (result < 0) {
			textures[windex] = texture;
			weights[windex] = 100;
			texture.bind(offset + (result = windex));
		} else 
			reused = true;
		return result;
	}
	
	@Override
	public final int getBindCount() { return bindCount; }
	
	@Override
	public final int getReuseCount() { return reuseCount; }
	
	@Override
	public final void resetCounts() { bindCount = reuseCount = 0; }
}