#ifndef __MODELFORMAT_H__
#define __MODELFORMAT_H__

typedef struct
{
    float x, y, z, w;            // координаты вершины
    unsigned a, b;                // наверное diffuse и specular
    float u, v;                    // текстурные координаты
}    VERTEX_FORMAT;

typedef unsigned short INDEX_FORMAT;

typedef struct
{
    unsigned chunkId;            // идентификатор, всегда = 3
    unsigned vbsize;            // размер вертексного буфера
    unsigned unknown1;            // всегда = 2
    unsigned vcount;            // кол-во вертексов
}    VERTICES_CHUNK_HEADER;

typedef struct
{
    unsigned chunkId;            // идентификатор, всегда = 4
    unsigned ibsize;            // размер индексного буфера
    unsigned nindices;            // число индексов
}    INDICES_CHUNK_HEADER;

typedef struct
{
    unsigned chunkId;            // номер блока
    unsigned chunkSize;            // размер блока
    unsigned modelNum;            // порядковый номер модели
    unsigned length1;            // длина строки, всегда 64 байта
    char stringData[64];        // строка (crc32) ?
    unsigned unknown1;            // всегда = 2
    unsigned length2;            // длина строки
    char stringArray[1];        // название текстуры, материала, модели
}    STATIC_MODEL_CHUNK_HEADER;

typedef struct
{
    unsigned fileId;            // идентификатор
    unsigned fileSize;            // размер файла
}    STATIC_MODEL_FILE_HEADER;

#endif // __MODELFORMAT_H__

#ifndef __SCENEIMPORT_H__
#define __SCENEIMPORT_H__

#include <Max.h>
#include <sstream>

class CSceneImport : public SceneImport
{
public:
    CSceneImport();

    ~CSceneImport();

    int ExtCount();

    BOOL SupportsOptions(int  ext, DWORD  options );

    const char* Ext(int n);

    const char* LongDesc();

    const char* ShortDesc();

    const char* AuthorName();

    const char* CopyrightMessage();

    const char* OtherMessage1();

    const char* OtherMessage2();

    unsigned int Version();

    void ShowAbout(HWND hWnd);

    void loadModel( const char* name );

    void unloadModel();

    int DoImport(const char* pszName, ImpInterface* pImpInterface, Interface* pInterface, BOOL bPrompts = FALSE );

private:
    std::stringstream mStream;

}; // CSceneImport

#endif // __SCENEIMPORT_H__

#include <SceneImport.h>
#include <fstream>
#include <exception>
#include <locale>
#include <ModelFormat.h>

CSceneImport::CSceneImport()
{
}

CSceneImport::~CSceneImport()
{
    unloadModel();
}

int CSceneImport::ExtCount()
{
    return 1;
}

BOOL CSceneImport::SupportsOptions(int  ext, DWORD  options )
{
    return 0;
}

const char* CSceneImport::Ext(int n)
{
    return "model";
}

const char* CSceneImport::LongDesc()
{
    return "";
}

const char* CSceneImport::ShortDesc()
{
    return "";
}

const char* CSceneImport::AuthorName()
{
    return "";
}

const char* CSceneImport::CopyrightMessage()
{
    return "";
}

const char* CSceneImport::OtherMessage1()
{
    return "";
}

const char* CSceneImport::OtherMessage2()
{
    return "";
}

unsigned int CSceneImport::Version()
{
    return 100;
}

void CSceneImport::ShowAbout(HWND hWnd)
{
}

void CSceneImport::loadModel( const char* model )
{
    std::ifstream source;
    unsigned length;
    char *buffer;

    source.open( model, std::ios::binary );
    if( source.good() == 0 )
    {
        throw std::exception( "File not found" );
    }

    source.seekg( 0, std::ios::end );
    length = source.tellg();
    source.seekg( 0, std::ios::beg );

    buffer = new char[length];
    source.read( buffer, length );

    mStream.write( buffer, length );

    delete buffer;
    source.close();
}

void CSceneImport::unloadModel()
{
    mStream.clear();
}

int CSceneImport::DoImport(const char* pszName, ImpInterface* pImpInterface, Interface* pInterface, BOOL bPrompts )
{
    try
    {
        STATIC_MODEL_FILE_HEADER fileHeader;
        STATIC_MODEL_CHUNK_HEADER chunkHeader;
        INDICES_CHUNK_HEADER indicesHeader;
        VERTICES_CHUNK_HEADER verticesHeader;
        VERTEX_FORMAT* vertices;
        INDEX_FORMAT* indices;

        unsigned filePtr;

        setlocale( LC_ALL, ".1251" );

        loadModel( pszName );

        filePtr = sizeof(STATIC_MODEL_FILE_HEADER);
        mStream.read( reinterpret_cast<char*>(&fileHeader), filePtr );

        while( filePtr < fileHeader.fileSize )
        {
            mStream.read( reinterpret_cast<char*>(&chunkHeader), sizeof(STATIC_MODEL_CHUNK_HEADER) );
            mStream.seekg( chunkHeader.length2-4, std::ios::cur );
            mStream.read( reinterpret_cast<char*>(&verticesHeader), sizeof(VERTICES_CHUNK_HEADER) );

            vertices = new VERTEX_FORMAT[verticesHeader.vcount];
            mStream.read( reinterpret_cast<char*>(vertices), verticesHeader.vbsize-8 );

            mStream.read( reinterpret_cast<char*>(&indicesHeader), sizeof(INDICES_CHUNK_HEADER) );

            indices = new INDEX_FORMAT[indicesHeader.nindices];
            mStream.read( reinterpret_cast<char*>(indices), indicesHeader.ibsize );

            ImpNode* node = pImpInterface->CreateNode();
            node->SetName( "test" );

            TriObject* obj = CreateNewTriObject();

            // ...

            node->Reference( obj );

            pImpInterface->AddNodeToScene( node );

            delete indices;
            delete vertices;

            filePtr += chunkHeader.chunkSize;
        }

        unloadModel();

        return IMPEXP_SUCCESS;
    }
    catch( ... )
    {
        return 0;
    }
}

