/*This source code copyrighted by Lazy Foo' Productions (2004-2019)
and may not be redistributed without written permission.*/

//Using SDL, SDL_image, standard IO, and strings
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <stdio.h>
#include <string>

//Screen dimension constants
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 640;

//Texture wrapper class
class LTexture
{
    public:
        //Initializes variables
        LTexture();

        //Deallocates memory
        ~LTexture();

        //Loads image at specified path
        bool loadFromFile( std::string path );
        //Deallocates texture
        void free();


        //Renders texture at given point
        void render( int x, int y, SDL_Rect* clip = NULL, double angle = 0.0, SDL_Point* center = NULL, SDL_RendererFlip flip = SDL_FLIP_NONE );


    private:
        //The actual hardware texture
        SDL_Texture* mTexture;

        //Image dimensions
        int mWidth;
        int mHeight;
};

class Player
{
    public:
        //The dimensions of the dot
        static const int DOT_WIDTH = 32;
        static const int DOT_HEIGHT = 48;

        //Maximum axis velocity of the dot
        static const int DOT_VEL = 4;

        //Initializes the variables
        void init();

        //Takes key presses and adjusts the dot's velocity
        void handleEvent( SDL_Event& e );

        //Moves the dot
        void move();

        //Shows the dot on the screen
        void render();

    private:
        //The X and Y offsets of the dot
        int xpos, ypos;

        //The velocity of the dot
        double velX, velY;
};


//Starts up SDL and creates window
bool init();

//Loads media
bool loadMedia();

//Frees media and shuts down SDL
void close();

//The window we'll be rendering to
SDL_Window* gWindow = NULL;

//The window renderer
SDL_Renderer* gRenderer = NULL;

//Scene textures
SDL_Rect gSpriteClips[ 7 ];
SDL_Rect gSpriteWalk[2];
SDL_Rect gSpriteJump[2];
LTexture gSpriteSheetTexture;
LTexture gSpriteWalkTexture;
LTexture gSpriteJumpTexture;
LTexture gDotTexture;

int isAttacking=0;
SDL_RendererFlip flipType = SDL_FLIP_NONE;
int flipflag =0;

LTexture::LTexture()
{
    //Initialize
    mTexture = NULL;
    mWidth = 0;
    mHeight = 0;
}

LTexture::~LTexture()
{
    //Deallocate
    free();
}

bool LTexture::loadFromFile( std::string path )
{
    //Get rid of preexisting texture
    free();

    //The final texture
    SDL_Texture* newTexture = NULL;

    //Load image at specified path
    SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
    if( loadedSurface == NULL )
    {
        printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
    }
    else
    {
        //Color key image
        SDL_SetColorKey( loadedSurface, SDL_TRUE, SDL_MapRGB( loadedSurface->format, 0, 0xFF, 0xFF ) );

        //Create texture from surface pixels
        newTexture = SDL_CreateTextureFromSurface( gRenderer, loadedSurface );
        if( newTexture == NULL )
        {
            printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
        }
        else
        {
            //Get image dimensions
            mWidth = loadedSurface->w;
            mHeight = loadedSurface->h;
        }

        //Get rid of old loaded surface
        SDL_FreeSurface( loadedSurface );
    }

    //Return success
    mTexture = newTexture;
    return mTexture != NULL;
}


void LTexture::free()
{
    //Free texture if it exists
    if( mTexture != NULL )
    {
        SDL_DestroyTexture( mTexture );
        mTexture = NULL;
        mWidth = 0;
        mHeight = 0;
    }
}


void LTexture::render( int x, int y, SDL_Rect* clip, double angle, SDL_Point* center, SDL_RendererFlip flip )
{
    //Set rendering space and render to screen
    SDL_Rect renderQuad = { x, y, mWidth, mHeight };

    //Set clip rendering dimensions
    if( clip != NULL )
    {
        renderQuad.w = clip->w;
        renderQuad.h = clip->h;
    }

    //Render to screen
    SDL_RenderCopyEx( gRenderer, mTexture, clip, &renderQuad, angle, center, flip );
}


