#include <SDL.h>

#include "World.h"

using SDLInitType=std::pair<int,std::pair<SDL_Window*,SDL_Renderer*>>;

SDLInitType sdl_start(int win_width, int win_height)
{
	//First we need to start up SDL, and make sure it went ok
	if (SDL_Init(SDL_INIT_VIDEO) != 0){
		std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
		return {1,{nullptr,nullptr}};
	}
	std::cout << "SDL_Init OK" << std::endl;

	atexit(SDL_Quit);
	
	//Now create a window with title "Hello World" at 100, 100 on the screen with w:640 h:480 and show it
	SDL_Window *win = SDL_CreateWindow("Hello World!", 200, 100, win_width, win_height, SDL_WINDOW_SHOWN|SDL_WINDOW_RESIZABLE);
	//Make sure creating our window went ok
	if (win == nullptr){
		std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
		return {1,{nullptr,nullptr}};
	}
	std::cout << "SDL_CreateWindow OK" << std::endl;

	//Create a renderer that will draw to the window, -1 specifies that we want to load whichever
	//video driver supports the flags we're passing
	//Flags: SDL_RENDERER_ACCELERATED: We want to use hardware accelerated rendering
	//SDL_RENDERER_PRESENTVSYNC: We want the renderer's present function (update screen) to be
	//synchronized with the monitor's refresh rate
	SDL_Renderer *ren = SDL_CreateRenderer(win, -1,0);//, SDL_RENDERER_SOFTWARE);// | SDL_RENDERER_PRESENTVSYNC|SDL_HINT_RENDER_VSYNC);
	if (ren == nullptr){
		SDL_DestroyWindow(win);
		std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
		return {1,{win,nullptr}};
	}
	std::cout << "SDL_CreateRenderer OK" << std::endl;

	return {0,{win,ren}};
}

void sdl_stop(SDLInitType sdl_init)
{
	if(sdl_init.second.second!=nullptr)SDL_DestroyRenderer(sdl_init.second.second);
	if(sdl_init.second.first!=nullptr)SDL_DestroyWindow(sdl_init.second.first);
}

SDL_Texture* sdl_load_texture(std::string imagePath,int key_r, int key_g, int key_b,SDL_Renderer *ren)
{
	//SDL 2.0 now uses textures to draw things but SDL_LoadBMP returns a surface
	//this lets us choose when to upload or remove textures from the GPU
	SDL_Surface *bmp = SDL_LoadBMP(imagePath.c_str());
	SDL_SetColorKey(bmp, SDL_TRUE, SDL_MapRGB(bmp->format, key_r, key_g, key_b));

	if (bmp == nullptr){
		std::cout << "SDL_LoadBMP Error: " << SDL_GetError() << std::endl;
		return nullptr;
	}
	std::cout << "SDL_LoadBMP ("<<imagePath<<") OK"<<std::endl;

	SDL_Texture *tex = SDL_CreateTextureFromSurface(ren, bmp);

	//We no longer need the surface
	SDL_FreeSurface(bmp);

	if (tex == nullptr){
		std::cout << "SDL_CreateTextureFromSurface Error: " << SDL_GetError() << std::endl;
		return nullptr;
	}
	std::cout << "SDL_CreateTextureFromSurface ("<<imagePath<<") OK"<<std::endl;
//       SDL_LockSurface(bmp4);
//       SDL_memset(bmp4->pixels,SDL_MapRGBA(bmp4->format, 255, 0, 255,220), bmp4->h * bmp4->pitch);
//       SDL_UnlockSurface(bmp4);

	//To use a hardware accelerated texture for rendering we can create one from
	//the surface we loaded

	return tex;
}

//

