#include <boo/boo.hpp>
#include "logvisor/logvisor.hpp"
#include "hecl/Console.hpp"
#include "hecl/CVarManager.hpp"
#include "athena/MemoryWriter.hpp"
#include "hecl/Runtime.hpp"
#include "hecl/Backend/Backend.hpp"
#include "hecl/HMDLMeta.hpp"
#include "hecl/Pipeline.hpp"
#include <cmath>
#include <thread>
#include <mutex>
#include <condition_variable>

using namespace std::literals;

struct HECLWindowCallback : boo::IWindowCallback
{
    bool m_sizeDirty = false;
    boo::SWindowRect m_latestSize;
    virtual ~HECLWindowCallback();
    void resized(const boo::SWindowRect& rect, bool /*sync*/)
    {
        m_sizeDirty = true;
        m_latestSize = rect;
    }

    bool m_destroyed = false;
    void destroyed()
    {
        m_destroyed = true;
    }

    void charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat)
    {
        hecl::Console::instance()->handleCharCode(charCode, mods, isRepeat);
    }
    void specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat)
    {
        hecl::Console::instance()->handleSpecialKeyDown(key, mods, isRepeat);
    }
    void specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods)
    {
        hecl::Console::instance()->hecl::Console::handleSpecialKeyUp(key, mods);
    }
};

HECLWindowCallback::~HECLWindowCallback()
{

}

struct HECLApplicationCallback : boo::IApplicationCallback
{
    HECLWindowCallback m_windowCb;
    hecl::Runtime::FileStoreManager m_fileStoreMgr;
    hecl::CVarManager m_cvarManager;
    hecl::Console m_console;
    std::shared_ptr<boo::IWindow> m_mainWindow;
    bool m_running = true;

    HECLApplicationCallback()
        : m_fileStoreMgr(_S("heclTest")),
          m_cvarManager(m_fileStoreMgr),
          m_console(&m_cvarManager)
    {
        m_console.registerCommand("quit"sv, "Quits application"sv, "",
            std::bind(&HECLApplicationCallback::quit, this, std::placeholders::_1, std::placeholders::_2));
    }

    virtual ~HECLApplicationCallback();

    int appMain(boo::IApplication* app)
    {
        hecl::VerbosityLevel = 2;

        /* Setup boo window */
        m_mainWindow = app->newWindow(_S("HECL Test"));
        m_mainWindow->setCallback(&m_windowCb);

        boo::ObjToken<boo::ITextureR> renderTex;
        boo::ObjToken<boo::IGraphicsBuffer> vubo;
        boo::ObjToken<boo::IShaderPipeline> pipeline, pipeline2;
        boo::ObjToken<boo::IShaderDataBinding> binding, binding2;

        struct VertexUBO
        {
            float modelview[4][4] = {};
            float modelviewInv[4][4] = {};
            float projection[4][4] = {};
            VertexUBO()
            {
                modelview[0][0] = 1.0;
                modelview[1][1] = 1.0;
                modelview[2][2] = 1.0;
                modelview[3][3] = 1.0;
                modelviewInv[0][0] = 1.0;
                modelviewInv[1][1] = 1.0;
                modelviewInv[2][2] = 1.0;
                modelviewInv[3][3] = 1.0;
                projection[0][0] = 1.0;
                projection[1][1] = 1.0;
                projection[2][2] = 1.0;
                projection[3][3] = 1.0;
            }
        } vuboData;

        /* Make ramp texture */
        using Pixel = uint8_t[4];
        static Pixel tex[256][256];
        for (int i=0 ; i<256 ; ++i)
            for (int j=0 ; j<256 ; ++j)
            {
                tex[i][j][0] = uint8_t(i);
                tex[i][j][1] = uint8_t(j);
                tex[i][j][2] = 0;
                tex[i][j][3] = 0xff;
            }

        boo::IGraphicsDataFactory* gfxF = m_mainWindow->getMainContextDataFactory();
        if (gfxF->platform() == boo::IGraphicsDataFactory::Platform::Vulkan)
            vuboData.modelview[1][1] = -1.f;

        /* Pipeline converter */
        std::unique_ptr<hecl::PipelineConverterBase> conv = hecl::NewPipelineConverter(gfxF);

        /* Compile HECL shader */
        static std::string testShader = "HECLOpaque(Texture(0, UV(0)))";
        //static std::string testShader = "HECLOpaque(vec3(1.0,1.0,1.0),1.0)";
        hecl::Backend::ShaderTag testShaderTag(testShader, 0, 1, 0, 0, boo::Primitive::TriStrips,
                                               hecl::Backend::ReflectionType::None, false, false, false);
        hecl::Frontend::Frontend FE;
        hecl::HECLIR irObj(FE.compileSource(testShader, "booTest"), testShaderTag, 0);

        gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx)
        {
            pipeline = conv->convert(ctx, irObj);
            pipeline2 = conv->convert(ctx, Shader_test{});

            boo::SWindowRect mainWindowRect = m_mainWindow->getWindowFrame();
            renderTex = ctx.newRenderTexture(size_t(mainWindowRect.size[0]), size_t(mainWindowRect.size[1]),
                                             boo::TextureClampMode::Repeat, 1, 0);

            /* Generate meta structure (usually statically serialized) */
            hecl::HMDLMeta testMeta;
            testMeta.topology = hecl::HMDLTopology::TriStrips;
            testMeta.vertStride = 32;
            testMeta.vertCount = 4;
            testMeta.indexCount = 4;
            testMeta.colorCount = 0;
            testMeta.uvCount = 1;
            testMeta.weightCount = 0;
            testMeta.bankCount = 0;

            /* Binary form of meta structure */
            atUint8 testMetaBuf[HECL_HMDL_META_SZ];
            athena::io::MemoryWriter testMetaWriter(testMetaBuf, HECL_HMDL_META_SZ);
            testMeta.write(testMetaWriter);

            /* Make Tri-strip VBO */
            struct Vert
            {
                float pos[3];
                float norm[3];
                float uv[2];
            };
            static const Vert quad[4] =
            {
                {{0.5,0.5},{},{1.0,1.0}},
                {{-0.5,0.5},{},{0.0,1.0}},
                {{0.5,-0.5},{},{1.0,0.0}},
                {{-0.5,-0.5},{},{0.0,0.0}}
            };

            /* Now simple IBO */
            static const uint32_t ibo[4] = {0,1,2,3};

            /* Construct quad mesh against boo factory */
            hecl::Runtime::HMDLData testData(ctx, testMetaBuf, quad, ibo);

            boo::ObjToken<boo::ITexture> texture =
            ctx.newStaticTexture(256, 256, 1, boo::TextureFormat::RGBA8, boo::TextureClampMode::Repeat, tex, 256*256*4).get();

            /* Make vertex uniform buffer */
            vubo = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(VertexUBO), 1).get();

