#ifndef __ODE_UTIL_STL_READER_H_
#define __ODE_UTIL_STL_READER_H_

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

namespace ode_util {

template<typename V_TYPE=float,typename IDX_TYPE=int>
class StlReader
{
public:
    typedef V_TYPE vertex_type;
    typedef IDX_TYPE index_type;
private:
    static const int head_size = 80;
    struct st_vec3f {
        float x; float y; float z;
    };
    struct st_param3f {
        st_vec3f n; st_vec3f v1; st_vec3f v2; st_vec3f v3;
    };

    // member
    char          *m_header;
    unsigned int   m_triNum;
    vertex_type   *m_vertices;
    index_type    *m_indices;

public:
    // constructor
    StlReader( const char* file_name )
        : m_header(NULL)
        , m_triNum(0)
        , m_vertices(NULL)
        , m_indices(NULL)
    {
        FILE *fp = fopen( file_name, "rb" );
        if (fp == NULL) {
            fprintf( stderr, "StlReader : can not open file.\n" );
            fprintf( stderr, "file : %s\n", file_name );
            exit(1);
        }

        st_param3f param;
        short int blank;

        int fsz;
        fseek( fp, 0, SEEK_END );
        fsz = ftell( fp );
        fseek(fp, 0, SEEK_SET );

        m_header = new char[head_size];

        // header
        fread( m_header, sizeof(char), head_size, fp );
        fread( &m_triNum, sizeof(unsigned int), 1, fp );

        m_vertices = new vertex_type[3*3*m_triNum];
        m_indices = new index_type[3*m_triNum];

        if (fsz < (int)(head_size+4+(sizeof(st_param3f)+2)*m_triNum-2)) {
            fprintf( stderr, "StlReader : error, %s", file_name );
            fprintf( stderr, "This file don't support file size.\n" );
            fprintf( stderr, "file size : %d bytes, trace size=%d bytes\n",
                    fsz, 80+4+(sizeof(st_param3f)+2)*m_triNum );
            exit(1);
        }

        for (int i=0; i<(int)m_triNum; i++) {
            fread( &param, sizeof(st_param3f), 1, fp );
            fread( &blank, sizeof(short int), 1, fp );
            m_vertices[i*3*3+0] = (vertex_type)param.v1.x;
            m_vertices[i*3*3+1] = (vertex_type)param.v1.y;
            m_vertices[i*3*3+2] = (vertex_type)param.v1.z;
            m_vertices[i*3*3+3] = (vertex_type)param.v2.x;
            m_vertices[i*3*3+4] = (vertex_type)param.v2.y;
            m_vertices[i*3*3+5] = (vertex_type)param.v2.z;
            m_vertices[i*3*3+6] = (vertex_type)param.v3.x;
            m_vertices[i*3*3+7] = (vertex_type)param.v3.y;
            m_vertices[i*3*3+8] = (vertex_type)param.v3.z;
        }

        for (int i=0; i<(int)m_triNum*3; i++) {
            m_indices[i] = i;
        }

        //printf( "header  : %s\n", m_header );
        //printf( "m_triNum : %d\n", m_triNum );

        //printf( "size = %d\n", sizeof(st_param3f) );

        fclose( fp );
    }

    ~StlReader()
    {
        if (m_header) delete [] m_header;
        if (m_vertices) delete [] m_vertices;
        if (m_indices) delete [] m_indices;
    }

    const vertex_type* getVertices() {
        return m_vertices;
    }

    const index_type* getIndices() {
        return (const index_type*)m_indices;
    }

    int getVertexCount() {
        return (int)m_triNum*3;
    }

    int getIndexCount() {
        return (int)m_triNum*3;
    }
};

}; // namespace ode_util;


//int main( int argc, char *argv[] )
//{
//    using namespace ode_util;
//    //const char* file_name = "cube-binary.stl";
//    //const char* file_name = "box.stl";
//
//    StlReader<> *stl = new StlReader<>( "box.stl" );
//
//    printf( "vertex cnt = %d\n", stl->getVertexCount() );
//    printf( "index cnt = %d\n", stl->getIndexCount() );
//
//    return 0;
//}


#endif