#include <iostream>
#include <limits> // std::numeric_limits<>
#include <cmath>  // round()
using namespace std;

#ifdef __linux
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif

#if __cplusplus < 201103L
#error "Wymagany C++11!"
#endif // __cplusplus


SDL_Surface* screen;
const int width = 900, height = 600;
const char* title = "*insertlennyface*";


/** Reguly oceniania:
- Za bycie Ÿród³em plagiatu -0,5 punkta. Proszê swoje rozwi¹zanie zlikwidowaæ z komputera
(najlepiej z maszymy wirtualnej wys³aæ sobie na maila, gdy¿ bêdzie potrzebne na nastêpny raz).
- Za plagiat przyznaje za zadanie 0 punktow!!! Dodam, ze mam program antyplagiatowy.
- Za niewpisanie w pliku z kodem swojego Nazwiska i Imienia powyzej [-0.1 punkta]
- Za wrzucenie mi na pendrive/wyslanie na maila/za³adowanie na moodle wiecej niz jednego pliku zrodlowego (*.cpp) [-0.1 punkta]
- Za nienazwanie pliku zrodlowego NazwiskoImie.cpp, gdzie Nazwisko i Imie zastepujemy odpowiednio swoim nazwiskiem i imieniem, zadnych podkreslen, spacji i numeru grupy [-0.1 punkta]

***************************************** zajecia 6: 8 -bit color
Naszym dzisiejszym zadaniem bêdzie zapisywanie koloru 256*256*256 na palecie 256 kolorów.
W tym celu nasze sk³adowe R, G, B z których ka¿da mieœci siê na 8 bitach bêdziemy zapisywaæ odpowiednio na (3, 3, 2) bitach.
Zadanie 1: Zaimplementowanie Funkcja1(), aby stosuj¹c przesuniêcie bitowe zapisywa³a kolory na mniejszej liczbie bitów.
Proszê aby ekran by³ podzielony w nastêpuj¹cy sposób:
- lewy górny prostok¹cik: oryginalny obrazek RGB
- prawy górny: obrazek RGB, ale odtworzony ze sk³adowych z mniejszej iloœci bitów (na oko bêdzie bardziej pikselasty)
- lewy i prawy dolny: mog¹ Pañstwo u¿yæ do zapamiêtywania pewnych informacji -ich nie sprawdzam
[0.5 punkta].
Zadanie 2: Zaimplementowanie Funkcja2(), podobnie jak Funkcja1(), ale stosujemy zaokr¹glanie do najbli¿szego koloru
[0.5 punkta].
Zadanie 3: Zaimplementowanie Funkcja3(), stosuj¹c algorytm Floyda-Steinberga dla obrazu 2-kolorowego.
Algorytm proszê zastosowaæ tylko dla dwóch kolorów (jeœli jedna sk³adowa RGB>128 wstaw Bia³y, w przeciwnym razie Czarny).
- lewy górny prostok¹cik: oryginalny obrazek RGB
- prawy górny prostok¹cik: tylko sk³adowa R
- lewy dolny prostok¹cik: tylko sk³adowa G
- prawy dolny prostok¹cik: tylko sk³adowa B
oczywiœcie jeœli ktoœ chce sobie utrudniæ ¿ycie i implementowaæ dla (R, G, B) to te¿ mo¿e.
[1 punkt].

UWAGA: Proszê przynieœæ na nastêpny raz skoñczon¹ implementacjê -bêdzie potrzebna.
Przypominam, ¿eby dopilnowaæ, aby nie dzieliæ siê swoim zadaniem bo wtedy -0,5 punkta.

Dodatkowo: Za ladny, czytelny, czysty, KONSEKWENTNY kod implementowanych funkcji, zaimplementowanych w 100% [+0.5 punkta].
**/


/// SDL_Color operators:
ostream& operator<<(ostream& os, const SDL_Color color)
{
	return os << "(" << (int)color.r << ", " << (int)color.g << ", " << (int)color.b << ")";
}

inline bool operator==(const SDL_Color lhs, const SDL_Color rhs)
{
	return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b;
}


void Funkcja1(); // TODO: implement body
void Funkcja2(); // TODO: implement body
void Funkcja3(); // TODO: implement body

				 /// maybe next time:
void Funkcja4();
void Funkcja5();
void Funkcja6();
void Funkcja7();
void Funkcja8();
void Funkcja9();


int initSdl();