int main(int, char**){

	// initial values
	int win_width=640;
	int win_height=480;

	SDLInitType sdl_init=sdl_start(win_width,win_height);
	if(sdl_init.first!=0)
	{	
		sdl_stop(sdl_init);
		return sdl_init.first;
	}

	SDL_Renderer *ren=sdl_init.second.second;

	std::vector<SDL_Texture*> textures;
	textures.push_back(sdl_load_texture("guy01.bmp",0,0,255,ren));
	textures.push_back(sdl_load_texture("guy02.bmp",0,0,255,ren));
	textures.push_back(sdl_load_texture("hello.bmp",0,0,255,ren));
	textures.push_back(sdl_load_texture("fonts.bmp",0,0,0,ren));
	textures.push_back(sdl_load_texture("earth01.bmp",0,0,0,ren));
	textures.push_back(sdl_load_texture("gridder01.bmp",255,255,255,ren));
	textures.push_back(sdl_load_texture("gridder02.bmp",255,255,255,ren));
	
	//	SDL_SetTextureColorMod(tex4,255,0,0);

	bool quit = false;
	SDL_Event event;

	Uint32 frameTime;
	Uint32 lastFrameTime = 0;
	Uint32 deltaTime = 0;
	Uint32 fpsTime = 0;
	Uint32 fpsCount = 0;

	Uint32 mouse_x=0;
	Uint32 mouse_y=0;


	// init world LEVEL 1
	World world(1);

	while (!quit)
	{
		// calc delta and FPS
		frameTime = SDL_GetTicks();
		deltaTime = frameTime - lastFrameTime;
		lastFrameTime = frameTime;
		fpsTime+=deltaTime;
		fpsCount++;

		if(fpsTime>3000)
		{
			std::cout << "FPS : " << fpsCount*1000/fpsTime  << std::endl;
			fpsTime=0;
			fpsCount=0;
		}


		// handle events (mouse & kb & win resize)
		while(!quit && SDL_PollEvent(&event)) 
		{
			if (event.type == SDL_WINDOWEVENT && (event.window.event==SDL_WINDOWEVENT_RESIZED || event.window.event==SDL_WINDOWEVENT_SIZE_CHANGED)) 
			{
			   SDL_Log("Window %d size changed to %dx%d",
			    event.window.windowID, event.window.data1,
			    event.window.data2);
				win_width=event.window.data1;
				win_height=event.window.data2;

			}

			if (event.type==SDL_MOUSEBUTTONDOWN)
			{
				mouse_x=event.button.x;
				mouse_y=event.button.y;

				world.bricks[(mouse_x+50-world.player.x2)/100+world.player.x-5][0].altitude=10-mouse_y/100;
			}


			switch (event.type) {
				case SDL_QUIT:
					quit = true;
					break;

				case SDL_KEYDOWN:
					if (event.key.keysym.sym == SDLK_ESCAPE)
					quit = true;
					break;
				default:
					break;
			}
		}

		// rendering & run world simu
		SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
		SDL_RenderClear(ren);

		int br=-1;

		for(int i=world.player.x-5;i<world.player.x+30;i++)
		{
			br++;
			if(i<0||i>=world.bricks.size())continue;

			for(int j=0;j<world.bricks[i].size();j++)
			{
				SDL_Rect rect={br*100-100*world.player.x2,(10-world.bricks[i][j].altitude)*100,100,100};
					
				switch(world.bricks[i][j].type)
				{
					case 1:
						SDL_RenderCopy(ren,textures[4],NULL,&rect);
						break;
					case 0:
						SDL_RenderCopy(ren,textures[4],NULL,&rect);
						SDL_SetRenderDrawColor(ren, 150+19*(i%2),115,70,  255);
						rect.h=800;
						rect.y+=100;
						SDL_RenderFillRect(ren,&rect);
						break;
				}
						

				
			}

			SDL_SetRenderDrawColor(ren, 100*(i%2),100*(i%2),255,  255);
			SDL_Rect rect2={br*100-100*world.player.x2,(15)*100+std::sin(frameTime/1000.0+i)*30,100,800};
			SDL_RenderFillRect(ren,&rect2);
		}

		SDL_Rect rect={450,(9-world.bricks[0][0].altitude)*100,100,100};
		if(world.player.anim==0)SDL_RenderCopy(ren,textures[0],NULL,&rect);
		else SDL_RenderCopy(ren,textures[1],NULL,&rect);

		SDL_Rect rect2={300,50,640+std::sin(frameTime/1000.0)*100,200};
		SDL_RenderCopyEx(ren,textures[2],NULL,&rect2,std::sin(frameTime/1000.0)*10,NULL,SDL_FLIP_NONE);

//		SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
//		SDL_Rect rect={mouse_x-10,mouse_y-10,20,20};


		// test text:

		std::string testString="Hello World\nMotherfuckas";
//.		SDL_RenderCopyEx(ren,tex4,NULL,NULL,0,NULL,SDL_FLIP_NONE);
		
		

		SDL_RenderPresent(ren);

		// run world simu 
		world.sim(deltaTime);

	}


	//Clean up our objects and quit
	for(SDL_Texture *tex:textures)
	{
		SDL_DestroyTexture(tex);
	}

	sdl_stop(sdl_init);
	
	return 0;
}