/*******************************************************
 * Copyright (c) 2014, ArrayFire
 * All rights reserved.
 *
 * This file is distributed under 3-clause BSD license.
 * The complete license agreement can be obtained at:
 * http://arrayfire.com/licenses/BSD-3-Clause
 ********************************************************/

#if defined(WITH_GRAPHICS)

#include <graphics_common.hpp>
#include <err_common.hpp>
#include <backend.hpp>
#include <platform.hpp>
#include <util.hpp>

using namespace std;

template<typename T>
GLenum getGLType() { return GL_FLOAT; }

fg::MarkerType getFGMarker(const af_marker_type af_marker) {
    fg::MarkerType fg_marker;
    switch (af_marker) {
        case AF_MARKER_NONE: fg_marker = fg::FG_NONE; break;
        case AF_MARKER_POINT: fg_marker = fg::FG_POINT; break;
        case AF_MARKER_CIRCLE: fg_marker = fg::FG_CIRCLE; break;
        case AF_MARKER_SQUARE: fg_marker = fg::FG_SQUARE; break;
        case AF_MARKER_TRIANGLE: fg_marker = fg::FG_TRIANGLE; break;
        case AF_MARKER_CROSS: fg_marker = fg::FG_CROSS; break;
        case AF_MARKER_PLUS: fg_marker = fg::FG_PLUS; break;
        case AF_MARKER_STAR: fg_marker = fg::FG_STAR; break;
        default: fg_marker = fg::FG_NONE; break;
    }
    return fg_marker;
}

#define INSTANTIATE_GET_FG_TYPE(T, ForgeEnum)\
    template<> fg::dtype getGLType<T>() { return ForgeEnum; }

INSTANTIATE_GET_FG_TYPE(float, fg::f32);
INSTANTIATE_GET_FG_TYPE(int  , fg::s32);
INSTANTIATE_GET_FG_TYPE(unsigned, fg::u32);
INSTANTIATE_GET_FG_TYPE(char, fg::s8);
INSTANTIATE_GET_FG_TYPE(unsigned char, fg::u8);
INSTANTIATE_GET_FG_TYPE(unsigned short, fg::u16);
INSTANTIATE_GET_FG_TYPE(short, fg::s16);

GLenum glErrorSkip(const char *msg, const char* file, int line)
{
#ifndef NDEBUG
    GLenum x = glGetError();
    if (x != GL_NO_ERROR) {
        char buf[1024];
        sprintf(buf, "GL Error Skipped at: %s:%d Message: %s Error Code: %d \"%s\"\n", file, line, msg, x, gluErrorString(x));
        AF_ERROR(buf, AF_ERR_INTERNAL);
    }
    return x;
#else
    return 0;
#endif
}

GLenum glErrorCheck(const char *msg, const char* file, int line)
{
// Skipped in release mode
#ifndef NDEBUG
    GLenum x = glGetError();

    if (x != GL_NO_ERROR) {
        char buf[1024];
        sprintf(buf, "GL Error at: %s:%d Message: %s Error Code: %d \"%s\"\n", file, line, msg, x, gluErrorString(x));
        AF_ERROR(buf, AF_ERR_INTERNAL);
    }
    return x;
#else
    return 0;
#endif
}

GLenum glForceErrorCheck(const char *msg, const char* file, int line)
{
    GLenum x = glGetError();

    if (x != GL_NO_ERROR) {
        char buf[1024];
        sprintf(buf, "GL Error at: %s:%d Message: %s Error Code: %d \"%s\"\n", file, line, msg, x, gluErrorString(x));
        AF_ERROR(buf, AF_ERR_INTERNAL);
    }
    return x;
}

size_t getTypeSize(GLenum type)
{
    switch(type) {
        case GL_FLOAT:          return sizeof(float);
        case GL_INT:            return sizeof(int  );
        case GL_UNSIGNED_INT:   return sizeof(unsigned);
        case GL_SHORT:          return sizeof(short);
        case GL_UNSIGNED_SHORT: return sizeof(unsigned short);
        case GL_BYTE:           return sizeof(char );
        case GL_UNSIGNED_BYTE:  return sizeof(unsigned char);
        default: return sizeof(float);
    }
}