void loadBMP(const char* nazwa, int x, int y);

void clearScreen(Uint8 R = 0, Uint8 G = 0, Uint8 B = 0);


int main(int argc, char** argv)
{
	if (initSdl())
	{
		return -1;
	}

	pair<int, int> mousePosition{ 0, 0 };
	// program main loop
	bool done = false;
	while (!done)
	{
		// message processing loop
		SDL_Event event;
		while (SDL_PollEvent(&event))
		{
			if (SDL_QUIT == event.type)
			{
				done = true;
			}
			else if (SDL_KEYDOWN == event.type)
			{
				switch (event.key.keysym.sym)
				{
				case SDLK_ESCAPE:
					done = true;
					break;
				case SDLK_a:
					loadBMP("obrazek1.bmp", 0, 0);
					break;
				case SDLK_s:
					loadBMP("obrazek2.bmp", 0, 0);
					break;
				case SDLK_d:
					loadBMP("obrazek3.bmp", 0, 0);
					break;
				case SDLK_f: // zrodlo ponizszych obrazkow: https://pl.wikipedia.org/wiki/Algorytm_Floyda-Steinberga
					loadBMP("obrazek4.bmp", 0, 0);
					break;
				case SDLK_g:
					loadBMP("obrazek5.bmp", 0, 0);
					break;

				case SDLK_b:
					clearScreen(0, 0, 0);
					break;

				case SDLK_1:
					Funkcja1();
					break;
				case SDLK_2:
					Funkcja2();
					break;
				case SDLK_3:
					Funkcja3();
					break;
				case SDLK_4:
					Funkcja4();
					break;
				case SDLK_5:
					Funkcja5();
					break;
				case SDLK_6:
					Funkcja6();
					break;
				case SDLK_7:
					Funkcja7();
					break;
				case SDLK_8:
					Funkcja8();
					break;
				case SDLK_9:
					Funkcja9();
					break;
				}
			}
			if (SDL_MOUSEMOTION == event.type)
			{
				mousePosition = make_pair(event.motion.x, event.motion.y);
			}
			if (SDL_MOUSEBUTTONDOWN == event.type)
			{
				cout << "Kliknieto: (" << mousePosition.first << ", " << mousePosition.second << ")\n";
			}
		} // end of message processing
	} // end main loop
	return 0;
}

#ifdef _WIN32
// to solve problem: https://stackoverflow.com/questions/5259714/undefined-reference-to-winmain16
int WinMain()
{
	return main(1, NULL);
}
#endif // _WIN32

int initSdl()
{
	if (SDL_Init(SDL_INIT_VIDEO) < 0)
	{
		printf("Unable to init SDL: %s\n", SDL_GetError());
		return 1;
	}

	atexit(SDL_Quit);

	const int bitDepth = 32;

	/// create a new window
	screen = SDL_SetVideoMode(width, height, bitDepth, SDL_HWSURFACE | SDL_DOUBLEBUF);
	if (!screen)
	{
		printf("Unable to set video: %s\n", SDL_GetError());
		return 1;
	}

	SDL_WM_SetCaption(title, NULL);

	return 0;
}

void loadBMP(char const* nazwa, int x, int y)
{
	SDL_Surface* bmp = SDL_LoadBMP(nazwa);
	if (!bmp)
	{
		printf("Unable to load bitmap: %s\n", SDL_GetError());
	}
	else
	{
		SDL_Rect dstrect;
		dstrect.x = x;
		dstrect.y = y;
		SDL_BlitSurface(bmp, 0, screen, &dstrect);
		SDL_Flip(screen);
		SDL_FreeSurface(bmp);
	}
}

void clearScreen(Uint8 R, Uint8 G, Uint8 B)
{
	SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, R, G, B));
	SDL_Flip(screen);
}

inline bool inScreen(int x, int y)
{
	return x >= 0 && x < screen->w && y >= 0 && y < screen->h;
}

Uint8* getPixelAddress(int x, int y)
{
	if (inScreen(x, y))
	{
		/* Pobieramy informacji ile bajtów zajmuje jeden pixel */
		const int bpp = screen->format->BytesPerPixel;

		/* Obliczamy adres pixela */
		return (Uint8*)screen->pixels + y * screen->pitch + x * bpp;
	}
	return NULL;
}

