#include <iostream>
#include <SDL2/SDL.h>
#include <vector>

using namespace std;
SDL_Color color = {.r = 255, .g = 255, .b = 255};
const int WIDTH = 800, HEIGHT = 600;

void addPointToShape(std::vector<SDL_Point>& shape, int x, int y) {
    SDL_Point point;
    point.x = x;
    point.y = y;
    shape.push_back(point);
}


bool isPointInPolygon(int x, int y, const std::vector<SDL_Point> &points)
{
    int crossings = 0;
    int numPoints = points.size();

    for (int i = 0; i < numPoints; i++)
    {
        int x1 = points[i].x;
        int y1 = points[i].y;
        int x2 = points[(i + 1) % numPoints].x;
        int y2 = points[(i + 1) % numPoints].y;

        if (((y1 <= y && y < y2) || (y2 <= y && y < y1)) &&
            x + (y - y1) / (y2 - y1) * (x2 - x1) < x1)
        {
            crossings++;
        }
    }

    return (crossings % 2 != 0);
}

void fillShapeWithColor(SDL_Renderer *renderer, const std::vector<SDL_Point> &shape, const SDL_Color &color)
{
    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);

    // Determine the bounding box
    int minX = INT_MAX, minY = INT_MAX, maxX = INT_MIN, maxY = INT_MIN;

    for (size_t i = 0; i < shape.size(); i++)
    {
        const SDL_Point &point = shape[i];
        // Use point.x and point.y as needed
        if (point.x < minX)
            minX = point.x;
        if (point.x > maxX)
            maxX = point.x;
        if (point.y < minY)
            minY = point.y;
        if (point.y > maxY)
            maxY = point.y;
    }

    // Fill the area inside the shape
    for (int x = minX; x <= maxX; x++)
    {
        for (int y = minY; y <= maxY; y++)
        {
            if (isPointInPolygon(x, y, shape))
            {
                SDL_RenderDrawPoint(renderer, x, y);
            }
        }
    }
}

void DrawFilledCircle(SDL_Renderer *renderer, int x, int y, int radius, SDL_Color color)
{
    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
    for (int w = 0; w < radius * 2; w++)
    {
        for (int h = 0; h < radius * 2; h++)
        {
            int dx = radius - w; // horizontal offset
            int dy = radius - h; // vertical offset
            if ((dx * dx + dy * dy) <= (radius * radius))
            {
                SDL_RenderDrawPoint(renderer, x + dx, y + dy);
            }
        }
    }
}

void DrawHalfCircle(SDL_Renderer *renderer, int centreX, int centreY, int radius, int a = 0, int minx = 0, int miny = 0)
{
    const int diameter = (radius * 2);

    int x = (radius - 1);
    int y = 0;
    int tx = 1;
    int ty = 1;
    int error = (tx - diameter);

    while (x >= y)
    {
        //  Each of the following renders an octant of the circle
        //   SDL_RenderDrawPoint(renderer, centreX + x, centreY - y);
        SDL_RenderDrawPoint(renderer, centreX + x, centreY + y);
        //   SDL_RenderDrawPoint(renderer, centreX - x, centreY - y);
        if (a == 0)
        {
            SDL_RenderDrawPoint(renderer, centreX - x, centreY + y);
        }
        else if (a == 1)
        {
            if (centreX - x > minx && centreY + y > miny)
            {
                SDL_RenderDrawPoint(renderer, centreX - x, centreY + y);
            }
        }

        //   SDL_RenderDrawPoint(renderer, centreX + y, centreY - x);
        SDL_RenderDrawPoint(renderer, centreX + y, centreY + x);
        //   SDL_RenderDrawPoint(renderer, centreX - y, centreY - x);
        SDL_RenderDrawPoint(renderer, centreX - y, centreY + x);

        if (error <= 0)
        {
            ++y;
            error += ty;
            ty += 2;
        }

        if (error > 0)
        {
            --x;
            tx += 2;
            error += (tx - diameter);
        }
    }
}

