#include <exception>
#include <fstream>
#include <iostream>
#include <set>
#include <vector>

#include <fbxsdk.h>

void ConvertMesh(FbxMesh *fbxMesh, std::vector<short> &indices, std::vector<float> &vertices)
{
    if (!fbxMesh->IsTriangleMesh()) {
        throw std::exception("The mesh should be a triangle mesh");
    }

    for (int i = 0; i < fbxMesh->GetPolygonCount(); ++i) {
        for (int j = 0; j < 3; ++j) {
            short index = fbxMesh->GetPolygonVertex(i, j);
            indices.push_back(index);
        }
    }

    const FbxVector4 *controlPoints = fbxMesh->GetControlPoints();
    for (int i = 0; i < fbxMesh->GetControlPointsCount(); ++i) {
        const FbxVector4 &controlPoint = controlPoints[i];
        vertices.push_back(controlPoint[0]);
        vertices.push_back(controlPoint[1]);
        vertices.push_back(controlPoint[2]);
        vertices.resize(vertices.size() + 11);
    }
}

void ConvertMesh(const std::vector<short> &indices, const std::vector<float> &vertices, FbxMesh *mesh)
{
    int count = vertices.size() / 14;
    mesh->InitControlPoints(count);

    const float *verts = vertices.data();
    FbxVector4 *points = mesh->GetControlPoints();

    for (int i = 0; i < count; ++i) {
        float x = *verts++;
        float y = *verts++;
        float z = *verts++;
        verts += 11;
        points[i] = FbxVector4(x, y, z);
    }

    count = indices.size();
    for (int i = 0; i < count; i +=3) {
        mesh->BeginPolygon();
        for (int j = 0; j < 3; ++j) {
            int index = indices[i + j];
            mesh->AddPolygon(index);
        }
        mesh->EndPolygon();
    }
}

void ExportMesh(const char *source, const char *target)
{
    std::vector<short> indices;
    std::vector<float> vertices;

    FbxManager *sdkManager = FbxManager::Create();
    FbxIOSettings *ios = FbxIOSettings::Create(sdkManager, IOSROOT);
    sdkManager->SetIOSettings(ios);

    FbxImporter* importer = FbxImporter::Create(sdkManager, "");
    if (!importer->Initialize(source, -1, sdkManager->GetIOSettings()))
        throw std::exception("Call to FbxImporter::Initialize() failed.");

    FbxScene* scene = FbxScene::Create(sdkManager, "ImportedScene");
    importer->Import(scene);
    importer->Destroy();

    std::ofstream file;
    file.open(target, std::ios::out | std::ios::binary);
    file.write("mdl\0", 4);

    short minor = 1, major = 0;
    file.write((char*)&major, 2);
    file.write((char*)&minor, 2);

    FbxNode *root = scene->GetRootNode();
    for (int i = 0; i < root->GetChildCount(); ++i) {
        std::vector<short> indices;
        std::vector<float> vertices;
        FbxNode *child = root->GetChild(i);
        ConvertMesh(child->GetMesh(), indices, vertices);

        int chunkId = 1, size = indices.size() * 2, fmt = 31;
        file.write((char*)&chunkId, 4);
        file.write((char*)&size, 4);
        file.write((const char*)indices.data(), indices.size() * 2);

        size = vertices.size() * 4;
        file.write((char*)&fmt, 4);
        file.write((char*)&size, 4);
        file.write((const char*)vertices.data(), vertices.size() * 4);
    }

    file.close();
}