#ifndef __MetroModelReader_h__
#define __MetroModelReader_h__

#include <string>

struct MetroModelVertex
{
    Point3    pos;
    union {
        struct { DWORD a, b; };
        struct { float fa, fb; };
    };
    Point3    normal;
};

typedef unsigned short MetroModelIndex;

class CMetroModelReader
{
public:
    CMetroModelReader();
    ~CMetroModelReader();

    int OpenModelFile(const std::string& fileName);
    int MakeMaxMesh(Mesh* mesh);

private:

    void ReadChunk(unsigned int chunkID, unsigned int chunkSize, FILE* file);

    unsigned int        m_VBSize;
    unsigned int        m_IBSize;

    unsigned int        m_NumVerteces;
    unsigned int        m_NumIndeces;

    MetroModelVertex    *m_VBPtr;
    MetroModelIndex        *m_IBPtr;
};

#endif    // __MetroModelReader_h__

#include "Metro2033MeshImport.h"
#include "MetroModelReader.h"


#define METRO_CHUNK_NULL            0x00000000    // iOrange - ????
#define METRO_CHUNK_UNKNOWN            0x00000001    // iOrange - ????
#define METRO_CHUNK_MATERIALS        0x00000002    // iOrange - some materials names
#define METRO_CHUNK_VERTEXDATA        0x00000003    // iOrange - vertex data chunk
#define METRO_CHUNK_INDEXDATA        0x00000004    // iOrange - indexes data chunk

#define METRO_CHUNK_IGNORETHIS        0x00000009    // iOrange - it seems that need to be ignored


CMetroModelReader::CMetroModelReader()
    : m_VBSize(0)
    , m_IBSize(0)
    , m_NumVerteces(0)
    , m_NumIndeces(0)
    , m_VBPtr(NULL)
    , m_IBPtr(NULL)
{
}
CMetroModelReader::~CMetroModelReader()
{
}

int CMetroModelReader::OpenModelFile(const std::string& fileName)
{
    FILE* file = NULL;
    fopen_s(&file, fileName.c_str(), "rb");
    if (!file)
        return FALSE;

    unsigned int chunkID, chunkSize;
    while (!feof(file))
    {
        fread(&chunkID, 4, 1, file);
        fread(&chunkSize, 4, 1, file);

        ReadChunk(chunkID, chunkSize, file);

        if (METRO_CHUNK_INDEXDATA == chunkID)
            break;
    }

    fclose(file);

    return TRUE;
}


void CMetroModelReader::ReadChunk(unsigned int chunkID, unsigned int chunkSize, FILE* file)
{
    switch (chunkID)
    {
        //    iOrange - just ignore these chunks to be ignored
        case METRO_CHUNK_NULL:
        case METRO_CHUNK_IGNORETHIS:
            return;

        case METRO_CHUNK_MATERIALS:
        {
            //std::cout << "Found materials chunk" << std::endl << "\tSize = " << chunkSize << std::endl;
        } break;

        case METRO_CHUNK_VERTEXDATA:
        {
            //std::cout << "Found vertexdata chunk" << std::endl << "\tSize = " << chunkSize << std::endl;

            unsigned int stub0 = 0;
            fread(&stub0, 4, 1, file);
            fread(&m_NumVerteces, 4, 1, file);

            m_VBPtr = new MetroModelVertex[m_NumVerteces];
            fread(m_VBPtr, m_NumVerteces * sizeof(MetroModelVertex), 1, file);
        } return;

        case METRO_CHUNK_INDEXDATA:
        {
            //std::cout << "Found indexdata chunk" << std::endl << "\tSize = " << chunkSize << std::endl;

            fread(&m_NumIndeces, 4, 1, file);

            m_IBPtr = new MetroModelIndex[m_NumIndeces];
            fread(m_IBPtr, m_NumIndeces * sizeof(MetroModelIndex), 1, file);
        } return;

        default:
            //std::cout << "Found unknown chunk id = " << ext::Hex(8) << chunkID << ", size = " << chunkSize << std::endl;
            break;
    }

    fseek(file, chunkSize, SEEK_CUR);
}