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