            /* Assemble data binding */
            binding = testData.newShaderDataBindng(ctx, pipeline, 1, &vubo, nullptr, 1, &texture);
            binding2 = testData.newShaderDataBindng(ctx, pipeline2, 1, &vubo, nullptr, 1, &texture);
            return true;
        } BooTrace);


        m_mainWindow->showWindow();
        m_windowCb.m_latestSize = m_mainWindow->getWindowFrame();
        boo::IGraphicsCommandQueue* gfxQ = m_mainWindow->getCommandQueue();

        size_t frameIdx = 0;
        while (m_running)
        {
            m_mainWindow->waitForRetrace();

            if (m_windowCb.m_destroyed)
            {
                m_running = false;
                break;
            }

            if (m_windowCb.m_sizeDirty)
            {
                gfxQ->resizeRenderTexture(renderTex,
                                          size_t(m_windowCb.m_latestSize.size[0]),
                                          size_t(m_windowCb.m_latestSize.size[1]));
                m_windowCb.m_sizeDirty = false;
            }

            m_console.proc();

            gfxQ->setRenderTarget(renderTex);
            boo::SWindowRect r = m_windowCb.m_latestSize;
            r.location[0] = 0;
            r.location[1] = 0;
            gfxQ->setViewport(r);
            gfxQ->setScissor(r);
            float rgba[] = {sinf(frameIdx / 60.0f), cosf(frameIdx / 60.0f), 0.0f, 1.0f};
            gfxQ->setClearColor(rgba);
            gfxQ->clearTarget();

            vuboData.modelview[3][0] = sinf(frameIdx / 60.0f) * 0.5f;
            vuboData.modelview[3][1] = cosf(frameIdx / 60.0f) * 0.5f;
            vubo.cast<boo::IGraphicsBufferD>()->load(&vuboData, sizeof(vuboData));

            gfxQ->setShaderDataBinding(binding2);
            gfxQ->drawIndexed(0, 4);
            gfxQ->resolveDisplay(renderTex);
            m_console.draw(gfxQ);
            gfxQ->execute();

            ++frameIdx;
        }

        m_cvarManager.serialize();
        gfxQ->stopRenderer();
        return 0;
    }
    void appQuitting(boo::IApplication* /*app*/)
    {
        m_running = false;
    }

    void quit(hecl::Console* /*con*/, const std::vector<std::string>& /*args*/)
    {
        m_running = false;
    }
};

void AthenaExcHandler(athena::error::Level level,
                      const char* file, const char* /*function*/,
                      int line, const char* fmt, ...)
{
    static logvisor::Module Log("heclTest::AthenaExcHandler");
    va_list ap;
    va_start(ap, fmt);
    Log.reportSource(logvisor::Level(level), file, uint32_t(line), fmt, ap);
    va_end(ap);
}

#if !WINDOWS_STORE
#if _WIN32
int wmain(int argc, const boo::SystemChar** argv)
#else
int main(int argc, const boo::SystemChar** argv)
#endif
{
    atSetExceptionHandler(AthenaExcHandler);
    logvisor::RegisterStandardExceptions();
    logvisor::RegisterConsoleLogger();
    HECLApplicationCallback appCb;
    int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto,
        appCb, _S("heclTest"), _S("HECL Test"), argc, argv);
    printf("IM DYING!!\n");
    return ret;
}
#else
using namespace Windows::ApplicationModel::Core;

[Platform::MTAThread]
int WINAPIV main(Platform::Array<Platform::String^>^ params)
{
    logvisor::RegisterStandardExceptions();
    logvisor::RegisterConsoleLogger();
    HECLApplicationCallback appCb;
    boo::ViewProvider^ viewProvider =
        ref new boo::ViewProvider(appCb, _S("heclTest"), _S("HECL Test"), _S("heclTest"), params, false);
    CoreApplication::Run(viewProvider);
    return 0;
}
#endif

#if _WIN32 && !WINDOWS_STORE
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int)
{
    int argc = 0;
    const boo::SystemChar** argv;
    if (lpCmdLine[0])
        argv = (const wchar_t**)(CommandLineToArgvW(lpCmdLine, &argc));
    static boo::SystemChar selfPath[1024];
    GetModuleFileNameW(nullptr, selfPath, 1024);
    static const boo::SystemChar* booArgv[32] = {};
    booArgv[0] = selfPath;
    for (int i=0 ; i<argc ; ++i)
        booArgv[i+1] = argv[i];

    logvisor::CreateWin32Console();
    return wmain(argc + 1, booArgv);
}
#endif

HECLApplicationCallback::~HECLApplicationCallback()
{

}