package min3d.parser;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import min3d.Min3d;
import min3d.Shared;
import min3d.animation.AnimationObject3d;
import min3d.animation.KeyFrame;
import min3d.vos.Number3d;
import min3d.vos.Uv;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.util.Log;

public class MD2Parser extends AParser implements IParser {
	private MD2Header header;
	private String currentTextureName;
	private KeyFrame[] frames;

	public MD2Parser(Resources resources, String resourceID, boolean generateMipMap) {
		super(resources, resourceID, generateMipMap);
	}

	@Override
	public AnimationObject3d getParsedAnimationObject() {
		Log.d(Min3d.TAG, "Start object creation");
		Bitmap texture = null;
		AnimationObject3d animObj;

		if (textureAtlas.hasBitmaps()) {
			textureAtlas.generate();
			texture = textureAtlas.getBitmap();
			Shared.textureManager().addTextureId(texture, textureAtlas.getId(), generateMipMap);
		}

		Log.d(Min3d.TAG, "Creating object " + co.name);
		animObj = co.getParsedObject(textureAtlas, materialMap, frames);

		if (textureAtlas.hasBitmaps()) {
			if (texture != null)
				texture.recycle();
		}
		Log.d(Min3d.TAG, "Object creation finished");

		super.cleanup();

		return animObj;
	}