void ImportMesh(const char *source, const char *target)
{
    std::vector<short> indices;
    std::vector<float> vertices;

    std::ifstream file;
    file.open(source, std::ios::in | std::ios::binary);
    if (!file)
        throw std::exception("Can't open source file");

    int size;
    file.seekg(12, SEEK_CUR);
    file.read((char*)&size, 4);

    indices.resize(size);
    file.read((char*)&indices[0], size);

    file.seekg(4, SEEK_CUR);
    file.read((char*)&size, 4);
    vertices.resize(size);
    file.read((char*)&vertices[0], size);

    FbxManager *sdkManager = FbxManager::Create();
    FbxIOSettings *ios = FbxIOSettings::Create(sdkManager, IOSROOT);
    sdkManager->SetIOSettings(ios);

    FbxExporter* exporter = FbxExporter::Create(sdkManager, "");
    if (!exporter->Initialize(source, -1, sdkManager->GetIOSettings()))
        throw std::exception("Call to FbxImporter::Initialize() failed.");

    FbxScene *scene = FbxScene::Create(sdkManager, "ExportedScene");
    FbxNode *root = scene->GetRootNode();

    FbxNode *child = FbxNode::Create(sdkManager, "teapot");
    FbxMesh *mesh = FbxMesh::Create(scene, "teapot");

    ConvertMesh(indices, vertices, mesh);

    child->SetNodeAttribute(mesh);
    root->AddChild(child);

    exporter->Export(scene);
    exporter->Destroy();
}

int main(int argc, char *argv[])
{
    try {
        if (argc != 3) {
            throw std::exception("Invalid parameters passed.");
        }

#if 0
        ExportMesh(argv[1], argv[2]);
#elif 0
        ImportMesh(argv[2], argv[1]);
#else
        ExportMesh(argv[1], argv[2]);
        ImportMesh(argv[2], argv[1]);
#endif
    }
    catch (const std::exception &error) {
        std::clog << error.what() << std::endl;
    }
}

#include <engine/model.h>
#include <engine/platform.h>
#include <engine/renderer.h>

std::string vertexShaderSrc =
"\n\
attribute vec4 vertexPosition;\n\
uniform mat4 modelViewProj;\n\
void main()\n\
{\n\
  gl_Position = modelViewProj * vertexPosition;\n\
}\n\
\0";

std::string fragmentShaderSrc =
"\n\
void main()\n\
{\n\
  gl_FragColor = vec4(1.0, 0.5, 0.5, 1.0);\n\
}\n\
\0";

int main()
{
    Engine::Platform *platform = Engine::GetPlatform();
    if (!platform->CreateMainWindow())
        return -1;

    Engine::Renderer *renderer = Engine::GetRenderer();
    Engine::ModelManager *modelManager = Engine::GetModelManager();
    Engine::ModelPtr teapot = modelManager->GetModel("teapot");
    teapot->Load();
    Engine::HardwareBufferId hardwareBuffer = teapot->GetGraphicsShapes().at(0)->hardwareBufferId;

    Engine::Matrix4 proj, model, modelViewProj;
    proj.SetPerspective(1.3f, 1.78f, 1.0f, 100.0f);
    model.SetTranslation(Engine::Vector3(0, 0, -5.0f));
    modelViewProj = model * proj;

    size_t size = vertexShaderSrc.size();
    const Engine::Byte *pVertShaderData = reinterpret_cast<const Engine::Byte*>(vertexShaderSrc.data());
    Engine::ByteVector vertexSrc(pVertShaderData, pVertShaderData + size);

    size = fragmentShaderSrc.size();
    const Engine::Byte *pFragShaderData = reinterpret_cast<const Engine::Byte*>(fragmentShaderSrc.data());
    Engine::ByteVector fragSrc(pFragShaderData, pFragShaderData + size);

    auto progId = renderer->CreateGpuProgram(Engine::STATIC_VERTEX, vertexSrc, fragSrc);
    renderer->BindGpuProgram(progId);

    renderer->SetGpuProgramConstant(progId, "modelViewProj", modelViewProj);

    platform->SetMainWindowSize(1280, 720, false);
    renderer->SetViewport(1280, 720);

    for (;;) {
        if (!platform->UpdateMainWindow()) {
            break;
        }

        renderer->BeginRenderFrame();
        renderer->DrawHardwareBuffer(hardwareBuffer);
        renderer->EndRenderFrame();
    }

    renderer->DestroyGpuProgram(progId);
}