int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_EVERYTHING);
    SDL_Window *window = SDL_CreateWindow("Hello SDL World", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIDTH, HEIGHT, SDL_WINDOW_ALLOW_HIGHDPI);
    SDL_Renderer *renderer = SDL_CreateRenderer(window, 1, SDL_RENDERER_ACCELERATED);
    if (NULL == window)
    {
        cout << "could not create window: " << SDL_GetError() << endl;
        return 1;
    }
    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);

    SDL_RenderDrawLine(renderer, 350, 190, 730, 190);
    SDL_RenderDrawLine(renderer, 730, 190, 780, 130);
    SDL_RenderDrawLine(renderer, 780, 130, 830, 190);
    SDL_RenderDrawLine(renderer, 830, 190, 980, 190);

    SDL_RenderDrawLine(renderer, 980, 190, 1030, 130);
    SDL_RenderDrawLine(renderer, 1030, 130, 1085, 200);
    SDL_RenderDrawLine(renderer, 1085, 200, 1100, 226);
    SDL_RenderDrawLine(renderer, 1100, 226, 1109, 240);
    SDL_RenderDrawLine(renderer, 1109, 240, 1120, 271);
    SDL_RenderDrawLine(renderer, 1120, 271, 1136, 320);
    SDL_RenderDrawLine(renderer, 1136, 320, 1147, 360);
    SDL_RenderDrawLine(renderer, 1147, 360, 1155, 400);
    SDL_RenderDrawLine(renderer, 1155, 400, 1160, 440);
    SDL_RenderDrawLine(renderer, 1160, 440, 1165, 480);
    SDL_RenderDrawLine(renderer, 1165, 480, 1165, 560);
    SDL_RenderDrawLine(renderer, 1165, 560, 1159, 600);
    SDL_RenderDrawLine(renderer, 1159, 600, 1154, 620);
    SDL_RenderDrawLine(renderer, 1154, 620, 1148, 640);
    SDL_RenderDrawLine(renderer, 1148, 640, 1140, 660);
    SDL_RenderDrawLine(renderer, 1140, 660, 1120, 700);
    SDL_RenderDrawLine(renderer, 1120, 700, 1100, 730);
    SDL_RenderDrawLine(renderer, 1100, 730, 1080, 756);
    SDL_RenderDrawLine(renderer, 1080, 756, 1054, 782);
    DrawHalfCircle(renderer, 1030, 780, 25);
    SDL_RenderDrawLine(renderer, 1005, 780, 810, 780);
    DrawHalfCircle(renderer, 785, 780, 25);
    SDL_RenderDrawLine(renderer, 760, 780, 510, 780);
    DrawHalfCircle(renderer, 485, 780, 25);
    SDL_RenderDrawLine(renderer, 460, 780, 265, 780);
    DrawHalfCircle(renderer, 240, 780, 25);
    SDL_RenderDrawLine(renderer, 215, 780, 180, 730);
    SDL_RenderDrawLine(renderer, 180, 730, 160, 695);
    SDL_RenderDrawLine(renderer, 160, 695, 145, 660);
    SDL_RenderDrawLine(renderer, 145, 660, 135, 635);
    SDL_RenderDrawLine(renderer, 135, 635, 125, 600);
    SDL_RenderDrawLine(renderer, 125, 600, 115, 540);
    SDL_RenderDrawLine(renderer, 115, 540, 115, 470);
    SDL_RenderDrawLine(renderer, 115, 470, 115, 435);
    SDL_RenderDrawLine(renderer, 115, 435, 120, 415);
    SDL_RenderDrawLine(renderer, 120, 415, 130, 387);
    SDL_RenderDrawLine(renderer, 130, 387, 140, 360);
    SDL_RenderDrawLine(renderer, 140, 360, 150, 337);
    SDL_RenderDrawLine(renderer, 150, 337, 170, 305);
    SDL_RenderDrawLine(renderer, 170, 305, 200, 273);
    SDL_RenderDrawLine(renderer, 200, 273, 240, 240);
    SDL_RenderDrawLine(renderer, 240, 240, 305, 205);
    SDL_RenderDrawLine(renderer, 305, 205, 330, 195);
    SDL_RenderDrawLine(renderer, 330, 195, 350, 190);

    SDL_RenderDrawLine(renderer, 116, 434, 105, 430);
    SDL_RenderDrawLine(renderer, 105, 430, 86, 419);
    SDL_RenderDrawLine(renderer, 86, 419, 70, 409);
    SDL_RenderDrawLine(renderer, 70, 409, 55, 397);
    SDL_RenderDrawLine(renderer, 55, 397, 50, 392);
    SDL_RenderDrawLine(renderer, 50, 392, 32, 377);
    SDL_RenderDrawLine(renderer, 32, 377, 22, 363);
    SDL_RenderDrawLine(renderer, 22, 363, 16, 352);
    SDL_RenderDrawLine(renderer, 16, 352, 13, 344);
    SDL_RenderDrawLine(renderer, 13, 344, 13, 333);
    SDL_RenderDrawLine(renderer, 13, 333, 16, 327);
    SDL_RenderDrawLine(renderer, 16, 327, 19, 323);
    SDL_RenderDrawLine(renderer, 19, 323, 24, 318);
    SDL_RenderDrawLine(renderer, 24, 318, 33, 314);
    SDL_RenderDrawLine(renderer, 33, 314, 43, 312);
    SDL_RenderDrawLine(renderer, 43, 312, 68, 311);
    SDL_RenderDrawLine(renderer, 68, 312, 86, 315);
    SDL_RenderDrawLine(renderer, 86, 315, 109, 320);
    SDL_RenderDrawLine(renderer, 109, 320, 127, 327);
    SDL_RenderDrawLine(renderer, 127, 327, 150, 337);

    SDL_RenderDrawLine(renderer, 900, 280, 900, 313);
    SDL_RenderDrawLine(renderer, 900, 313, 904, 316);
    SDL_RenderDrawLine(renderer, 904, 316, 909, 320);
    SDL_RenderDrawLine(renderer, 909, 320, 914, 321);
    SDL_RenderDrawLine(renderer, 914, 321, 933, 321);
    SDL_RenderDrawLine(renderer, 900, 313, 895, 316);
    SDL_RenderDrawLine(renderer, 895, 316, 890, 320);
    SDL_RenderDrawLine(renderer, 890, 320, 885, 321);
    SDL_RenderDrawLine(renderer, 885, 321, 866, 321);

    DrawFilledCircle(renderer, 1009, 296, 21, color);
    DrawFilledCircle(renderer, 793, 296, 21, color);

    SDL_RenderDrawLine(renderer, 700, 273, 610, 257);
    SDL_RenderDrawLine(renderer, 700, 305, 611, 312);
    SDL_RenderDrawLine(renderer, 1120, 271, 1208, 257);
    SDL_RenderDrawLine(renderer, 1135, 312, 1217, 309);

    DrawHalfCircle(renderer, 850, 190, 15);
    DrawHalfCircle(renderer, 905, 190, 15);
    DrawHalfCircle(renderer, 960, 190, 15);

    DrawHalfCircle(renderer, 540, 190, 50);
    DrawHalfCircle(renderer, 360, 190, 50, 1, 303, 203);

    std::vector<SDL_Point> shape1;

    addPointToShape(shape1, 70, 410);
    addPointToShape(shape1, 70, 406);
    addPointToShape(shape1, 71, 403);
    addPointToShape(shape1, 72, 399);
    addPointToShape(shape1, 73, 394);
    addPointToShape(shape1, 74, 390);
    addPointToShape(shape1, 75, 384);
    addPointToShape(shape1, 76, 378);
    addPointToShape(shape1, 78, 373);
    addPointToShape(shape1, 80, 367);
    addPointToShape(shape1, 82, 362);
    addPointToShape(shape1, 84, 356);
    addPointToShape(shape1, 86, 352);
    addPointToShape(shape1, 87, 350); //
    addPointToShape(shape1, 90, 343);
    addPointToShape(shape1, 92, 338);
    addPointToShape(shape1, 95, 332);
    addPointToShape(shape1, 98, 327);
    addPointToShape(shape1, 101, 323);
    addPointToShape(shape1, 98, 320);
    addPointToShape(shape1, 95, 319);
    addPointToShape(shape1, 90, 318);
    addPointToShape(shape1, 87, 317);
    addPointToShape(shape1, 82, 316);
    addPointToShape(shape1, 78, 315);
    addPointToShape(shape1, 74, 315);
    addPointToShape(shape1, 70, 314);
    addPointToShape(shape1, 66, 320);
    addPointToShape(shape1, 65, 323);
    addPointToShape(shape1, 63, 328);
    addPointToShape(shape1, 61, 332);
    addPointToShape(shape1, 59, 337);
    addPointToShape(shape1, 57, 342);
    addPointToShape(shape1, 57, 343);
    addPointToShape(shape1, 55, 348);
    addPointToShape(shape1, 53, 353);
    addPointToShape(shape1, 51, 357);
    addPointToShape(shape1, 50, 362);
    addPointToShape(shape1, 48, 366);
    addPointToShape(shape1, 47, 371);
    addPointToShape(shape1, 46, 374);
    addPointToShape(shape1, 45, 379);
    addPointToShape(shape1, 44, 385);
    addPointToShape(shape1, 43, 388);
    addPointToShape(shape1, 46, 393);
    addPointToShape(shape1, 50, 396);
    addPointToShape(shape1, 53, 399);
    addPointToShape(shape1, 57, 401);
    addPointToShape(shape1, 61, 403);
    addPointToShape(shape1, 64, 406);
    addPointToShape(shape1, 70, 409);

    shape1.push_back(shape1[0]);

    SDL_Color fillColor = {255, 255, 255, 255}; // Red fill color

    fillShapeWithColor(renderer, shape1, fillColor);


        std::vector<SDL_Point> shape2;

    addPointToShape(shape2, 116, 434);
    addPointToShape(shape2, 117, 431);
    addPointToShape(shape2, 117, 429);
    addPointToShape(shape2, 118, 426);
    addPointToShape(shape2, 118, 422);
    addPointToShape(shape2, 120, 416);
    addPointToShape(shape2, 121, 413);
    addPointToShape(shape2, 122, 408);
    addPointToShape(shape2, 123, 403);
    addPointToShape(shape2, 124, 399);
    addPointToShape(shape2, 126, 393);
    addPointToShape(shape2, 127, 389);
    addPointToShape(shape2, 129, 385);
    addPointToShape(shape2, 131, 379);
    addPointToShape(shape2, 133, 375);
    addPointToShape(shape2, 134, 370);
    addPointToShape(shape2, 136, 367);
    addPointToShape(shape2, 137, 364);
    addPointToShape(shape2, 139, 360);
    addPointToShape(shape2, 140, 357);
    addPointToShape(shape2, 142, 353);
    addPointToShape(shape2, 144, 349);
    addPointToShape(shape2, 145, 346);
    addPointToShape(shape2, 147, 342);
    addPointToShape(shape2, 150, 339);
    addPointToShape(shape2, 148, 338);
    addPointToShape(shape2, 146, 337);
    addPointToShape(shape2, 144, 336);
    addPointToShape(shape2, 142, 335);
    addPointToShape(shape2, 140, 334);
    addPointToShape(shape2, 138, 333);
    addPointToShape(shape2, 136, 332);
    addPointToShape(shape2, 134, 331);
    addPointToShape(shape2, 132, 330);
    addPointToShape(shape2, 129, 329);
    addPointToShape(shape2, 127, 332);
    addPointToShape(shape2, 125, 334);
    addPointToShape(shape2, 124, 336);
    addPointToShape(shape2, 123, 339);
    addPointToShape(shape2, 121, 343);
    addPointToShape(shape2, 120, 345);
    addPointToShape(shape2, 119, 347);
    addPointToShape(shape2, 117, 350);
    addPointToShape(shape2, 116, 353);
    addPointToShape(shape2, 115, 356);
    addPointToShape(shape2, 113, 359);
    addPointToShape(shape2, 112, 363);
    addPointToShape(shape2, 110, 365);
    addPointToShape(shape2, 110, 369);
    addPointToShape(shape2, 108, 372);
    addPointToShape(shape2, 107, 375);
    addPointToShape(shape2, 105, 379);
    addPointToShape(shape2, 104, 382);
    addPointToShape(shape2, 103, 386);
    addPointToShape(shape2, 102, 390);
    addPointToShape(shape2, 101, 394);
    addPointToShape(shape2, 100, 397);
    addPointToShape(shape2, 99, 400);
    addPointToShape(shape2, 98, 404);
    addPointToShape(shape2, 97, 407);
    addPointToShape(shape2, 96, 411);
    addPointToShape(shape2, 95, 416);
    addPointToShape(shape2, 95, 419);
    addPointToShape(shape2, 94, 423);
    addPointToShape(shape2, 94, 425);
    addPointToShape(shape2, 96, 426);
    addPointToShape(shape2, 98, 427);
    addPointToShape(shape2, 101, 428);
    addPointToShape(shape2, 104, 429);
    addPointToShape(shape2, 107, 431);
    addPointToShape(shape2, 110, 432);
    addPointToShape(shape2, 113, 434);
    addPointToShape(shape2, 116, 435);

    shape2.push_back(shape2[0]);

    fillShapeWithColor(renderer, shape2, fillColor);
   

    SDL_RenderPresent(renderer);

    SDL_Event windowEvent;
    while (true)
    {
        if (SDL_PollEvent(&windowEvent))
        {
            if (SDL_QUIT == windowEvent.type)
            {
                break;
            }
        }
    }
    SDL_DestroyWindow(window);
    SDL_Quit();
    return EXIT_SUCCESS;
}