void Player::init()
{
    //Initialize the offsets
    xpos = 0;
    ypos = 550;

    //Initialize the velocity
    velX = 0;
    velY = 0;
}

void Player::handleEvent( SDL_Event& e )
{
    //If a key was pressed
    if( e.type == SDL_KEYDOWN && e.key.repeat == 0)
    {
        //Adjust the velocity
        switch( e.key.keysym.sym )
        {
            case SDLK_UP:   velY = -5.0; break;
            //case SDLK_DOWN: velY += DOT_VEL; break;
            case SDLK_LEFT: velX = -7.5; break;
            case SDLK_RIGHT: velX = 7.5; break;
        }

        if(e.key.keysym.sym==SDLK_SPACE)
        {
            isAttacking = 1;
        }
    }
    //If a key was released
    else if( e.type == SDL_KEYUP && e.key.repeat == 0)
    {
        isAttacking = 0;
        //Adjust the velocity
        switch( e.key.keysym.sym)
        {
            //case SDLK_UP:  velY += DOT_VEL;break;
            //case SDLK_DOWN:  velY -= DOT_VEL; break;
            case SDLK_LEFT:  velX = 0; break;
            case SDLK_RIGHT: velX = 0; break;
        }
    }
}

/*void Player::move()
{
    //Move the dot left or right
    xpos += velX;

    //If the dot went too far to the left or right
    if( ( xpos < 0 ) || ( xpos + DOT_WIDTH > SCREEN_WIDTH ) )
    {
        //Move back
        xpos -= velX;
    }

    //Move the dot up or down
    ypos += velY;

    //If the dot went too far up or down
    if( ( ypos < 0 ) || ( ypos + DOT_HEIGHT > SCREEN_HEIGHT ) )
    {
        //Move back
        ypos -= velY;
    }
}*/



