/* 3dsloader.c : a small library to load a subset of the 3DS model format */
/* This software is PUBLIC DOMAIN as of January 2006. No copyright is claimed.
 * - Jon Mayo <jmayo@rm-f.net> */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "fileio.h"
#include "model.h"
#include "logger.h"

enum chunk_id {
	CHUNK_M3DMAGIC=0x4d4d,
		CHUNK_M3D_VERSION=0x0002,
		CHUNK_MDATA=0x3d3d,
			CHUNK_COLOR_F=0x0010,
			CHUNK_COLOR_24=0x0011,
			CHUNK_MAT_ENTRY=0xafff,
				CHUNK_MAT_NAME=0xa000,
				CHUNK_MAT_AMBIENT=0xa010,
				CHUNK_MAT_DIFFUSE=0xa020,
				CHUNK_MAT_SPECULAR=0xa030,
				CHUNK_MAT_SHININESS=0xa040,
				CHUNK_MAT_SNIN2PCT=0xa041,
				CHUNK_MAT_TRANSPARENCY=0xa050,
				CHUNK_MAT_XPFALL=0xa052,
				CHUNK_MAT_USE_XPFALL=0xa240,
				CHUNK_MAT_REFBLUR=0xa053,
				CHUNK_MAT_SHADING=0xa100,
				CHUNK_MAT_WIRESIZE=0xa087,
			CHUNK_MESH_VERSION=0x3d3e,
			CHUNK_NAMED_OBJECT=0x4000,
				CHUNK_N_TRI_OBJECT=0x4100,
					CHUNK_POINT_ARRAY=0x4110,
					CHUNK_FACE_ARRAY=0x4120,
					CHUNK_TEX_VERTS=0x4140,
					CHUNK_MESH_MATRIX=0x4160,
			CHUNK_MASTER_SCALE=0x0100,
			CHUNK_INT_PERCENTAGE=0x0030,
	CHUNK_KFDATA=0xb000, /* Keyframe data */
};

struct state_3ds {
	long file_size;
	struct model *model;
	struct object *current_object;
};

static void free_state(struct state_3ds *m) {
	model_free(m->model);
	m->model=0;
}

static int swallow(FILE *f, long bytes) {
	if(fseek(f, bytes, SEEK_CUR)!=0) {
        LOG_DEBUG("%s:%d:", __FILE__, __LINE__);
		perror("fseek()");
		return 0;
	}
	return 1;
}

static int read3ds_chunk_header(FILE *f, const char *filename, enum chunk_id *chunk_id, size_t *chunk_len) {
	uint16_t chunk_id_data;
	uint32_t chunk_len_data;
	if( read_u2le(f, filename, 1, &chunk_id_data)
	&& read_u4le(f, filename, &chunk_len_data)) {
		*chunk_id=chunk_id_data;
		*chunk_len=chunk_len_data-6;
		if(chunk_len_data<6) {
			LOG_INFO("%s:short chunk\n", filename);
			return 0;
		}
		return 1;
	}
    LOG_DEBUG("%s:%d:", __FILE__, __LINE__);
	perror(filename);
	return 0;
}

static int read_point_array(struct state_3ds *m, FILE *f, const char *filename, long len) {
	float point[3];
	uint16_t count;
	unsigned i;

	if(!read_u2le(f, filename, 1, &count)) {
		return 0;
	}
	if(len!=count*4*3+2) {
		LOG_INFO("%s: corrupt POINT_ARRAY chunk\n", filename);
		return 0;
	}

	for(i=0;i<count;i++) {
		if(!read_fle(f, filename, point+0)
			|| !read_fle(f, filename, point+1)
			|| !read_fle(f, filename, point+2)) {
			return 0;
		}
		model_object_vertex_add(m->current_object, point[0], point[1], point[2]);
	}
	return 1;
}

