namespace Engine
{
    class Shader
    {
    public:
        virtual ~Shader() {}

        virtual void Compile(const String &shaderName, bool isDynamic) = 0;

        virtual void Draw(GraphicsShapePtr shape) = 0;

        virtual void SetWorldViewProj(const Matrix4 &worldViewProj) = 0;
    };

    Shader *GetShader();
}

const char geomVertexShader[] =
"\
layout(location = 1) in vec4 vertexPosition;\n\
layout(location = 2) in vec4 vertexNormal;\n\
layout(location = 3) in vec4 vertexTangent;\n\
layout(location = 4) in vec4 vertexBinormal;\n\
layout(location = 5) in vec2 vertexTexcoords;\n\
layout(location = 6) in uint bones;\n\
layout(location = 7) in vec4 weights;\n\
out vec2 texCoords;\n\
uniform mat4 worldViewProj;\n\
void main()\n\
{\n\
    gl_Position = worldViewProj * vertexPosition;\n\
    texCoords = vertexTexcoords;\n\
}\n\
\0";

const char geomFragmentShader[] =
"\
in vec2 texCoords;\n\
out vec4 color;\n\
#ifdef DIFFUSE_MAP\n\
uniform sampler2D diffuseMap;\n\
#endif\n\
void main()\n\
{\n\
#ifdef DIFFUSE_MAP\n\
    color = texture(diffuseMap, texCoords);\n\
#else\n\
    color = vec4(1.0, 1.0, 1.0, 1.0);\n\
#endif\n\
}\n\
\0";

namespace Engine
{
    // Shader parameters
    const String tagDiffuseMap = "DiffuseMap";

    // Macro definitions
    const String tagDiffuseMapMacro = "DIFFUSE_MAP";
    const String tagDynamicMacro = "DYNAMIC";

    struct ShaderDataHolder
    {
        ShaderDataHolder(const ShaderDataHolder &) = delete;
        ShaderDataHolder &operator = (const ShaderDataHolder &) = delete;

        ShaderDataHolder()
            : gpuProgramId(INVALID_GPU_PROGRAM_ID)
        {
        }

        ShaderDataHolder(GpuProgramId gpuProgramId)
            : gpuProgramId(gpuProgramId)
        {
        }

        ~ShaderDataHolder()
        {
            if (gpuProgramId != INVALID_GPU_PROGRAM_ID)
                GetRenderer()->DestroyGpuProgram(gpuProgramId);
        }

        GpuProgramId gpuProgramId;
    };

    using ShaderDataHolderPtr = std::shared_ptr<ShaderDataHolder>;
    using ShaderDataMap = std::unordered_map<String, ShaderDataHolderPtr>;

    struct Material
    {
        TexturePtr diffuseMap;
    };

    using MaterialPtr = std::shared_ptr<Material>;
    using MaterialMap = std::unordered_map<String, MaterialPtr>;

    template <class AssociativeContainer_T, class Key_T>
    bool HasEntry(const AssociativeContainer_T &container, const Key_T &key)
    {
        auto elementIt = container.find(key);
        if (elementIt != container.end())
            return true;

        return false;
    }

    template <class Key_T, class Val_T>
    bool GetEntry(const std::unordered_map<Key_T, Val_T> &container, const Key_T &key, Val_T &value)
    {
        auto elementIt = container.find(key);
        if (elementIt == container.end())
            return false;

        value = elementIt->second;
        return true;
    }

    class ShaderImpl : public Shader
    {
    public:
        ShaderImpl()
        {
            worldViewProj.SetIdentity();
            staticShaders.reserve(MAX_SHADER_DATAS);
            dynamicShaders.reserve(MAX_SHADER_DATAS);
        }

