// Dolaczamy plik naglowkowy naszej klasy MyWindow
#include "mywindow.h"

// Dolaczamy plik naglowkowy zawierajacy definicje GUI
// Plik ten jest generowany automatycznie
// z pliku XML "mywindow.ui"
#include "ui_mywindow.h"

#include <cmath>
#include <QColor>
#include <QDebug>
#include <QColorDialog>
#include <iostream>
#include <float.h> // for float,double macros
#include <string.h>
#include <stack>
#include <vector>

#define PI 3.1415

std::vector<float> matrixMul(std::vector<float> p, std::vector<float> m)
{
    std::vector<float> res(3);
    for(int i = 0; i < 3; i++)
    {
        res.push_back(0);
        for(int j = 0; j < 3; j++)
        {
            res[i] += m[i * 3 + j] * p[j];
        }
    }
    return res;
}

std::vector<float> matrixMul3x3(std::vector<float> m1, std::vector<float> m2)
{
    std::vector<float> res(9, 0);
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            for(int k = 0; k < 3; k++)
            {
                res[i * 3 + j] += m1[i * 3 + k] * m2[k * 3 + j];
            }
        }
    }
    return res;
}


QColor mul(float v, QColor c){
    int red = (int)(c.red() * v);
    if(red > 255) red = 255;
    int green = (int)(c.green() * v);
    if(green > 255) green = 255;
    int blue = (int)(c.blue() * v);
    if(blue > 255) blue = 255;
    return QColor(red, green, blue);
}

QColor add(QColor c1, QColor c2){
    int red = (int)(c1.red() + c2.red());
    if(red > 255) red = 255;
    int green = (int)(c1.green() + c2.green());
    if(green > 255) green = 255;
    int blue = (int)(c1.blue() + c2.blue());
    if(blue > 255) blue = 255;
    return QColor(red, green, blue);
}
// Definicja konstruktora, wywolujemy najpierw
// konstruktor klasy nadrzednej, nastepnie tworzymy
// obiekt klasy Ui_MyWindow reprezentujacy GUI
MyWindow::MyWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MyWindow)
{
    // Wywolujemy funkcje tworzaca elementy GUI
    // Jej definicja znajduje sie w pliku "ui_mywindow.h"
    ui->setupUi(this);

    // Pobieramy wymiary i wspolrzedne lewego gornego naroznika ramki
    // i ustawiamy wartosci odpowiednich pol
    // Uwaga: ramke "rysujFrame" wykorzystujemy tylko do
    // wygodnego ustaiwenia tych wymiarow. Rysunek bedziemy wyswietlac
    // bezposrednio w glownym oknie aplikacji.
    szer = ui->rysujFrame->width();
    wys = ui->rysujFrame->height();
    poczX = ui->rysujFrame->x();
    poczY = ui->rysujFrame->y();

    // Tworzymy obiekt klasy QImage, o odpowiedniej szerokosci
    // i wysokosci. Ustawiamy format bitmapy na 32 bitowe RGB
    // (0xffRRGGBB).
    img = new QImage(szer,wys,QImage::Format_RGB32);

    loaded_img1 = new QImage("/home/davp/umk/2022_2023/GK/QT/alpha-blending/p.png");
    loaded_img2 = new QImage("/home/davp/umk/2022_2023/GK/QT/alpha-blending/f.png");

    rotation_angle = 0;


    UpdateImage();
}

// Definicja destruktora
MyWindow::~MyWindow()
{
    delete ui;
}

// Funkcja (slot) wywolywana po nacisnieciu przycisku "Wyjscie" (exitButton)
// Uwaga: polaczenie tej funkcji z sygnalem "clicked"
// emitowanym przez przycisk jest realizowane
// za pomoca funkcji QMetaObject::connectSlotsByName(MyWindow)
// znajdujacej sie w automatycznie generowanym pliku "ui_mywindow.h"
// Nie musimy wiec sami wywolywac funkcji "connect"
void MyWindow::on_exitButton_clicked()
{
    // qApp to globalny wskaznik do obiektu reprezentujacego aplikacje
    // quit() to funkcja (slot) powodujaca zakonczenie aplikacji z kodem 0 (brak bledu)
    qApp->quit();
}

void MyWindow::on_slider_mode_valueChanged(int val){
    mode = val;
}

void MyWindow::on_slider_a_valueChanged(int val){
    alpha = (float) val / 100.0f;
}


QColor Normal(QColor c1, QColor c2){
    return c2;
}

QColor Multiply(QColor c1, QColor c2){
    return QColor(
        (c1.red() * c2.red()) >> 8,
        (c1.green() * c2.green()) >> 8,
        (c1.blue() * c2.blue()) >> 8,
        (c1.alpha() * c2.alpha()) >> 8);
}

QColor Screen(QColor c1, QColor c2){
    return QColor(
        255 - (((255 - c1.red()) * (255 - c2.red())) >> 8),
        255 - (((255 - c1.green()) * (255 - c2.green())) >> 8),
        255 - (((255 - c1.blue()) * (255 - c2.blue())) >> 8),
        255 - (((255 - c1.alpha()) * (255 - c2.alpha())) >> 8));
}