namespace graphics
{

ForgeManager& ForgeManager::getInstance()
{
    static ForgeManager my_instance;
    return my_instance;
}

ForgeManager::~ForgeManager()
{
    destroyResources();
}

fg::Font* ForgeManager::getFont(const bool dontCreate)
{
    static bool flag = true;
    static fg::Font* fnt = NULL;

    CheckGL("Begin ForgeManager::getFont");

    if (flag && !dontCreate) {
        fnt = new fg::Font();
#if defined(_WIN32) || defined(_MSC_VER)
        fnt->loadSystemFont("Arial", 32);
#else
        fnt->loadSystemFont("Vera", 32);
#endif
        CheckGL("End ForgeManager::getFont");
        flag = false;
    };

    return fnt;
}

fg::Window* ForgeManager::getMainWindow(const bool dontCreate)
{
    static bool flag = true;
    static fg::Window* wnd = NULL;

    // Define AF_DISABLE_GRAPHICS with any value to disable initialization
    std::string noGraphicsENV = getEnvVar("AF_DISABLE_GRAPHICS");
    if(noGraphicsENV.empty()) { // If AF_DISABLE_GRAPHICS is not defined
        if (flag && !dontCreate) {
            wnd = new fg::Window(WIDTH, HEIGHT, "ArrayFire", NULL, true);
            CheckGL("End ForgeManager::getMainWindow");
            flag = false;
        };
    }
    return wnd;
}

fg::Image* ForgeManager::getImage(int w, int h, fg::ChannelFormat mode, fg::dtype type)
{
    /* w, h needs to fall in the range of [0, 2^16]
     * for the ForgeManager to correctly retrieve
     * the necessary Forge Image object. So, this implementation
     * is a limitation on how big of an image can be rendered
     * using arrayfire graphics funtionality */
    assert(w <= 2ll<<16);
    assert(h <= 2ll<<16);
    long long key = ((w & _16BIT) << 16) | (h & _16BIT);
    key = (((key << 16) | mode) << 16) | type;

    ImgMapIter iter = mImgMap.find(key);
    if (iter==mImgMap.end()) {
        fg::Image* temp = new fg::Image(w, h, mode, type);
        mImgMap[key] = temp;
    }

    return mImgMap[key];
}

fg::Plot* ForgeManager::getPlot(int nPoints, fg::dtype dtype, fg::PlotType ptype, fg::MarkerType mtype)
{
    /* nPoints needs to fall in the range of [0, 2^48]
     * for the ForgeManager to correctly retrieve
     * the necessary Forge Plot object. So, this implementation
     * is a limitation on how big of an plot graph can be rendered
     * using arrayfire graphics funtionality */
    assert(nPoints <= 2ll<<48);
    long long key = ((nPoints & _48BIT) << 48);
    key |= (((((dtype & 0x000F) << 12) | (ptype & 0x000F)) << 8) | (mtype & 0x000F));

    PltMapIter iter = mPltMap.find(key);
    if (iter==mPltMap.end()) {
        fg::Plot* temp = new fg::Plot(nPoints, dtype, ptype, mtype);
        mPltMap[key] = temp;
    }

    return mPltMap[key];
}

fg::Plot3* ForgeManager::getPlot3(int nPoints, fg::dtype dtype, fg::PlotType ptype, fg::MarkerType mtype)
{
    /* nPoints needs to fall in the range of [0, 2^48]
     * for the ForgeManager to correctly retrieve
     * the necessary Forge Plot object. So, this implementation
     * is a limitation on how big of an plot graph can be rendered
     * using arrayfire graphics funtionality */
    assert(nPoints <= 2ll<<48);
    long long key = ((nPoints & _48BIT) << 48);
    key |= (((((dtype & 0x000F) << 12) | (ptype & 0x000F)) << 8) | (mtype & 0x000F));

    Plt3MapIter iter = mPlt3Map.find(key);
    if (iter==mPlt3Map.end()) {
        fg::Plot3* temp = new fg::Plot3(nPoints, dtype, ptype, mtype);
        mPlt3Map[key] = temp;
    }

    return mPlt3Map[key];
}

fg::Histogram* ForgeManager::getHistogram(int nBins, fg::dtype type)
{
    /* nBins needs to fall in the range of [0, 2^48]
     * for the ForgeManager to correctly retrieve
     * the necessary Forge Histogram object. So, this implementation
     * is a limitation on how big of an histogram data can be rendered
     * using arrayfire graphics funtionality */
    assert(nBins <= 2ll<<48);
    long long key = ((nBins & _48BIT) << 48) | (type & _16BIT);

    HstMapIter iter = mHstMap.find(key);
    if (iter==mHstMap.end()) {
        fg::Histogram* temp = new fg::Histogram(nBins, type);
        mHstMap[key] = temp;
    }

    return mHstMap[key];
}

fg::Surface* ForgeManager::getSurface(int nX, int nY, fg::dtype type)
{
    /* nX * nY needs to fall in the range of [0, 2^48]
     * for the ForgeManager to correctly retrieve
     * the necessary Forge Plot object. So, this implementation
     * is a limitation on how big of an plot graph can be rendered
     * using arrayfire graphics funtionality */
    assert(nX * nY <= 2ll<<48);
    long long key = (((nX * nY) & _48BIT) << 48) | (type & _16BIT);

    SfcMapIter iter = mSfcMap.find(key);
    if (iter==mSfcMap.end()) {
        fg::Surface* temp = new fg::Surface(nX, nY, type);
        mSfcMap[key] = temp;
    }

    return mSfcMap[key];
}

void ForgeManager::destroyResources()
{
    /* clear all OpenGL resource objects (images, plots, histograms etc) first
     * and then delete the windows */
    for(ImgMapIter iter = mImgMap.begin(); iter != mImgMap.end(); iter++)
        delete (iter->second);

    for(PltMapIter iter = mPltMap.begin(); iter != mPltMap.end(); iter++)
        delete (iter->second);

    for(HstMapIter iter = mHstMap.begin(); iter != mHstMap.end(); iter++)
        delete (iter->second);

    delete getFont(true);
    delete getMainWindow(true);
}

}

#endif