#if WINDOW == 2

#ifndef WINDOW_SDL3
#define WINDOW_SDL3

#include "pch.hpp"

#include "utils/Window/Window.h"

#include <SDL3/SDL.h>

#if RENDERER == 2

#include <SDL3/SDL_opengl.h>

#endif

namespace Archimedes {

    static bool EventCallback(void* ptr, SDL_Event* e) {

        WindowData& data = *(WindowData*) ptr;

        switch(e->type) {

            case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
            case SDL_EVENT_QUIT:
                data.sendEvent(new CloseWindowEvent(data.window, e));
                break;
            case SDL_EVENT_WINDOW_RESIZED:
                data.sendEvent(new ResizeWindowEvent(e->window.data1, e->window.data2, e));
                break;
            case SDL_EVENT_WINDOW_MOUSE_ENTER:
            case SDL_EVENT_WINDOW_FOCUS_GAINED:
                data.sendEvent(new FocusedWindowEvent(data.window, e));
                break;
            case SDL_EVENT_WINDOW_MOUSE_LEAVE:
            case SDL_EVENT_WINDOW_FOCUS_LOST:
                data.sendEvent(new FocusLostWindowEvent(data.window, e));
                break;
            case SDL_EVENT_KEY_DOWN:
                data.sendEvent(new KeyPressedWindowEvent(e->key.key, e->key.repeat ? 1 : 0, e));
                break;
            case SDL_EVENT_KEY_UP:
                data.sendEvent(new KeyReleasedWindowEvent(e->key.key, e));
                break;
            case SDL_EVENT_MOUSE_MOTION:
                data.sendEvent(new MouseMovedWindowEvent(e->motion.x, e->motion.y, e));
                break;
            case SDL_EVENT_MOUSE_BUTTON_DOWN:
                data.sendEvent(new MouseButtonPressedWindowEvent(e->button.button, e));
                break;
            case SDL_EVENT_MOUSE_BUTTON_UP:
                data.sendEvent(new MouseButtonReleasedWindowEvent(e->button.button, e));
                break;
            case SDL_EVENT_MOUSE_WHEEL:
                data.sendEvent(new ScrollWindowEvent(e->wheel.x, e->wheel.y, e));
                break;
            default:
                data.sendEvent(new AnonymousEvent(e));
                break;
        }

        return true;
    }

    class WindowSDL3 : public Window {

        public:

            WindowSDL3(const std::function<void(Event*)>& sendEvent) : Window(sendEvent) {

                data.window = this;
                data.sendEvent = sendEvent;

                if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
                    std::cerr << "Error: SDL_Init(): " << SDL_GetError() << std::flush;
                    std::abort();
                }

#if RENDERER == 1
                SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
                SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
                SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

                SDL_WindowFlags window_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN;
#elif RENDERER == 2
                SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
#endif

                window = SDL_CreateWindow("Archimedes", 1280, 720, window_flags);
                if (window == nullptr)
                {
                    std::cerr << "Error: SDL_CreateWindow(): " << SDL_GetError() << std::endl;
                    std::abort();
                }
                SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
 
#if RENDERER == 1
                gl_context = SDL_GL_CreateContext(window);

                if (gl_context == nullptr)
                {
                    std::cerr << "Error: SDL_GL_CreateContext(): " << SDL_GetError() << std::endl;
                    std::abort();
                }

                SDL_GL_MakeCurrent(window, gl_context);
                SDL_GL_SetSwapInterval(1); // Enable vsync
#endif               
                SDL_AddEventWatch(EventCallback, &data);

                SDL_ShowWindow(window);
            }

            ~WindowSDL3() {
#if RENDERER == 1
                SDL_GL_DestroyContext(gl_context);
#endif
                SDL_RemoveEventWatch(EventCallback, &data);
                SDL_DestroyWindow(window);
                SDL_Quit();
            }

            bool shouldClose() override { return false; }

            void swapBuffers() override { 
#if RENDERER == 1
                restoreContext();
                SDL_GL_SwapWindow(window);
#endif
            }

            void pollEvents() override {
                static SDL_Event e;
                while(SDL_PollEvent(&e));
            }
            
            WindowSDL3* getWindowImpl() { return this; };

#if RENDERER == 1
            void restoreContext() { SDL_GL_MakeCurrent(window, gl_context); }
#endif
            void getSize(int& w, int& h) override {
                w = this->w;
                h = this->h;
            }

            void setSize(int& w, int& h) {
                this->w = w;
                this->h = h;
            }

            SDL_Window* getWindow() { return window; }
#if RENDERER == 1
            SDL_GLContext getContext() { return gl_context; }
#endif
            WindowData data;
        
        private:
            SDL_Window* window;
#if RENDERER == 1
            SDL_GLContext gl_context;
#endif

    };
}

#endif

#endif