#include <SDL2/SDL.h>
#undef main
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include <SDL2/SDL_mixer.h>

#include <string>
#include <memory>

namespace MiniEngine
{

class Rect
{
public:
    int x, y, w, h;
    Rect(int X, int Y, int W, int H)
    {
        x = X;
        y = Y;
        w = W;
        h = H;
    }
    Rect()
    {
        x = y = w = h = 0;
    }
    SDL_Rect toSDLRect()
    {
        SDL_Rect r;
        r.x = x;
        r.y = y;
        r.w = w;
        r.h = h;
        return r;
    }
};

class Point
{
public:
    int x,y;
    Point(int X,int Y)
    {
        x=X;
        y=Y;
    }
    Point()
    {
        x=y=0;
    }
    SDL_Point toSDLPoint()
    {
        SDL_Point p;
        p.x=x;
        p.y=y;
        return p;
    }
    bool inRect(Rect rect)
    {
        auto p=toSDLPoint();
        auto r=rect.toSDLRect();
        return SDL_PointInRect(&p,&r);
    }
};

class RGBA
{
public:
    int r, g, b, a;
    RGBA(int R, int G, int B, int A)
    {
        r = R;
        g = G;
        b = B;
        a = A;
    }
    RGBA()
    {
        r = g = b = a = 0;
    }
    SDL_Color toSDLColor()
    {
        SDL_Color c;
        c.r = r;
        c.g = g;
        c.b = b;
        c.a = a;
        return c;
    }
};

class NonCopyable
{
protected:
    NonCopyable() = default;
    ~NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator = (const NonCopyable&) = delete;
};

/// Forward Declaration
class Window;
class Renderer;

class ErrorViewer : public std::exception
{
public:
    void fetch()
    {
        str = SDL_GetError();
    }
    std::string getError()
    {
        return str;
    }
    const char* what() const throw() override
    {
        return str.c_str();
    }
private:
    std::string str;
};

class Surface
{
public:
    ~Surface()
    {

    }
protected:
    Surface() = default;
private:
    std::shared_ptr<SDL_Surface> surf;
    friend class Renderer;
    friend class Font;
};

class Texture
{
public:
    ~Texture()
    {

    }
    Rect getSize()
    {
        return rect;
    }
    int getw()
    {
        return rect.w;
    }
    int geth()
    {
        return rect.h;
    }
protected:
    Texture()
    {

    }
    void updateInfo()
    {
        SDL_QueryTexture(text.get(), NULL, NULL, &rect.w, &rect.h);
        rect.x = rect.y = 0;
    }
private:
    std::shared_ptr<SDL_Texture> text;
    Rect rect;
    friend class Renderer;
};


class Renderer
{
public:
    enum class Type { Software=SDL_RENDERER_SOFTWARE, Accelerated=SDL_RENDERER_ACCELERATED,
                      PresentSync=SDL_RENDERER_PRESENTVSYNC, TargetTexture=SDL_RENDERER_TARGETTEXTURE
                    };

    int setColor(RGBA pack)
    {
        return SDL_SetRenderDrawColor(rnd.get(), pack.r, pack.g, pack.b, pack.a);
    }

    RGBA getColor()
    {
        Uint8 r, g, b, a;
        SDL_GetRenderDrawColor(rnd.get(), &r, &g, &b, &a);
        RGBA pack(r, g, b, a);
        return pack;
    }
    int fillRect(Rect rect)
    {
        auto inr = rect.toSDLRect();
        return SDL_RenderFillRect(rnd.get(), &inr);
    }

