#include <SDL.h>
#include <SDL_image.h>
#include <iostream>
#include <stdio.h>
using namespace std;

const int WIDTH = 500;
const int HEIGHT = 500;

enum Keys {
        KEY_DEFAULT,
        KEY_UP,
        KEY_DOWN,
        KEY_LEFT,
        KEY_RIGHT,
        KEY_TOTAL
};

bool init();
bool loadMedia();
void run();
void close();
SDL_Surface* loadImage(string path);

SDL_Window* gWindow = NULL;
SDL_Surface* gScreenSurface = NULL;
char gKeyPress[KEY_TOTAL][3];
char gBackColor[3];
SDL_Surface* gImage = NULL;

void setColor(char* c, char r, char g, char b) { c[0]=r; c[1]=g; c[2]=b; }
void setColor(char* dest, char* src) { setColor(dest, src[0], src[1], src[2]); }

int main(int argc, char* args[]) {
        printf("HI\n");
        if (init()) {
                if (loadMedia()) {
                        run();
                }
        }

        close();

        return 0;
}

bool init() {
        bool success = true;

        if (SDL_Init(SDL_INIT_VIDEO) < 0) {
                cout << "SDL could not be initialized; SDL_Error: " << SDL_GetError() << endl;
                success = false;
        } else {
                freopen( "CON", "wt", stdout );
                freopen( "CON", "wt", stderr );
                printf("HI\n");
                gWindow = SDL_CreateWindow("My SDL", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WIDTH, HEIGHT, SDL_WINDOW_SHOWN);
                if (gWindow == NULL) {
                        cout << "Window could not be created; SDL_Error: " << SDL_GetError() << endl;
                        success = false;
                } else {
                        int imgFlags = IMG_INIT_PNG;
                        if (!(IMG_Init(imgFlags) & imgFlags)) {
                                cout << "SDL_image could not initialize; SDL_image Error: " << IMG_GetError() << endl;
                                success = false;
                        } else {
                                gScreenSurface = SDL_GetWindowSurface(gWindow);
                        }
                }
        }

        return success;
}

bool loadMedia() {
        bool success = true;

        setColor(gKeyPress[KEY_DEFAULT], 0x00, 0x00, 0x00);
        setColor(gKeyPress[KEY_UP], 0xff, 0xff, 0xff);
        setColor(gKeyPress[KEY_DOWN], 0xff, 0xff, 0x00);
        setColor(gKeyPress[KEY_LEFT], 0x00, 0xff, 0xff);
        setColor(gKeyPress[KEY_RIGHT], 0xff, 0x00, 0xff);

        string imgPath = "D:/Code/C++/SDL Tutorial/hello.bmp";

        gImage = loadImage(imgPath);
        if (gImage == NULL) {
                success = false;
        }

        return success;
}

void run() {
        bool running = true;
        SDL_Event e;
        setColor(gBackColor, gKeyPress[KEY_DEFAULT]);

        while (running) {
                while(SDL_PollEvent(&e) != 0) {
                        if (e.type == SDL_QUIT) {
                                running = false;
                        } else if (e.type = SDL_KEYDOWN) {
                                switch(e.key.keysym.sym) {
                                        case SDLK_UP:
                                                setColor(gBackColor, gKeyPress[KEY_UP]);
                                                break;
                                        case SDLK_DOWN:
                                                setColor(gBackColor, gKeyPress[KEY_DOWN]);
                                                break;
                                        case SDLK_LEFT:
                                                setColor(gBackColor, gKeyPress[KEY_LEFT]);
                                                break;
                                        case SDLK_RIGHT:
                                                setColor(gBackColor, gKeyPress[KEY_RIGHT]);
                                                break;
                                        default:
                                                setColor(gBackColor, gKeyPress[KEY_DEFAULT]);
                                }
                        }
                }

                SDL_FillRect(gScreenSurface, NULL, SDL_MapRGB(gScreenSurface->format, gBackColor[0], gBackColor[1], gBackColor[2]));
                       
                SDL_Rect rect;
                rect.x = 50;
                rect.y = 50;
                rect.w = 300;
                rect.h = 200;
                SDL_BlitScaled(gImage, NULL, gScreenSurface, &rect);
               
                SDL_UpdateWindowSurface(gWindow);
        }
}

void close() {
        SDL_FreeSurface(gImage);
        gImage = NULL;

        SDL_DestroyWindow(gWindow);
        gWindow = NULL;

        SDL_Quit();
}

SDL_Surface* loadImage(string path) {
        SDL_Surface* optimizedImage = NULL;
        SDL_Surface* newImage = SDL_LoadBMP(path.c_str());
        if (newImage == NULL) {
                cout << "Unable to load image " << path << "; SDL_image Error: " << IMG_GetError() << endl;
        } else {
                optimizedImage = SDL_ConvertSurface(newImage, gScreenSurface->format, NULL);
                if (optimizedImage == NULL) {
                        cout << "Unable to optimize image; SDL Error: " << SDL_GetError() << endl;
                }
                SDL_FreeSurface(newImage);
        }

        return optimizedImage;
}