	@Override
	public void parse() {
		InputStream fileIn = resources.openRawResource(resources.getIdentifier(
				resourceID, null, null));
		BufferedInputStream stream = new BufferedInputStream(fileIn);

		co = new ParseObjectData();
		header = new MD2Header();

		Log.d(Min3d.TAG, "Start parsing MD2 file");
		try {
			header.parse(stream);
			frames = new KeyFrame[header.numFrames];
			byte[] bytes = new byte[header.offsetEnd - 68];
			stream.read(bytes);
			getMaterials(stream, bytes);
			getTexCoords(stream, bytes);
			getFrames(stream, bytes);
			getTriangles(stream, bytes);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void getMaterials(BufferedInputStream stream, byte[] bytes)
			throws IOException {
		ByteArrayInputStream ba = new ByteArrayInputStream(bytes,
				header.offsetSkins - 68, bytes.length - header.offsetSkins);
		LittleEndianDataInputStream is = new LittleEndianDataInputStream(ba);
		try
		{
    		for (int i = 0; i < header.numSkins; i++) {
    			String skinPath = is.readString(64);
    			StringBuffer texture = new StringBuffer(packageID);
    			texture.append(":drawable/");
    
    			skinPath = skinPath.substring(skinPath.lastIndexOf("/") + 1,
    					skinPath.length());
    			StringBuffer textureName = new StringBuffer(skinPath.toLowerCase());
    			int dotIndex = textureName.lastIndexOf(".");
    			if (dotIndex > -1)
    				texture.append(textureName.substring(0, dotIndex));
    			else
    				texture.append(textureName);
    
    			currentTextureName = texture.toString();
    			textureAtlas.addBitmapAsset(new BitmapAsset(currentTextureName,
    					currentTextureName));
    		}
		} finally {
		    is.close();
		}
	}

	private void getTexCoords(BufferedInputStream stream, byte[] bytes)
			throws IOException {
		ByteArrayInputStream ba = new ByteArrayInputStream(bytes,
				header.offsetTexCoord - 68, bytes.length
						- header.offsetTexCoord);
		LittleEndianDataInputStream is = new LittleEndianDataInputStream(ba);
		try {
    		for (int i = 0; i < header.numTexCoord; i++) {
    			co.texCoords.add(new Uv((float)is.readShort() / (float)header.skinWidth, (float)is.readShort() / (float)header.skinHeight));
    		}
		} finally {
		    is.close();
		}
	}

	private void getFrames(BufferedInputStream stream, byte[] bytes)
			throws IOException {
		ByteArrayInputStream ba = new ByteArrayInputStream(bytes,
				header.offsetFrames - 68, bytes.length - header.offsetFrames);
		LittleEndianDataInputStream is = new LittleEndianDataInputStream(ba);
		//ArrayList<Number3d> firstFrameVerts = new ArrayList<Number3d>();
		try {
    		for (int i = 0; i < header.numFrames; i++) {
    			float scaleX = is.readFloat();
    			float scaleY = is.readFloat();
    			float scaleZ = is.readFloat();
    			float translateX = is.readFloat();
    			float translateY = is.readFloat();
    			float translateZ = is.readFloat();
    			String name = is.readString(16);
    			
    			if(name.indexOf("_") > 0)
    				name = name.subSequence(0, name.lastIndexOf("_")).toString();
    			else
    				name = name.substring(0, 6).replaceAll("[0-9]{1,2}$", "");
    			
    			Log.d(Min3d.TAG, "frame name: " + name);
    			float vertices[] = new float[header.numVerts * 3];
    			int index = 0;
    
    			for (int j = 0; j < header.numVerts; j++) {
    				vertices[index++] = scaleX * is.readUnsignedByte() + translateX;
    				vertices[index++] = scaleY * is.readUnsignedByte() + translateY;
    				vertices[index++] = scaleZ * is.readUnsignedByte() + translateZ;
    				
    				//int normalIndex = is.readUnsignedByte();
    				if (i == 0)
    					co.vertices.add(new Number3d(vertices[index - 3],
    							vertices[index - 2], vertices[index - 1]));
    			}
    
    			frames[i] = new KeyFrame(name, vertices);
    		}
		} finally {
		    is.close();
		}
	}

	private void getTriangles(BufferedInputStream stream, byte[] bytes)
			throws IOException {
		ByteArrayInputStream ba = new ByteArrayInputStream(bytes,
				header.offsetTriangles - 68, bytes.length
						- header.offsetTriangles);
		LittleEndianDataInputStream is = new LittleEndianDataInputStream(ba);
		try
		{
    		int[] indices = new int[header.numTriangles*3];
    		int index = 0;
    
    		for (int i = 0; i < header.numTriangles; i++) {
    			int[] vertexIDs = new int[3];
    			int[] uvIDS = new int[3];
    
    			indices[index+2] = vertexIDs[2] = is.readUnsignedShort();
    			indices[index+1] = vertexIDs[1] = is.readUnsignedShort();
    			indices[index] = vertexIDs[0] = is.readUnsignedShort();
    			index += 3;
    			uvIDS[2] = is.readUnsignedShort();
    			uvIDS[1] = is.readUnsignedShort();
    			uvIDS[0] = is.readUnsignedShort();
    
    			ParseObjectFace f = new ParseObjectFace();
    			f.v = vertexIDs;
    			f.uv = uvIDS;
    			f.hasn = f.hasuv = true;
    			f.faceLength = 3;
    			f.materialKey = currentTextureName;
    			co.numFaces++;
    			co.faces.add(f);
    			co.calculateFaceNormal(f);
    		}
    		
    		for(int j=0; j<header.numFrames; j++)
    		{
    			frames[j].setIndices(indices);
    		}
		} finally {
		    is.close();
		}
	}

	private class MD2Header {
		public int id;
		public int version;
		public int skinWidth;
		public int skinHeight;
		//public int frameSize;
		public int numSkins;
		public int numVerts;
		public int numTexCoord;
		public int numTriangles;
		//public int numGLCommands;
		public int numFrames;
		public int offsetSkins;
		public int offsetTexCoord;
		public int offsetTriangles;
		public int offsetFrames;
		//public int offsetGLCommands;
		public int offsetEnd;

		public void parse(InputStream stream) throws Exception {
			id = readInt(stream);
			version = readInt(stream);

			if (id != 844121161 || version != 8)
				throw new Exception("This is not a valid MD2 file.");

			skinWidth = readInt(stream);
			skinHeight = readInt(stream);
			/*frameSize = */readInt(stream);

			numSkins = readInt(stream);
			numVerts = readInt(stream);
			numTexCoord = readInt(stream);
			numTriangles = readInt(stream);
			/* numGLCommands = */readInt(stream);
			numFrames = readInt(stream);

			offsetSkins = readInt(stream);
			offsetTexCoord = readInt(stream);
			offsetTriangles = readInt(stream);
			offsetFrames = readInt(stream);
			/* offsetGLCommands = */readInt(stream);
			offsetEnd = readInt(stream);
		}
	}
}