    int drawRect(Rect rect)
    {
        auto inr = rect.toSDLRect();
        return SDL_RenderDrawRect(rnd.get(), &inr);
    }
    int clear()
    {
        return SDL_RenderClear(rnd.get());
    }
    void update()
    {
        SDL_RenderPresent(rnd.get());
    }
    int copy(Texture t, Rect src, Rect dst)
    {
        SDL_Rect s = src.toSDLRect();
        SDL_Rect d = dst.toSDLRect();
        return SDL_RenderCopy(rnd.get(), t.text.get(), &s, &d);
    }
    int copyTo(Texture t, Rect dst)
    {
        SDL_Rect d = dst.toSDLRect();
        return SDL_RenderCopy(rnd.get(), t.text.get(), NULL, &d);
    }
    int copyFill(Texture t, Rect src)
    {
        SDL_Rect s = src.toSDLRect();
        return SDL_RenderCopy(rnd.get(), t.text.get(), &s, NULL);
    }
    int copyFullFill(Texture t)
    {
        return SDL_RenderCopy(rnd.get(), t.text.get(), NULL, NULL);
    }
    Surface loadSurface(std::string FileName) throw(ErrorViewer)
    {
        Surface surf;
        SDL_Surface* temp = IMG_Load(FileName.c_str());
        if (temp == nullptr)
        {
            ErrorViewer e;
            e.fetch();
            throw e;
        }
        surf.surf.reset(temp, SDL_FreeSurface);
        return surf;
    }
    Texture render(Surface surf) throw (ErrorViewer)
    {
        Texture t;
        SDL_Texture* temp = SDL_CreateTextureFromSurface(rnd.get(), surf.surf.get());
        if (temp == nullptr)
        {
            ErrorViewer e;
            e.fetch();
            throw e;
        }
        t.text.reset(temp, SDL_DestroyTexture);
        t.updateInfo();
        return t;
    }
    Texture loadTexture(std::string FileName) throw(ErrorViewer)
    {
        Texture t;
        SDL_Texture* temp = IMG_LoadTexture(rnd.get(), FileName.c_str());
        if (temp == nullptr)
        {
            ErrorViewer e;
            e.fetch();
            throw e;
        }
        t.text.reset(temp, SDL_DestroyTexture);
        t.updateInfo();
        return t;
    }

protected:
    Renderer()
    {
        /// This function is called by Window ONLY.
    }
private:
    std::shared_ptr<SDL_Renderer> rnd;
    friend class Window;
};

class Window
{
public:
    Window(std::string Title, int Width, int Height) throw(ErrorViewer)
    {
        SDL_Window* temp = SDL_CreateWindow(Title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_WINDOW_SHOWN);
        if (temp == NULL)
        {
            ErrorViewer e;
            e.fetch();
            throw e;
        }
        wnd.reset(temp, SDL_DestroyWindow);
        setRenderer(Renderer::Type::Accelerated,Renderer::Type::TargetTexture);
    }
    Renderer getRenderer() const
    {
        return winrnd;
    }

    /// TODO: Unfinished.
    void setRenderer(Renderer::Type a,Renderer::Type b)
    {
        _setRenderer_Real(static_cast<int>(a)|static_cast<int>(b));
    }

    Rect getSize()
    {
        int w, h;
        SDL_GetWindowSize(wnd.get(), &w, &h);
        Rect rect(0, 0, w, h);
        return rect;
    }
    void setSize(Rect sizeRect)
    {
        setSize(sizeRect.w, sizeRect.h);
    }
    void setSize(int w, int h)
    {
        SDL_SetWindowSize(wnd.get(),w,h);
    }

    void setTitle(std::string Title)
    {

    }
private:
    void _setRenderer_Real(Uint32 flags)
    {
        winrnd.rnd.reset(SDL_CreateRenderer(wnd.get(), -1, flags),SDL_DestroyRenderer);
    }
    std::shared_ptr<SDL_Window> wnd;
    Renderer winrnd;
};

class Font
{
public:
    Font()
    {

    }
    Font(std::string FontFileName, int size) throw(ErrorViewer)
    {
        if (use(FontFileName, size) != 0)
        {
            ErrorViewer e;
            e.fetch();
            throw e;
        }
    }
    int use(std::string FontFileName, int size)
    {
        TTF_Font* temp = TTF_OpenFont(FontFileName.c_str(), size);
        if (temp == NULL) return -1;
        font.reset(temp, TTF_CloseFont);
        return 0;
    }
    Texture renderText(Renderer rnd, std::string Text, RGBA fg)
    {
        Surface surf;
        surf.surf.reset(TTF_RenderText_Blended(font.get(), Text.c_str(), fg.toSDLColor()));
        Texture t = rnd.render(surf);
        return t;
    }

    Texture renderUTF8(Renderer rnd, std::string Text, RGBA fg)
    {
        Surface surf;
        surf.surf.reset(TTF_RenderUTF8_Blended(font.get(), Text.c_str(), fg.toSDLColor()));
        Texture t = rnd.render(surf);
        return t;
    }
private:
    std::shared_ptr<TTF_Font> font;
};

class SDLSystem
{
public:
    static int SDLInit()
    {
        return SDL_Init(SDL_INIT_EVERYTHING);
    }
    static void SDLQuit()
    {
        SDL_Quit();
    }
    static int IMGInit()
    {
        return IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG);
    }
    static void IMGQuit()
    {
        IMG_Quit();
    }
    static int TTFInit()
    {
        return TTF_Init();
    }
    static void TTFQuit()
    {
        TTF_Quit();
    }
    static int MixInit()
    {
        return Mix_Init(MIX_INIT_MP3);
    }
    static void MixQuit()
    {
        Mix_Quit();
    }

    static void Init()
    {
        SDLInit();
        IMGInit();
        TTFInit();
        MixInit();
    }
    static void Quit()
    {
        MixQuit();
        TTFQuit();
        IMGQuit();
        SDLQuit();
    }

    static void Delay(int ms)
    {
        SDL_Delay(ms);
    }
};


}/// End of namespace MiniEngine

namespace App
{

int main(int argc,char* argv[]);

}/// End of namespace App


/// Default Setup Code
int main(int argc,char* argv[])
{
    MiniEngine::SDLSystem::Init();
    int ret=App::main(argc,argv);
    MiniEngine::SDLSystem::Quit();
    return ret;
}