void Player::render()
{
    int frame = 0;

    //While application is running


                        if( velX > 0 && velY==0)
                        {
                            if(flipflag == 1)
                            {
                                flipType = SDL_FLIP_HORIZONTAL;
                                flipflag = 0;
                            }
                            else
                                flipType = SDL_FLIP_NONE;

                            for(int frame=0;frame<10;frame++)
                            {
                                //Render current frame
                                SDL_Rect* currentClip = &gSpriteWalk[ frame /5   ];
                                gSpriteWalkTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );
                                xpos++;
                                //Update screen
                                SDL_RenderPresent( gRenderer );

                                //Go to next frame
                                //++frame;

                                //Cycle animation
                                if( frame / 5 >= 2 )
                                {
                                    frame = 0;
                                    //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                    //SDL_RenderClear( gRenderer );

                                }
                                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                SDL_RenderClear( gRenderer );
                                xpos+=velX;
                            }
                        }

                        else if( velX < 0  && velY==0)
                        {

                            if(flipflag==0)
                            {
                                flipType = SDL_FLIP_HORIZONTAL;
                                flipflag = 1;
                            }

                            for(int frame=0;frame<10;frame++)
                            {
                                //Render current frame
                                SDL_Rect* currentClip = &gSpriteWalk[ frame /5   ];
                                gSpriteWalkTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip, 0, NULL, flipType  );
                                xpos--;
                                //Update screen
                                SDL_RenderPresent( gRenderer );

                                //Go to next frame
                                //++frame;

                                //Cycle animation
                                if( frame / 5 >= 2 )
                                {
                                    frame = 0;
                                    //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                    //SDL_RenderClear( gRenderer );

                                }
                                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                SDL_RenderClear( gRenderer );
                                xpos+=velX;
                            }
                        }

                        else if(velY < 0)
                        {
                            while(velY < 0)
                            {
                                if(flipflag ==0)
                                {
                                    flipType = SDL_FLIP_NONE;
                                }
                                else flipType = SDL_FLIP_HORIZONTAL;

                                    //Render current frame
                                    SDL_Rect* currentClip = &gSpriteJump[ 0 ];
                                    gSpriteJumpTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );
                                    //ypos -= 5;

                                    //Update screen
                                    SDL_RenderPresent( gRenderer );

                                    //Go to next frame
                                    //++frame;

                                    //Cycle animation

                                    SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                    SDL_RenderClear( gRenderer );
                                    xpos+=velX;
                                    ypos+=velY;
                                    velY+=0.4;
                                    if(velY > 0) break;
                            }
                            velY=0.0;
                            if(ypos<451&&velY==0.0)
                            {
                                while(ypos<451)
                                {
                                    if(flipflag ==0)
                                    {
                                        flipType = SDL_FLIP_NONE;
                                    }
                                    else flipType = SDL_FLIP_HORIZONTAL;

                                        //Render current frame
                                        SDL_Rect* currentClip = &gSpriteJump[ 1 ];
                                        gSpriteJumpTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );
                                        //y -= 5;

                                        //Update screen
                                        SDL_RenderPresent( gRenderer );

                                        //Go to next frame
                                        //++frame;

                                        //Cycle animation

                                        SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                        SDL_RenderClear( gRenderer );
                                        xpos+=velX;
                                        ypos+=velY;
                                        velY+=0.4;
                                }
                                velY=0.0;
                                ypos=450;

                            }

                            else if(isAttacking == 1)
                            {
                                if(flipflag == 1)
                                {
                                    flipType = SDL_FLIP_HORIZONTAL;
                                    //flipflag = 0;
                                }
                                else
                                    flipType = SDL_FLIP_NONE;
                                for(int frame=0;frame<35;frame++)
                                {
                                    //Render current frame
                                    SDL_Rect* currentClip = &gSpriteClips[ frame /5  ];
                                    gSpriteSheetTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );

                                    //Update screen
                                    SDL_RenderPresent( gRenderer );

                                    //Go to next frame
                                    //++frame;

                                    //Cycle animation
                                    if( frame / 5 >= 7 )
                                    {
                                        frame = 0;
                                        //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                        //SDL_RenderClear( gRenderer );

                                    }
                                    SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                    SDL_RenderClear( gRenderer );
                                }
                            }
                        }

                        /*else if(ypos<451&&velY==0.0)
                        {
                            while(ypos<451)
                            {
                                if(flipflag ==0)
                                {
                                    flipType = SDL_FLIP_NONE;
                                }
                                else flipType = SDL_FLIP_HORIZONTAL;

                                    //Render current frame
                                    SDL_Rect* currentClip = &gSpriteJump[ 1 ];
                                    gSpriteJumpTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );
                                    //y -= 5;

                                    //Update screen
                                    SDL_RenderPresent( gRenderer );

                                    //Go to next frame
                                    //++frame;

                                    //Cycle animation

                                    SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                    SDL_RenderClear( gRenderer );
                                    xpos+=velX;
                                    ypos+=velY;
                                    velY+=0.4;
                            }
                            velY=0.0;
                            ypos=450;

                        }*/

                        else if(isAttacking == 1)
                        {
                            if(flipflag == 1)
                            {
                                flipType = SDL_FLIP_HORIZONTAL;
                                //flipflag = 0;
                            }
                            else
                                flipType = SDL_FLIP_NONE;
                            for(int frame=0;frame<35;frame++)
                            {
                                //Render current frame
                                SDL_Rect* currentClip = &gSpriteClips[ frame /5  ];
                                gSpriteSheetTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );

                                //Update screen
                                SDL_RenderPresent( gRenderer );

                                //Go to next frame
                                //++frame;

                                //Cycle animation
                                if( frame / 5 >= 7 )
                                {
                                    frame = 0;
                                    //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                    //SDL_RenderClear( gRenderer );

                                }
                                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                SDL_RenderClear( gRenderer );
                            }
                        }



                    else if(velX==0.0 && velY==0.0 )
                    {
                                if(flipflag==0)
                                {
                                    flipType = SDL_FLIP_NONE;
                                }
                                else flipType = SDL_FLIP_HORIZONTAL;
                                SDL_Rect* currentClip = &gSpriteWalk[ 0 ];
                                gSpriteWalkTexture.render( ( xpos - currentClip->w ) / 2, ( ypos - currentClip->h ) / 2, currentClip , 0, NULL, flipType );

                                //Update screen
                                SDL_RenderPresent( gRenderer );
                                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                                SDL_RenderClear( gRenderer );
                    }


                //Clear screen
            //  SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
            //  SDL_RenderClear( gRenderer );


}

