#include <iostream>
#include <cmath>
#include <SFML/Graphics.hpp>

struct point {

    double x, y;

    point(double _x = 0, double _y = 0) {
        this->x = _x;
        this->y = _y;
    }

};

struct pixel {

    double x, y;

    pixel(double _x = 0, double _y = 0) {
        this->x = _x;
        this->y = _y;
    }

};

struct complex {

    double Re, Im;

    complex(double _Re = 0, double _Im = 0) {
        this->Re = _Re;
        this->Im = _Im;
    }

    friend complex operator-(const complex &a) {
        return {-a.Re, -a.Im};
    }

    friend complex operator+(const complex &a, const complex &b) {
        return {a.Re + b.Re, a.Im + b.Im};
    }

    friend complex operator-(const complex &a, const complex &b) {
        return a + (-b);
    }

    friend double dot_product(const complex &a, const complex &b) {
        return a.Re * b.Re + a.Im * b.Im;
    }

    friend double cross_product(const complex &a, const complex &b) {
        return a.Re * b.Im - a.Im * b.Re;
    }

    friend complex operator*(const complex &a, const complex &b) {
        return {a.Re * b.Re - a.Im * b.Im, a.Re * b.Im + a.Im * b.Re};
    }

    complex pow(int n) {
        complex ans = {1, 0}, step = {Re, Im};
        while (n > 0) {
            if (n % 2 == 1) {
                ans = ans * step;
            }
            ans = ans * ans;
            n /= 2;
        }
        return ans;
    }

    double abs() {
        return sqrt(Re * Re + Im * Im);
    }

};

const int W = 1080, H = 720, MAX_ITERS = 200;
double scale = 200;
pixel centre{W / 2, H / 2};
sf::Uint8* pixels = new sf::Uint8[W * H * 4];

point pixel_to_point(const pixel &a) {
    return {(a.x - centre.x) / scale, (centre.y - a.y) / scale};
}

void make_fractal(complex c) {
    for (int i = 0; i < W; ++i) {
        for (int j = 0; j < H; ++j) {
            point p = pixel_to_point({double(i), double(j)});
            complex z = {p.x, p.y};
            int it;
            double r = 5;
            for (it = 0; it < MAX_ITERS; ++it) {
                if (z.abs() >= r) {
                    break;
                }
                z = z.pow(2) + c;
            }
            double len = z.abs();
            int id = 4 * (j * W + i);
            if (it == MAX_ITERS) {
                pixels[id] = pixels[id + 1] = pixels[id + 2] = 0;
                pixels[id + 3] = 255;
            }
            else {
                pixels[id] = 10 * sin(len + 2.0) + 150;
                pixels[id + 1] = 15 * sin(len + 1.0) + 200;
                pixels[id + 2] = 20 * sin(len + 1.5) + 100;
                pixels[id + 3] = 255;
            }
        }
    }
}

int main() {

    sf::RenderWindow window(sf::VideoMode(W, H), "SFML works!");

    sf::Texture texture;
    texture.create(W, H);
    sf::Sprite sprite(texture);

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
            /*else if (event.type == sf::Event::MouseButtonPressed) {
                pressed = true;
                mouse_pos = {event.mouseButton.x, event.mouseButton.y};
            }
            else if (event.type == sf::Event::MouseButtonReleased) {
                pressed = false;
                pixel current = {event.mouseButton.x, event.mouseButton.y};

            }*/
        }
        make_fractal({0.377, -0.248});
        texture.update(pixels);
        window.clear();
        window.draw(sprite);
        window.display();
    }

    return 0;
}