        virtual void Compile(const String &shaderName, bool isDynamic) override
        {
            if (shaderName.empty()) {
                //TODO: log error
                return;
            }

            if ((isDynamic && HasEntry(dynamicShaders, shaderName))
                || (!isDynamic && HasEntry(staticShaders, shaderName))) {
                //TODO: log warning
                return;
            }

            ByteArray source;
            if (!LoadFileSource(shaderName + ".shader", source)) {
                //TODO: log error
                return;
            }

            ScriptPtr shaderScript = ParseScript(shaderName, source);
            if (!shaderScript) {
                //TODO: log error
                return;
            }

            String shaderIdentifierStr;
            const String shaderBase = MakeShaderBase(shaderScript, isDynamic, shaderIdentifierStr);
            const String vertexShaderStr = String(shaderBase) + geomVertexShader;
            const String fragmentShaderStr = String(shaderBase) + geomFragmentShader;

            ByteArray vertexShaderSrc(vertexShaderStr.begin(), vertexShaderStr.end());
            ByteArray fragmentShaderSrc(fragmentShaderStr.begin(), fragmentShaderStr.end());
            GpuProgramId gpuProgramId = GetRenderer()->CreateGpuProgram(vertexShaderSrc, fragmentShaderSrc);

            if (gpuProgramId == INVALID_GPU_PROGRAM_ID) {
                //TODO: log error
                return;
            }

            if (!ParseMaterial(shaderScript, ))

            auto shaderData = std::make_shared<ShaderDataHolder>(gpuProgramId);
            if (isDynamic)
                dynamicShaders[shaderIdentifierStr] = shaderData;
            else
                staticShaders[shaderIdentifierStr] = shaderData;
        }

        virtual void Draw(GraphicsShapePtr shape) override
        {
            ShaderDataHolderPtr shaderData;
            bool isDynamic = IsDynamicShape(*shape);
            if ((isDynamic && !GetEntry(dynamicShaders, shape->shaderName, shaderData))
            || (!isDynamic && !GetEntry(staticShaders, shape->shaderName, shaderData))) {
                //TODO: log warning
                return;
            }

            if (shaderData != currentShaderData) {
                currentShaderData = shaderData;
                GetRenderer()->BindGpuProgram(shaderData->gpuProgramId);
                if (shaderData->diffuseMap)
                    GetRenderer()->BindHardwareTexture(shaderData->diffuseMap->GetHardwareTexture(), DIFFUSE_MAP);

                GetRenderer()->SetGpuProgramConstant(shaderData->gpuProgramId, "worldViewProj", worldViewProj);
            }

            GetRenderer()->DrawHardwareBuffer(shape->hardwareBufferId);
        }

        virtual void SetWorldViewProj(const Matrix4 &worldViewProj) override
        {
            this->worldViewProj = worldViewProj;
            if (currentShaderData) {
                GetRenderer()->SetGpuProgramConstant(
                    currentShaderData->gpuProgramId, "worldViewProj", worldViewProj);
            }
        }

    private:
        bool LoadFileSource(const String &fileName, ByteArray &source) const
        {
            FilePtr file = GetFileSystem()->OpenFileRead(fileName);
            if (!file)
                return false;

            const size_t fileSize = file->GetSize();
            if (fileSize == 0)
                return false;

            source.resize(fileSize);
            file->Read(&source[0], source.size());
            return true;
        }

        String MakeMacroDefinition(const String &macroName, const String &macroDefinition) const
        {
            return String("#ifndef ") + macroName + '\n'
                + String("#define ") + macroName + ' ' + macroDefinition + '\n'
                + String("#endif") + "\n\n";
        }

        String MakeShaderBase(ScriptPtr shaderScript, bool isDynamic, String &usedDefinesString) const
        {
            String result = "#version 330\n\n";
            const String separator = ";";

            if (isDynamic) {
                result += MakeMacroDefinition(tagDynamicMacro, "1");
                usedDefinesString += tagDynamicMacro + separator;
            }

            if (shaderScript->HasValue(tagDiffuseMap)) {
                result += MakeMacroDefinition(tagDiffuseMapMacro, "1");
                usedDefinesString += tagDiffuseMapMacro + separator;
            }

            return result;
        }