static int read_face_array(struct state_3ds *m, FILE *f, const char *filename, long len) {
	enum chunk_id chunk_id;
	size_t chunk_len;
	long start;
	uint16_t nr_face;
	int i;
	
	start=ftell(f);
	LOG_INFO("%s:FACE_ARRAY start\n", filename);

	if(!read_u2le(f, filename, 1, &nr_face)) {
		return 0;
	}
	LOG_INFO("%s:FACE_ARRAY nr_face=%d\n", filename, (int)nr_face);
	for(i=0;i<nr_face;i++) {
		uint16_t face[4];
		if(!read_u2le(f, filename, 4, face))
			return 0;
		model_object_face_add(m->current_object, face[0], face[1], face[2]);
	}

	while((ftell(f)-start)<len) {
		if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len)) {
			LOG_INFO("%s:premature end of chunk\n", filename);
			return 0;
		}
		switch(chunk_id) {
			default:
				LOG_INFO("FACE_ARRAY: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
				if(!swallow(f, chunk_len)) return 0;
		}
	}	
	LOG_INFO("%s:FACE_ARRAY end\n", filename);
	return 1;
}

static int read_n_tri_object(struct state_3ds *m, FILE *f, const char *filename, long len) {
	enum chunk_id chunk_id;
	size_t chunk_len;
	long start;
	
	start=ftell(f);
	LOG_INFO("%s:N_TRI_OBJECT start\n", filename);

	while((ftell(f)-start)<len) {
		if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len)) {
			LOG_INFO("%s:premature end of chunk\n", filename);
			return 0;
		}
		switch(chunk_id) {
			case CHUNK_POINT_ARRAY:
				if(!read_point_array(m, f, filename, chunk_len))
					return 0;
				break;
			case CHUNK_FACE_ARRAY:
				if(!read_face_array(m, f, filename, chunk_len))
					return 0;
				break;
			default:
				LOG_INFO("N_TRI_OBJECT: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
				if(!swallow(f, chunk_len)) return 0;
		}
	}	
	LOG_INFO("%s:N_TRI_OBJECT end\n", filename);
	return 1;
}

static int read_named_object(struct state_3ds *m, FILE *f, const char *filename, long len) {
	enum chunk_id chunk_id;
	size_t chunk_len;
	long start;
	char name[11];

	start=ftell(f);
	LOG_INFO("%s:NAMED_OBJECT start\n", filename);

	if(!read_asciiz(f, filename, sizeof name, name)) 
		return 0;
	LOG_INFO("NAMED_OBJECT: name='%s'\n", name);
	m->current_object=model_object_create(m->model, name, 0);
	while((ftell(f)-start)<len) {
		if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len)) {
			LOG_INFO("%s:premature end of chunk\n", filename);
			return 0;
		}
		switch(chunk_id) {
			case CHUNK_N_TRI_OBJECT:
				if(!read_n_tri_object(m, f, filename, chunk_len))
					return 0;
				break;
			default:
				LOG_INFO("NAMED_OBJECT: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
				if(!swallow(f, chunk_len)) return 0;
		}
	}	
	LOG_INFO("%s:NAMED_OBJECT end\n", filename);
	m->current_object=0;
	return 1;
}

static int read_mat_entry(struct state_3ds *m, FILE *f, const char *filename, long len) {
	enum chunk_id chunk_id;
	size_t chunk_len;
	long start;
	start=ftell(f);
	LOG_INFO("%s:MAT_ENTRY start\n", filename);
	while((ftell(f)-start)<len) {
		if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len)) {
			LOG_INFO("%s:premature end of chunk\n", filename);
			goto failure;
		}
		/* LOG_INFO("MAT_ENTRY: id: 0x%04X len: %zu ofs: %ld\n", chunk_id, chunk_len, ftell(f)); */
		switch(chunk_id) {
			default:
				LOG_INFO("MAT_ENTRY: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
				if(!swallow(f, chunk_len)) goto failure;
		}
	}	
	LOG_INFO("%s:MAT_ENTRY end : success\n", filename);
	return 1;
	failure:
	LOG_INFO("%s:MAT_ENTRY end : failure\n", filename);
	return 0;

}

