#include <iostream>
#include <limits> // std::numeric_limits<>
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 = "GKiM - Lab 7 - Nazwisko Imie";


/** Reguly oceniania:
- Za bycie źródłem plagiatu -0,5 punkta. Proszę swoje rozwiązanie zlikwidować z komputera.
- Za plagiat przyznaje za zadanie 0 punktow!!! Dodam, ze mam program antyplagiatowy, zresztą Państwo wiedzą
- 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 elfa 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, prosze nie dawac zadnych podkreslen, spacji i numeru grupy [-0.1 punkta].

***************************************** zajecia 7:
Redukcja ilości barw:
Naszym zadaniem jest zmniejszenie palety dla składowej R, podobnie jak ostatnio, ale tym razem będziemy to robić w oparciu o oryginalny obrazek.
Wszystko ma się odbywać w Funkcja1()
1. Za wyświetlenie ilości unikalnych odcieni zadanej składowej na standardowe wyjście [0.5 punkta].
2. Za zredukowanie do 7 najczęstszych odcieni danej składowej i wyświetlenie tych najczęstrzych odcieni na standardowe wyjście. [0.5 punkta].
3. Za wyświetlenie wynikowego obrazka. [1 punkt].

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

Algorytm redukcji palety:
1. Znajdujemy wszystkie możliwe wartości zadanej składowej i zliczamy ile razy występuje dana wartość.
2. Sortujemy wg częstości występowania.
3. Dla wszystkich składowych poza zadaną ilością najczęściej występujących znajdujemy, który z najczęściej występujących
jest bliższy i wartość danej składowej zastępujemy najbliższą z najcześciej występujących odcieni.
**/


constexpr static auto MAX_COLOR_VALUE = std::numeric_limits<decltype(SDL_Color::r)>::max();
constexpr static auto MIN_COLOR_VALUE = std::numeric_limits<decltype(SDL_Color::r)>::min();


void Funkcja1();

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};

    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;
                }
            }
            if(event.type == SDL_MOUSEMOTION)
            {
                mousePosition = make_pair(event.motion.x, event.motion.y);
            }
            if(event.type == SDL_MOUSEBUTTONDOWN)
            {
                cout << "Pressed: (" << 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)
    {
        fprintf(stderr, "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 getPixel(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 setPixel(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 setPixel(int x, int y, SDL_Color color)
{
    setPixel(x, y, color.r, color.g, color.b);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////// TODO:

struct pix
{
    int color;
    int times;
};



void Sortowanie( pix tab[], int size = 256)
{
    for( int i = 0; i < size; ++i )
    {
        for( int j = 0; j < size - 1; ++j )
        {
            if( tab[j].times < tab[j + 1].times )
                 swap( tab[j], tab[j + 1]);

        }
    }
}


void Funkcja1()
{
    int halveW = width/2;
    int halveH = height/2;
    pix countR[256];
    for(int i=0; i<256; ++i)
    {
        countR[i].color = i;
        countR[i].times = 0;
    }
    // TODO: but without plagiarism!
    for(int y=0; y<halveH; ++y)
    {
        for(int x=0; x<halveW; ++x)
        {
            SDL_Color newColor;
            newColor = getPixel(x,y);
            ++countR[newColor.r].times;
        }
    }
    //zliczenie ile jest kolorow na obrazku o danej skladowej R
    int numberOfColors = 0;
    for(int i=0; i<256; ++i)
    {
        if(countR[i].times > 0)
            ++numberOfColors;
    }
    cout << "W obrazku wystepuje " << numberOfColors << " roznych kolorow" << endl;

    Sortowanie(countR);
    cout << "Najczesciej wystepuja: " << endl;
    if(numberOfColors < 7)
    {
        for(int i = 0; i<numberOfColors; ++i)
            cout << countR[i].color << " wystepuje " << countR[i].times << " razy" << endl;
    }
    else
    {
        for(int i=0; i<7; ++i)
            cout << countR[i].color << " wystepuje " << countR[i].times << " razy" << endl;
    }

    for(int y=0; y<halveH; ++y)
    {
        for(int x=0; x<halveW; ++x)
        {
            SDL_Color currentColor;
            currentColor = getPixel(x,y);
            int bestColor = countR[0].color;
            int distance = abs(currentColor.r - countR[0].color);
            for(int i=1; i<7; ++i)
            {
                int newDistance = abs(currentColor.r - countR[i].color);
                if( newDistance < distance)
                {
                    distance = newDistance;
                    bestColor = countR[i].color;
                }
            }
            currentColor.r = bestColor;
            setPixel(halveW+x,y, currentColor);
        }
    }
    SDL_Flip(screen);
}