#include <SDL.h>
#include <SDL_Image.h>
#include <string>
#include <vector>

SDL_Surface* Load_Image(std::string filename, bool Color_Key = false, int R=0, int G=0, int B=0);
void Apply_Surface(int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL);


#define SCREEN_WIDTH 400
#define SCREEN_HEIGHT 400
#define SCREEN_BPP 32

#define CHAR_VELOCITY 5

#define FRAMES_PER_SECOND 60

SDL_Surface* Screen = NULL;
SDL_Surface* BackGround = NULL;


enum STATE
{
    E_STATE_STAND,
    E_STATE_WALK_R,
    E_STATE_DEATH,
    E_COUNT
};

class Timer
{
    public:
        Timer();

        int
            StartTicks,
            PauseTicks;

        bool
            Started,
            Paused;

        void Start();
        void Stop();
        void Pause();
        void UnPause();

        int GetTicks();
};

class Character
{
    public:
        Character();
        ~Character();

        int
            X,
            Y,
            VX,
            VY,
            Frame;

        SDL_Surface* Image;

        STATE
            state;

        std::vector< std::vector<SDL_Rect> > sprite;
        std::vector<Timer> fps;

        void UpdateState(STATE);

        int AddFrame(STATE,int,int,int,int);
        int AddFrameEx(STATE,int=0,int=0,int=0,int=0);

        void ApplyAnim(SDL_Surface*, int);

        SDL_Surface* LoadImage(std::string, bool=false,int=0,int=0,int=0);
};

void Character::ApplyAnim(SDL_Surface* Screen, int frames)
{
    if(!fps[state].Started) fps[state].Start();
    if(Frame >= sprite[state].size()) Frame = 0;

    bool
        inc = false;

    if(fps[state].GetTicks() > 1000/frames)
    {
        fps[state].Start();
        inc = true;
    }

    Apply_Surface(X,Y,Image,Screen,&sprite[state][Frame]);
    Frame += (inc) ? (1) : (0);
}

SDL_Surface* Character::LoadImage(std::string filename, bool Color_Key, int R, int G, int B)
{
    Image = Load_Image(filename,Color_Key,R,G,B);
    return Image;
}

void Character::UpdateState(STATE newstate)
{
    fps[state].Stop();

    Frame = 0;
    state = newstate;

    fps[state].Start();
}

int Character::AddFrameEx(STATE state, int x, int y, int w, int h)
{
    sprite[state].push_back(SDL_Rect());

    int
        index = sprite[state].size()-1,
        previous = index-1;

    if(!index)
    {
        sprite[state][index].x = x;
        sprite[state][index].y = y;
        sprite[state][index].w = w;
        sprite[state][index].h = h;

        return index;
    }
    sprite[state][index].x = sprite[state][previous].x + x;
    sprite[state][index].y = sprite[state][previous].y + y;
    sprite[state][index].w = sprite[state][previous].w + w;
    sprite[state][index].h = sprite[state][previous].h + h;

    return index;
}

int Character::AddFrame(STATE state, int x, int y, int w, int h)
{
    sprite[state].push_back(SDL_Rect());

    int
        index = sprite[state].size()-1;

    sprite[state][index].x = x;
    sprite[state][index].y = y;
    sprite[state][index].w = w;
    sprite[state][index].h = h;

    return index;
}

Character::Character()
{
    Frame = NULL,
    X = NULL,
    Y = NULL,
    VX = NULL,
    VY = NULL,
    Image = NULL,
    state = E_STATE_STAND;

    for(int i = 0; i < E_COUNT; i++)
    {
        fps.push_back(Timer());
        sprite.push_back(std::vector<SDL_Rect>());
    }
}

Character::~Character()
{
    SDL_FreeSurface(Image);
}


void Timer::UnPause()
{
    if(Paused)
    {
        Paused = false;

        StartTicks = SDL_GetTicks() - PauseTicks;
        PauseTicks = 0;
    }
}

void Timer::Pause()
{
    if(Started)
    {
        if(!Paused)
        {
            Paused = true;
            PauseTicks = SDL_GetTicks() - StartTicks;
        }
    }
}


int Timer::GetTicks()
{
    if(Started)
    {
        if(Paused) return PauseTicks;

        return SDL_GetTicks() - StartTicks;
    }
    return 0;
}

void Timer::Stop()
{
    Started = false;
    Paused = false;
}

void Timer::Start()
{
    Started = true;
    Paused = false;

    StartTicks = SDL_GetTicks();
}

Timer::Timer()
{
    StartTicks = 0;
    PauseTicks = 0;
    Started = false;
    Paused = false;
}

Timer fps;
Character Mario;