QColor Overlay(QColor c1, QColor c2){
    int r = c1.red() < 128 ? (c1.red() * c2.red()) >> 7 : 255 - (((255 - c1.red()) * (255 - c2.red())) >> 7);
    int g = c1.green() < 128 ? (c1.green() * c2.green()) >> 7 : 255 - (((255 - c1.green()) * (255 - c2.green())) >> 7);
    int b = c1.blue() < 128 ? (c1.blue() * c2.blue()) >> 7 : 255 - (((255 - c1.blue()) * (255 - c2.blue())) >> 7);
    int a = c1.alpha() < 128 ? (c1.alpha() * c2.alpha()) >> 7 : 255 - (((255 - c1.alpha()) * (255 - c2.alpha())) >> 7);
    return QColor(r, g, b, a);
}

QColor Darken(QColor c1, QColor c2){
    int r = c1.red() < c2.red() ? c1.red() : c2.red();
    int g = c1.green() < c2.green() ? c1.green() : c2.green();
    int b = c1.blue() < c2.blue() ? c1.blue() : c2.blue();
    int a = c1.alpha() < c2.alpha() ? c1.alpha() : c2.alpha();
    return QColor(r, g, b, a);
}

QColor Lighten(QColor c1, QColor c2){
    int r = c1.red() > c2.red() ? c1.red() : c2.red();
    int g = c1.green() > c2.green() ? c1.green() : c2.green();
    int b = c1.blue() > c2.blue() ? c1.blue() : c2.blue();
    int a = c1.alpha() > c2.alpha() ? c1.alpha() : c2.alpha();
    return QColor(r, g, b, a);
}

QColor Blend(QColor c1, QColor c2, float a, int p){
    switch (p) {
    case 0:
        return add(mul(a, Normal(c1, c2)), mul((1.0f - a), c1));
        break;
    case 1:
        return add(mul(a, Multiply(c1, c2)), mul((1.0f - a), c1));
        break;
    case 2:
        return add(mul(a, Screen(c1, c2)), mul((1.0f - a), c1));
        break;
    case 3:
        return add(mul(a, Overlay(c1, c2)), mul((1.0f - a), c1));
        break;
    case 4:
        return add(mul(a, Darken(c1, c2)), mul((1.0f - a), c1));
        break;
    case 5:
        return add(mul(a, Lighten(c1, c2)), mul((1.0f - a), c1));
        break;
    default:
        break;
    }
}

void MyWindow::UpdateImage(){
    for(int x = 0; x < szer; x++)
        for(int y = 0; y < wys; y++){
            float xw = (float) x / (float)szer;
            float yh = (float) y / (float) wys;
            DrawPixel(img, x, y,
                      Blend(GetInterpolatedColor(loaded_img1, xw, yh),
                            GetInterpolatedColor(loaded_img2, xw, yh), alpha, mode));
        }

    update();
}

QColor MyWindow::GetPixel(QImage* img, int x, int y){
    QColor res;
    int width = img->width();
    int height = img->height();
    if(x >= width || y >= height || x < 0 || y < 0)
        return res;

    unsigned char* ptr = img->bits();

    res.setBlue(ptr[width*4*y + 4*x]);
    res.setGreen(ptr[width*4*y + 4*x + 1]);
    res.setRed(ptr[width*4*y + 4*x + 2]);
    res.setAlpha(ptr[width*4*y + 4*x + 3]);

    return res;
}


QColor MyWindow::GetInterpolatedColor(QImage* img, float x, float y){
    float width = img->width();
    float height = img->height();
    float xw = (x * width);
    float yw = (y * height);
    int x_f = (int) (x * width);
    int y_f = (int) (y * height);
    int x_c = ceil(x * width);
    int y_c = ceil(y * height);
    float a = (xw - (float) x_f);
    float b = ((yw) - (float) y_f);

    QColor P1 = GetPixel(img, x_f, y_c);
    QColor P2 = GetPixel(img, x_c, y_c);
    QColor P3 = GetPixel(img, x_c, y_f);
    QColor P4 = GetPixel(img, x_f, y_f);

    QColor v1 = mul(1.0f - a, P1);
    QColor v2 = mul(a, P2);
    QColor v3 = mul(a, P3);
    QColor v4 = mul(1.0f - a, P4);
    QColor top = add(v1, v2);
    QColor bottom = add(v3, v4);
    QColor btop = mul(b, top);
    QColor bbottom = mul(1.0f - b, bottom);
    QColor res = add(btop, bbottom);

    return res;
}

// Funkcja "odmalowujaca" komponent
void MyWindow::paintEvent(QPaintEvent*)
{
    // Obiekt klasy QPainter pozwala nam rysowac na komponentach
    QPainter p(this);


    UpdateImage();
    // Rysuje obrazek "img" w punkcie (poczX,poczY)
    // (tu bedzie lewy gorny naroznik)
    p.drawImage(poczX,poczY,*img);
}


void MyWindow::DrawPixel(QImage* img, int x, int y, QColor color){
    if(x >= szer || y >= wys || x < 0 || y < 0)
        return;

    unsigned char* ptr = img->bits();

    ptr[szer*4*y + 4*x] = color.blue();
    ptr[szer*4*y + 4*x + 1] = color.green();
    ptr[szer*4*y + 4*x + 2] = color.red();
    ptr[szer*4*y + 4*x + 3] = color.alpha();
}


void MyWindow::ClearImage(QImage *img){
    unsigned char* empty_val = (unsigned char*)malloc(4);
    empty_val[0] = 0;
    empty_val[1] = 0;
    empty_val[2] = 0;
    empty_val[3] = 255;
    unsigned char* ptr = img->bits();
    for(int i = 0; i < img->width(); i++){
        for(int j = 0; j < img->height(); j++){
            memcpy(ptr + 4 * (i + j * img->width()), empty_val, 4);
        }
    }
}