#pragma once

#include "memory.h"
#include "window.h"
#include "event.h"
#include "log.h"
#include "camera.h"

#include "rendering/rhi.h"
#include "rendering/scene_renderer.h"
#include "rendering/black_hole_renderer.h"

#include <string>
#include <vector>

namespace Donut
{
    // The application owns ONE RHI::Device (OpenGL or Vulkan, chosen at startup)
    // and the two portable renderers written on top of it, plus all the shared
    // state (cameras, scene objects, disk parameters, HDRI). Because the rendering
    // lives in the RHI and the shared renderers, the app behaves identically no
    // matter which backend is active.
    class Application
    {
    public:
        Application(const std::string& name = "Donut",
                    int width = 1280, int height = 720);
        ~Application();

        auto run() -> void;
        auto close() -> void;

        auto get_window() -> Window&      { return *m_window;   }
        static auto get() -> Application&  { return *s_instance; }

    private:
        auto on_init() -> void;
        auto on_shutdown() -> void;
        auto on_event(Event& event) -> void;

        auto build_ui() -> void;         // shared ImGui panel
        auto build_scene_ui() -> void;   // scene-view (object list) section

        auto process_input() -> void;    // orbit / free-fly / zoom, was per-backend
        auto set_free_fly(bool enabled) -> void;
        auto reset_camera() -> void;
        auto set_hdri(const std::string& path) -> void;

        auto render_frame() -> void;

    private:
        Scope<Window> m_window;

        // The unified renderer: one device + the shared renderers on top of it.
        Scope<RHI::Device>        m_device;
        Scope<SceneRenderer>      m_scene_renderer;
        Scope<BlackHoleRenderer>  m_black_hole_renderer;
        Ref<RHI::Texture>         m_cubemap;          // shared HDRI environment

        Camera m_camera{ 60.0f, 16.0f / 9.0f, 0.1f, 100.0f };        // black-hole view
        Camera m_scene_camera{ 45.0f, 16.0f / 9.0f, 0.1f, 1000.0f }; // world-builder view

        BlackHoleParams m_bh_params;
        std::vector<SceneObject> m_scene_objects{ SceneObject{} };
        int  m_selected_object = 0;
        bool m_scene_mode = false;
        std::string m_hdri_path;

        // input tracking (mirrors the old per-backend process_input)
        bool   m_left_was_down = false;
        double m_fps_last_x = 0.0, m_fps_last_y = 0.0;
        double m_last_frame_time = 0.0;
        double m_start_time = 0.0;
        bool   m_user_moving = false;

        bool m_running;
        bool m_minimized;

        static Application* s_instance;
    };
}