SDL_Color getColor(int x, int y)
{
	Uint8* pixelAddress = getPixelAddress(x, y);

	SDL_Color color = {};
	if (pixelAddress)
	{
		Uint32 col = 0;

		memcpy(&col, pixelAddress, screen->format->BytesPerPixel);
		SDL_GetRGB(col, screen->format, &color.r, &color.g, &color.b);
	}

	return color;
}

void setColor(int x, int y, Uint8 R, Uint8 G, Uint8 B)
{
	Uint8* pixelAddress = getPixelAddress(x, y);
	if (pixelAddress)
	{
		Uint32 pixel = SDL_MapRGB(screen->format, R, G, B);

		switch (screen->format->BytesPerPixel)
		{
		case 1: //8-bit
			*pixelAddress = pixel;
			break;

		case 2: //16-bit
			*(Uint16*)pixelAddress = pixel;
			break;

		case 3: //24-bit
			if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
			{
				pixelAddress[0] = (pixel >> 16) & 0xff;
				pixelAddress[1] = (pixel >> 8) & 0xff;
				pixelAddress[2] = pixel & 0xff;
			}
			else
			{
				pixelAddress[0] = pixel & 0xff;
				pixelAddress[1] = (pixel >> 8) & 0xff;
				pixelAddress[2] = (pixel >> 16) & 0xff;
			}
			break;
		case 4: //32-bit
			*(Uint32*)pixelAddress = pixel;
			break;
		}
	}
	/* update the screen (aka double buffering) */
}

void setColor(int x, int y, SDL_Color color)
{
	setColor(x, y, color.r, color.g, color.b);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////// TODO:
void Funkcja1()
{
	constexpr auto halveW = width / 2;
	constexpr auto halveH = height / 2;

	for (int x = 0; x < halveW; ++x)
		for (int y = 0; y < halveH; ++y)
		{
			const SDL_Color currentColor = getColor(x, y);
			int red = (currentColor.r >> 6) << 6;
			int green = (currentColor.g >> 5) << 5;
			int blue = (currentColor.b >> 6) << 6;
			setColor(halveW + x, y, red, green, blue);
		}

	SDL_Flip(screen);
}

void Funkcja2()
{
	constexpr auto halveW = width / 2;
	constexpr auto halveH = height / 2;

	for (int x = 0; x < halveW; ++x)
		for (int y = 0; y < halveH; ++y)
		{
			const SDL_Color currentColor = getColor(x, y);
			int red = round(currentColor.r * 7 / 255);
			int green = round(currentColor.g * 7 / 255);
			int blue = round(currentColor.b * 3 / 255);
			setColor(halveW + x, y, red << 5, green << 5, blue << 6);
		}

	SDL_Flip(screen);
}

void Funkcja3()
{
	constexpr auto halveW = width / 2;
	constexpr auto halveH = height / 2;

	int e_tab[halveW + 2][halveH + 2] = { 0 };
	int e;

	for (int x = 0; x < halveW; ++x)
		for (int y = 0; y < halveH; ++y)
		{
			const SDL_Color currentColor = getColor(x, y);
			if (128 > e_tab[x][y] + currentColor.g) {
				setColor(halveW + x, y, 0, 0, 0);
				e = currentColor.g + e_tab[x][y];
			}
			else {
				setColor(halveW + x, y, 255, 255, 255);
				e = currentColor.g + e_tab[x][y] - 255;
			}
			e_tab[x][y + 1] = e_tab[x][y + 1] + 7 * e / 16;
			e_tab[x + 1][y - 1] = e_tab[x + 1][y - 1] + 3 * e / 16;
			e_tab[x + 1][y] = e_tab[x + 1][y] + 5 * e / 16;
			e_tab[x + 1][y + 1] = e_tab[x + 1][y + 1] + e / 16;
		}

	SDL_Flip(screen);
}


void Funkcja4()
{
	// TODO maybe next time: but without plagiarism!

	SDL_Flip(screen);
}

void Funkcja5()
{
	// TODO maybe next time: but without plagiarism!

	SDL_Flip(screen);
}

void Funkcja6()
{
	// TODO maybe next time: but without plagiarism!

	SDL_Flip(screen);
}

void Funkcja7()
{
	// TODO maybe next time: but without plagiarism!

	SDL_Flip(screen);
}


void Funkcja8()
{
	// TODO maybe next time: but without plagiarism!

	SDL_Flip(screen);
}

void Funkcja9()
{
	// TODO maybe next time: but without plagiarism!

	SDL_Flip(screen);
}