bool init()
{
    //Initialization flag
    bool success = true;

    //Initialize SDL
    if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
        success = false;
    }
    else
    {
        //Set texture filtering to linear
        if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
        {
            printf( "Warning: Linear texture filtering not enabled!" );
        }

        //Create window
        gWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
        if( gWindow == NULL )
        {
            printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
            success = false;
        }
        else
        {
            //Create vsynced renderer for window
            gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );
            if( gRenderer == NULL )
            {
                printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
                success = false;
            }
            else
            {
                //Initialize renderer color
                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );

                //Initialize PNG loading
                int imgFlags = IMG_INIT_PNG;
                if( !( IMG_Init( imgFlags ) & imgFlags ) )
                {
                    printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
                    success = false;
                }
            }
        }
    }

    return success;
}

bool loadMedia()
{
    //Loading success flag
    bool success = true;

    //Load sprite sheet texture
    if( !gSpriteSheetTexture.loadFromFile( "Sword.png" ) )
    {
        printf( "Failed to load walking animation texture!\n" );
        success = false;
    }
    else
    {
        //Set sprite clips
        for(int i=0;i<7;i++)
        {
            gSpriteClips[ i ].x =   32*i;
            gSpriteClips[ i ].y =   0;
            gSpriteClips[ i ].w =  32;
            gSpriteClips[ i ].h =  48;
        }
    }
    if( !gSpriteWalkTexture.loadFromFile( "walk.png" ) )
    {
        printf( "Failed to load walking animation texture!\n" );
        success = false;
    }
    else
    {
        //Set sprite clips
        for(int i=0;i<2;i++)
        {
            gSpriteWalk[ i ].x =   32*i;
            gSpriteWalk[ i ].y =   0;
            gSpriteWalk[ i ].w =  32;
            gSpriteWalk[ i ].h =  48;
        }
    }


    if( !gSpriteJumpTexture.loadFromFile( "jump.png" ) )
    {
        printf( "Failed to load walking animation texture!\n" );
        success = false;
    }
    else
    {
        //Set sprite clips
        for(int i=0;i<2;i++)
        {
            gSpriteJump[ i ].x =   32*i;
            gSpriteJump[ i ].y =   0;
            gSpriteJump[ i ].w =  32;
            gSpriteJump[ i ].h =  48;
        }
    }

    return success;
}

void close()
{
    //Free loaded images
    gDotTexture.free();

    //Destroy window
    SDL_DestroyRenderer( gRenderer );
    SDL_DestroyWindow( gWindow );
    gWindow = NULL;
    gRenderer = NULL;

    //Quit SDL subsystems
    IMG_Quit();
    SDL_Quit();
}

int main( int argc, char* args[] )
{
    //Start up SDL and create window
    if( !init() )
    {
        printf( "Failed to initialize!\n" );
    }
    else
    {
        //Load media
        if( !loadMedia() )
        {
            printf( "Failed to load media!\n" );
        }
        else
        {
            //Main loop flag
            bool quit = false;

            //Event handler
            SDL_Event e;

            //The dot that will be moving around on the screen
            Player player;
            player.init();

            //While application is running
            while( !quit )
            {
                //Handle events on queue
                while( SDL_PollEvent( &e ) != 0 )
                {
                    //User requests quit
                    if( e.type == SDL_QUIT )
                    {
                        quit = true;
                    }

                    //Handle input for the dot
                    player.handleEvent( e );
                }

                //Move the dot
                //player.move();

                //Clear screen
                //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                //SDL_RenderClear( gRenderer );

                //Render objects
                player.render();

                //Update screen
                //SDL_RenderPresent( gRenderer );
            }
        }
    }

    //Free resources and close SDL
    close();

    return 0;
}