int main(int argc, char * args[])
{
    if(SDL_Init(SDL_INIT_EVERYTHING) != -1)
    {
        Screen = SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,SDL_SWSURFACE);

        if(Screen)
        {
            SDL_WM_SetCaption("Kyoshiro's SDL tests",NULL);

            BackGround = Load_Image("background.jpg");
            Mario.LoadImage("mario.png"); //163 77 77


            Mario.AddFrame(E_STATE_DEATH, 0,35,40,40);

            int pf;

            pf = Mario.AddFrame(E_STATE_STAND, 195,265,40,45);
            pf = Mario.AddFrameEx(E_STATE_STAND, Mario.sprite[E_STATE_STAND][pf].w);
            pf = Mario.AddFrameEx(E_STATE_STAND, Mario.sprite[E_STATE_STAND][pf].w);
            pf = Mario.AddFrameEx(E_STATE_STAND, Mario.sprite[E_STATE_STAND][pf].w);

            pf = Mario.AddFrame(E_STATE_WALK_R, 318,70,40,45);
            Mario.AddFrame(E_STATE_WALK_R, 200,70,40,45);
            Mario.AddFrame(E_STATE_WALK_R, 358,70,40,45);


            while(true)
            {
                SDL_Event Event;

                fps.Start();

                int
                    TX = Mario.X + Mario.VX,
                    TY = Mario.Y + Mario.VY;

                if(!(SCREEN_WIDTH-Mario.sprite[Mario.state][Mario.Frame].w >= TX && TX >= 0))
                {
                    Mario.X = (TX > 0)?(SCREEN_WIDTH-Mario.sprite[Mario.state][Mario.Frame].w):(0);
                }
                else
                {
                    Mario.X = TX;
                }

                if(!(SCREEN_HEIGHT-Mario.sprite[Mario.state][Mario.Frame].h >= TY && TY >= 0))
                {
                    Mario.Y = (TY > 0)?(SCREEN_HEIGHT-Mario.sprite[Mario.state][Mario.Frame].h):(0);
                }
                else
                {
                    Mario.Y = TY;
                }

                Apply_Surface(0,0,BackGround,Screen);
                Mario.ApplyAnim(Screen,15);

                SDL_Flip(Screen);

                while(SDL_PollEvent(&Event))
                {
                    if(Event.type == SDL_KEYUP)
                    {
                        switch(Event.key.keysym.sym)
                        {
                            case SDLK_DOWN: Mario.VY -= CHAR_VELOCITY; break;
                            case SDLK_UP: Mario.VY += CHAR_VELOCITY; break;
                            case SDLK_LEFT: Mario.VX += CHAR_VELOCITY; break;
                            case SDLK_RIGHT: Mario.VX -= CHAR_VELOCITY; break;
                        }
                    }
                    if(Event.type == SDL_KEYDOWN)
                    {
                        switch(Event.key.keysym.sym)
                        {
                            //for testing
                            case SDLK_F1: Mario.UpdateState(E_STATE_WALK_R); break;
                            case SDLK_F2: Mario.UpdateState(E_STATE_STAND); break;
                            case SDLK_F3: Mario.UpdateState(E_STATE_DEATH); break;

                            case SDLK_DOWN: Mario.VY += CHAR_VELOCITY; break;
                            case SDLK_UP: Mario.VY -= CHAR_VELOCITY; break;
                            case SDLK_LEFT: Mario.VX -= CHAR_VELOCITY; break;
                            case SDLK_RIGHT: Mario.VX += CHAR_VELOCITY; break;
                        }
                    }
                    if(Event.type == SDL_QUIT)
                    {
                        SDL_FreeSurface(BackGround);

                        SDL_Quit();
                        return 1;
                    }
                }

                if(Mario.Frame >= Mario.sprite[Mario.state].size()) Mario.Frame = 0;

                if(fps.GetTicks() < 1000 / FRAMES_PER_SECOND)
                {
                    SDL_Delay((1000 / FRAMES_PER_SECOND) - fps.GetTicks());
                }

            }

        }
    }
    return 1;
}


SDL_Surface* Load_Image(std::string filename, bool Color_Key, int R, int G, int B)
{
    SDL_Surface* loadedImage = NULL;
    SDL_Surface* optimizedImage = NULL;

    loadedImage = IMG_Load(filename.c_str());

    if(loadedImage)
    {
        optimizedImage = SDL_DisplayFormat(loadedImage);
        SDL_FreeSurface(loadedImage);

        if(optimizedImage)
        {
            if(Color_Key)
            {
                Uint32 ColorKey = SDL_MapRGB(optimizedImage->format,R,G,B);
                SDL_SetColorKey( optimizedImage, SDL_SRCCOLORKEY, ColorKey);
            }
        }
    }
    return optimizedImage;
}

void Apply_Surface(int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip)
{
    SDL_Rect offset;

    offset.x = x;
    offset.y = y;

    SDL_BlitSurface(source, clip, destination, &offset );
}