#include <stdio.h>
#include <stdlib.h>
#include "dff.h"

void ReadBinMeshPS2(geometry *geo, FILE *dff)
{
	int i;

	fread(&geo->facetype, 4, 1, dff);
	fread(&geo->splitcount, 4, 1, dff);
	fread(&geo->indexcount, 4, 1, dff);
	       
	/* Loop through splits.
	 * PC Version uses index here, PS2 not.
	*/
	geo->splt = (split *) malloc(geo->splitcount*sizeof(split));
	for (i = 0; i < geo->splitcount; i++) {
		fread(&geo->splt[i].indexcount, 4, 1, dff);
		fread(&geo->splt[i].matindex, 4, 1, dff);
	}
}

void ReadNativeDataSAPS2(geometry *geo, FILE *dff)
{
	int i, j, k;
	int unk;
	int doubleflag;
	split *cursplit;
	int blocksize, nextblock;
	short comp_vert[4];

	/* Struct - incorrect size in header */
	ReadHeader(dff);
	fseek(dff, 4, SEEK_CUR);	/* Skip 04 00 00 00 */
	
	for (i = 0; i < geo->splitcount; i++) {
		cursplit = &geo->splt[i];
		cursplit->saindexcount = cursplit->indexcount;

		fread(&blocksize, 4, 1, dff);
		nextblock = blocksize + 4 + ftell(dff);
		fseek(dff, 8, SEEK_CUR);
		fread(&unk, 4, 1, dff);
		fseek(dff, unk*16-8, SEEK_CUR);

		cursplit->savertices=(float **)malloc(cursplit->saindexcount*4);
		cursplit->sauv[0] = (float **)malloc(cursplit->saindexcount*4);
		cursplit->sanormals =(float **)malloc(cursplit->saindexcount*4);
		cursplit->savc = (unsigned char **)malloc(cursplit->saindexcount*4);
		cursplit->saflags = (int *) malloc(cursplit->saindexcount*4);

		doubleflag = 0;
		for (j = 0; j < cursplit->saindexcount; j++) {
			cursplit->savertices[j] = (float *)
			  malloc(3 * sizeof(float));

			fread(&comp_vert, 4, 2, dff);
//			cursplit->savertices[j][0] = (float) comp_vert[0] / 128;
//			cursplit->savertices[j][1] = (float) comp_vert[1] / 128;
//			cursplit->savertices[j][2] = (float) comp_vert[2] / 128;
			cursplit->savertices[j][0] = (float) comp_vert[0]/ 1024;
			cursplit->savertices[j][1] = (float) comp_vert[1]/ 1024;
			cursplit->savertices[j][2] = (float) comp_vert[2]/ 1024;
			cursplit->saflags[j] = comp_vert[3];
			cursplit->saflags[j] &= 0x0000ffff;
			if (cursplit->saflags[j] == 0x8000)
				doubleflag++;
		}
		cursplit->indexcount = cursplit->saindexcount + doubleflag;
		
		cursplit->vertices = (float **) malloc(cursplit->indexcount*4);
		cursplit->uv[0] = (float **)malloc(cursplit->indexcount*4);
		cursplit->normals =(float **)malloc(cursplit->indexcount*4);
		cursplit->vc = (unsigned char **)malloc(cursplit->indexcount*4);

		for (j = 0, k = 0; j < cursplit->saindexcount; j++, k++) {
			cursplit->vertices[k] =(float *)malloc(3*sizeof(float));
			cursplit->uv[0][k] = (float *) malloc(2*sizeof(float));
			cursplit->normals[k] = (float *)malloc(3*sizeof(float));
			cursplit->vc[k] = (unsigned char *)malloc(4*1);

			cursplit->vertices[k][0] = cursplit->savertices[j][0];
			cursplit->vertices[k][1] = cursplit->savertices[j][1];
			cursplit->vertices[k][2] = cursplit->savertices[j][2];

			/* Convert the double face flag to a second face
			 * so the vertex data is in the same format like
			 * PC and VC PS2 format. */
			if (cursplit->saflags[j+1] == 0x8000) {
				k++;
				cursplit->vertices[k] =(float *)malloc(3*sizeof(float));
				cursplit->uv[0][k] = (float *) malloc(2*sizeof(float));
				cursplit->normals[k] = (float *)malloc(3*sizeof(float));
				cursplit->vc[k] = (unsigned char *)malloc(4*1);


				cursplit->vertices[k][0] = cursplit->savertices[j][0];
				cursplit->vertices[k][1] = cursplit->savertices[j][1];
				cursplit->vertices[k][2] = cursplit->savertices[j][2];
			}
		}

		cursplit->vertexcount = cursplit->indexcount;
		fseek(dff, nextblock, 0);
	}
}

