#include "renderer.h"
#include <stdio.h>
#include <math.h>   // för fmod()
#include <stdlib.h> // för rand()
#include <string.h> // för strlen

#include "vecmath.h"
#include "gameobject.h"
#include "player.h"
#include "background.h"
#include "enemies.h"

typedef struct {
    int time;
    void (*function) (void);
} GameEvent;

GameEvent gameEvents[] = {
    { 0, createHearts },
    { 0, createCoins }
};
int nextEvent = 0;
int nGameEvents = sizeof(gameEvents) / sizeof(GameEvent);


const Uint8 *state;

void close(); 
void vändSträng();
void printToWindow(char* str, int x, int y);
void printToConsole(char* str, int x, int y);


unsigned int t = 0;
bool bShake = false;
unsigned int shakeStop = 0;
void shake(float *x, float *y)
{
    // om bShake == false, initiera shake med sannolikhet 1/60.
    //      Sätt bShake = true;
    //      Sätt shakeStop till t + (30 till 50) frames
    // om (bShake && t < shakeStop)
    //      addera omväxlande -1 resp 1 varannan frame till x,y
    // om (bShake && t >= shakeStop)
    //      sätt bShake = false;
    
    if( bShake == false && ((rand() % 60)==1) ) {
        bShake = true;
        shakeStop = t + (rand() % 20) + 30;
    }
    if( bShake && t < shakeStop) {
        *x += 2*(((int)t % 3) - (int)1); // <-- Ändra till detta
        *y += ((rand() % 3) - (int)1); 
    }
    if( bShake && (t >= shakeStop) ) {
        bShake = false;
    }
    t++;
}

int main( int argc, char* args[] )
{
	// Start up SDL and create window of width=800, height = 600
	initRenderer(800, 600); 

    // Create objects
    createBackground(); 
    createShip();   
//    createHearts();
//    createCoins();

    state = SDL_GetKeyboardState(NULL); // get pointer to key states 
    void (*print) (char* str, int x, int y) = printToWindow;
    char sträng[] = "Hello World!";
    int  loopIter = 0;
    while(true) // The real-time loop
    {
        // Handle events on the inqueue (e.g., mouse events)
        SDL_Event e;  //Event handler
        while( SDL_PollEvent( &e ) != 0 )
        {
            if( e.type == SDL_QUIT ) {   //User requests quit
                close(); 
                exit(0);
            }
            if( (e.type == SDL_KEYDOWN) && (e.key.keysym.scancode == SDL_SCANCODE_C) ) {
                static bool toggle = true;
                toggle = !toggle;
                if(!toggle)
                    print = printToConsole;
                else
                    print = printToWindow;
            }        
        }
        
        // Handle initiation of game events
        while(loopIter >= gameEvents[nextEvent].time && nextEvent < nGameEvents) {
            gameEvents[nextEvent].function();
            nextEvent++;
        }            
    

        
        // Clear screen with a grey background color, red=0x33, blue=0x33, green=0x33, alpha=0xff. 0=minimum, 0xff=maximum.
        // Alpha is transparency: 0 = fully transparent, 0xFF = fully opaque. However, actual use of transparency requires further settings.
        SDL_SetRenderDrawColor( gRenderer, 0x33, 0x33, 0x33, 0xFF ); 
        SDL_RenderClear( gRenderer );
      
        // Collision detection
        collisionDetection();
        
        // Update our objects
        updateAllGameObjects();
        removeDeadObjects();
        
        // Render our objects
        renderAllGameObjects();

        if( (loopIter % 100) == 99 )
            vändSträng(sträng);
        print(sträng, 300, 150);
         
        // This function updates the screen and also sleeps ~16 ms or so (based on the screen's refresh rate),  
        // because we used the flag SDL_RENDERER_PRESENTVSYNC in function initRenderer()
        SDL_RenderPresent( gRenderer );
        loopIter++;
    }

	close(); //Free allocated resources
	return 0;
}

void vändSträng(char str[])
{
    int l = strlen(str); 
    int half_len = l/2;
    for(int i=0; i<half_len; i++) {
        // swap two elements
        char t = str[i];
        str[i] = str[l - i - 1];
        str[l - i - 1] = t;
    }
}

void printToWindow(char* str, int x, int y)
{
   renderText(str, x, y);
}

void printToConsole(char* str, int x, int y)
{
   printf("%s\n", str); 
}


void close()
{
    //Preferably, you should free all your GfxObjects, by calls to freeGfxObject(GfxObject* obj), but you don't have to.
    freeGfxObject(&ship.gfxObj);
    freeGfxObject(&background.gfxObj);
    
    closeRenderer(); //Free resources and close SDL
}