static int read_mdata(struct state_3ds *m, FILE *f, const char *filename, long len) {
	enum chunk_id chunk_id;
	size_t chunk_len;
	long start;
	start=ftell(f);
	while((ftell(f)-start)<len) {
		if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len)) {
			LOG_INFO("%s:premature end of chunk\n", filename);
			return 0; /* error or EOF */
		}
		switch(chunk_id) {
			case CHUNK_MESH_VERSION: {
				uint32_t version;
				if(chunk_len!=4) {
					if(!swallow(f, chunk_len)) return 0;
				}
				if(!read_u4le(f, filename, &version))
					return 0;
				LOG_INFO("MDATA: Mesh version = %u\n", version);
			break;
			}
			case CHUNK_MAT_ENTRY: 
				if(!read_mat_entry(m, f, filename, chunk_len)) return 0;
				break;
			case CHUNK_NAMED_OBJECT:
				if(!read_named_object(m, f, filename, chunk_len)) return 0;
				break;
			case CHUNK_MASTER_SCALE: {
				float scale;
				if(chunk_len!=4) {
					if(!swallow(f, chunk_len)) return 0;
				}
				if(!read_fle(f, filename, &scale))
					return 0;
				LOG_INFO("MDATA: Master scale = %f\n", scale);
			break;
			}
			default:
				LOG_INFO("MDATA: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
				if(!swallow(f, chunk_len)) return 0;
		}
	}	
	LOG_INFO("%s:MDATA success\n", filename);
	return 1;
}

static int read_main3ds(struct state_3ds *m, FILE *f, const char *filename, long len) {
	enum chunk_id chunk_id;
	size_t chunk_len;
	long start;
	start=ftell(f);
	while((ftell(f)-start)<len) {
		if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len)) 
			return 0;
		switch(chunk_id) {
			case CHUNK_M3D_VERSION: {
					uint32_t version;
					if(chunk_len!=4) {
						LOG_INFO("MAIN3DS: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
						if(!swallow(f, chunk_len)) return 0;
					}
					if(!read_u4le(f, filename, &version))
						return 0;
					LOG_INFO("%s: 3DS format version=%u\n", filename, version);
				}
			break;
			case CHUNK_MDATA:
				if(!read_mdata(m, f, filename, chunk_len)) return 0;
			break;
			default:
				LOG_INFO("MAIN3DS: ignoring chunk 0x%04X (len: %zu ofs: %ld)\n", chunk_id, chunk_len, ftell(f));
				if(!swallow(f, chunk_len)) return 0;
		}
	}
    LOG_INFO("MAIN3DS: success %lu=%lu\n", len+start, ftell(f));
	return 1;
}

struct model *load_3ds(const char *filename) {
	struct state_3ds m;
	FILE *f;
	enum chunk_id chunk_id;
	size_t chunk_len;

	f=fopen(filename, "rb");
	if(!f) {
        LOG_DEBUG("%s:%d:", __FILE__, __LINE__);
		perror(filename);
		return 0;
	}
	m.model=model_create();

    if(!read3ds_chunk_header(f, filename, &chunk_id, &chunk_len))
        goto failure;

    LOG_INFO("id: 0x%04X len: %zu\n", chunk_id, chunk_len);
    if(chunk_id!=CHUNK_M3DMAGIC) 
        goto failure;
    m.file_size=chunk_len+6;
    if(!read_main3ds(&m, f, filename, chunk_len)) 
        goto failure;

#ifdef NDEBUG
    if(!model_verify(m.model)) 
        goto failure;
#endif
	if(ftell(f) == m.file_size) {
		struct model *ret;
		fclose(f);
		ret=m.model;
		m.model=0;
		free_state(&m);
		return ret;
	}

	failure:
	LOG_INFO("%s: failed to load\n", filename);
	fclose(f);
	free_state(&m);
	return 0;
}