        bool IsDynamicShape(const GraphicsShape &shape) const
        {
            switch (shape.vertexFormat) {
            case VA_BONES:
            case VA_SKINNED_W2:
            case VA_SKINNED_W3:
            case VA_SKINNED_W4:
            case VA_SKINNED_W1:
                return true;
            }

            return false;
        }

        bool ParseMaterial(ScriptPtr shaderScript, Material &material) const
        {
            const String diffuseMapName = shaderScript->GetString(tagDiffuseMap);
            if (!diffuseMapName.empty())
                material.diffuseMap = GetTextureManager()->GetTexture(diffuseMapName);

            return true;
        }

    private:
        static const int MAX_SHADER_DATAS = 128;

        Matrix4 worldViewProj;

        ShaderDataMap staticShaders;
        ShaderDataMap dynamicShaders;

        ShaderDataHolderPtr currentShaderData;
    };

    Shader *GetShader()
    {
        static ShaderImpl shader;
        return &shader;
    }
}

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

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");

    Engine::Matrix4 rotation(Engine::Matrix3(M_PI * 0.25f, M_PI * 0.1f, 0));

    Engine::Matrix4 proj, view, model, modelViewProj;
    view.SetIdentity();
    proj.SetPerspective(1.3f, 1.78f, 0.1f, 100000.0f);
    model.SetTranslation(Engine::Vector3(-0.35, -0.3f, -1.5f));
    modelViewProj = rotation * model * proj;


    Engine::Shader *shader = Engine::GetShader();
    shader->Compile("cat", false);
    shader->SetWorldViewProj(modelViewProj);

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

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

        shader->Draw(teapot->GetGraphicsShapes()[0]);
    }
}

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

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

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

    Engine::ModelManager *modelManager = Engine::GetModelManager();
    Engine::ModelPtr teapot = modelManager->GetModel("teapot");

    Engine::Matrix4 rotation(Engine::Matrix3(M_PI * 0.25f, M_PI * 0.1f, 0));

    Engine::Matrix4 proj, view, world;
    view.SetIdentity();
    proj.SetPerspective(1.3f, 1.78f, 0.1f, 100000.0f);
    world.SetTranslation(Engine::Vector3(-0.35, -0.3f, -1.5f));
    world = rotation * world;

    Engine::Shader *shader = Engine::GetShader();
    shader->SetFrameBufferSize(1280, 720);
    shader->Compile("cat", false);
    shader->SetWorldViewProj(world, view, proj);

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

        shader->BeginFrame();
        shader->Draw(teapot->GetGraphicsShapes()[0]);
        shader->EndFrame();
    }
}

#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");
    }

    const FbxVector4 *controlPoints = fbxMesh->GetControlPoints();

    FbxStringList uvSets;
    fbxMesh->GetUVSetNames(uvSets);
    fbxMesh->GenerateNormals();

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

            const FbxVector4 &controlPoint = controlPoints[index];
            vertices.push_back(controlPoint[0]);
            vertices.push_back(controlPoint[1]);
            vertices.push_back(controlPoint[2]);

            FbxVector4 normal;
            fbxMesh->GetPolygonVertexNormal(i, j, normal);
            vertices.push_back(normal[0]);
            vertices.push_back(normal[1]);
            vertices.push_back(normal[2]);

            vertices.resize(vertices.size() + 6);

            bool unmapped;
            FbxVector2 textureUV;
            fbxMesh->GetPolygonVertexUV(i, j, uvSets[0], textureUV, unmapped);
            vertices.push_back(textureUV[0]);
            vertices.push_back(1-textureUV[1]);
        }
    }
}

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;
    }
}

{
    // Diffuse map
    DiffuseMap = cat_diff;
}