void ReadNativeDataVCPS2(geometry *geo, FILE *dff)
{
	int i, l, k;
	split *cursplit;
	int blockvertcount;
	int isnotactor;
	int islast;
	int subsecthdr;
	int splitsize, nextsplit;
	char normal;
	float normscale;
	FILE *log;

	/* could also be 127 or 126 */
	normscale = 1/126.076126092;

	if ((log = fopen("log.txt", "w")) == NULL) {
		fprintf(stderr, "Couldn't open log file\n");
		exit(1);
	}

	/* Struct - incorrect size in header */
	ReadHeader(dff);
	fprintf(log, "Native Data Struct: %lX\n", ftell(dff));
	fseek(dff, 4, SEEK_CUR);	/* Skip 04 00 00 00 */

	for (i = 0; i < geo->splitcount; i++) {
		cursplit = &geo->splt[i];

		fread(&splitsize, 4, 1, dff);
		nextsplit = splitsize + ftell(dff) + 4;

		fread(&isnotactor, 4, 1, dff);
		if (isnotactor)
			fseek(dff, 16, SEEK_CUR);

		cursplit->vertices = (float **) malloc(4);
		cursplit->uv[0] = (float **) malloc(4);
		cursplit->vc = (unsigned char **) malloc(4);
		cursplit->normals = (float **) malloc(4);

	/* Loop through blocks */
		cursplit->vertexcount = 0;
		for (l = 0, islast = 0; !islast; l++) {
			if (!isnotactor)	/* is actor */
				fseek(dff, 48, SEEK_CUR);
	/* */
	/* Vertices */
	/* */
	/* get vertex count in format: 00 80 vertex count 68 */
			fprintf(log, "Vertex header at: %lX\n", ftell(dff));
			fseek(dff, 12, SEEK_CUR);
			fread(&subsecthdr, 4, 1, dff);
			if ((subsecthdr & 0xff00ffff) != 0x68008000) {
				fprintf(stderr, "Vertex section not found\n");
				exit(3);
			}
			blockvertcount = (subsecthdr & 0x00ff0000) >> 16;

	/* read Vertices */
	/* Add block vertex count to total split vertex count
	 * and allocate enough space */
			cursplit->vertexcount += blockvertcount;
			cursplit->vertices = (float **)
			  realloc(cursplit->vertices, cursplit->vertexcount*4);

			for (k = cursplit->vertexcount-blockvertcount;
			  k < cursplit->vertexcount; k++) {
				cursplit->vertices[k] = (float *) malloc(3*4);

				fread(&cursplit->vertices[k][X], 4, 1, dff);
				fread(&cursplit->vertices[k][Y], 4, 1, dff);
				fread(&cursplit->vertices[k][Z], 4, 1, dff);
			}
			if ((blockvertcount*12 % 16) != 0)
				fseek(dff, 16 - (blockvertcount*12
				  % 16), SEEK_CUR); /* skip padding */



	/* */
	/* UV Coordinates */
	/* */
	/* get vertex count in format: 01 80 vertex count 64 */
			fprintf(log, "UV header at: %lX\n", ftell(dff));
			fseek(dff, 12, SEEK_CUR);
			fread(&subsecthdr, 4, 1, dff);
			if ((subsecthdr & 0xff00ffff) != 0x64008001) {
				fprintf(stderr, "UV section not found\n");
				exit(3);
			}


	/* read UV Coordinates */
			cursplit->uv[0] = (float **)
			  realloc(cursplit->uv[0], cursplit->vertexcount*4);

			for (k = cursplit->vertexcount-blockvertcount;
			  k < cursplit->vertexcount; k++) {
				cursplit->uv[0][k] = (float *) malloc(2*4);

				fread(&cursplit->uv[0][k][U], 4, 1, dff);
				fread(&cursplit->uv[0][k][V], 4, 1, dff);
			} 
			if ((blockvertcount*8 % 16) != 0)
				fseek(dff, 16 - (blockvertcount*8
				  % 16), SEEK_CUR); /* skip padding */

	/* */
	/* Vertexcolors */
	/* */
	/* get vertex count in format: 02 C0 vertex count 6E */
			fprintf(log, "Vertex color header at: %lX\n",
			  ftell(dff));
			fseek(dff, 12, SEEK_CUR);
			fread(&subsecthdr, 4, 1, dff);
			if ((subsecthdr & 0xff00ffff) != 0x6E00C002) {
				fprintf(stderr,
				  "Vertexcolor section not found\n");
				exit(3);
			}

	/* read Vertexcolors */
			cursplit->vc = (unsigned char **)
			  realloc(cursplit->vc, cursplit->vertexcount*4);

			for (k = cursplit->vertexcount-blockvertcount;
			  k < cursplit->vertexcount; k++) {
				cursplit->vc[k] = (unsigned char *) malloc(1*4);

				cursplit->vc[k][R] = getc(dff);
				cursplit->vc[k][G] = getc(dff);
				cursplit->vc[k][B] = getc(dff);
				cursplit->vc[k][A] = getc(dff);
			}

			if ((blockvertcount*4 % 16) != 0)
				fseek(dff, 16 - (blockvertcount*4
				  % 16), SEEK_CUR); /* skip padding */


	/* */
	/* Normals */
	/* */
	/* get vertexcount in format: 03 80 vertexcount 6A */
			fprintf(log, "Normal header at:%lX\n", ftell(dff));
			fseek(dff, 12, SEEK_CUR);
			fread(&subsecthdr, 4, 1, dff);
			if ((subsecthdr & 0xff00ffff) != 0x6A008003) {
				fprintf(stderr, "Normal section not found\n");
				exit(3);
			}

	/* read Normals */
			cursplit->normals = (float **)
			  realloc(cursplit->normals, cursplit->vertexcount*4);

			for (k = cursplit->vertexcount-blockvertcount;
			  k < cursplit->vertexcount; k++) {
				cursplit->normals[k] = (float *) malloc(3*4);

				normal = getc(dff);
				cursplit->normals[k][X] = normal * normscale;
				normal = getc(dff);
				cursplit->normals[k][Y] = normal * normscale;
				normal = getc(dff);
				cursplit->normals[k][Z] = normal * normscale;
			}
			if ((blockvertcount*3 % 16) != 0)
				fseek(dff, 16 - (blockvertcount*3
				  % 16), SEEK_CUR); /* skip padding */

			
	/* skip end of block, but read if this block was the last */
			fseek(dff, 8, SEEK_CUR);
			fread(&islast, 4, 1, dff);
			if (islast == 0x11000000)
				islast = 1;
			else
				islast = 0;
			fseek(dff, 4, SEEK_CUR);
			fprintf(log, "Split end: %d\n\n", islast);
		}

	/* Jump to next split and skip unknowns */
		fseek(dff, nextsplit, 0);
	}
}