//
//  GraphicsEngine.h
//
//  Created by Sam Gateau on 29/6/2018.
//  Copyright 2018 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_GraphicsEngine_h
#define hifi_GraphicsEngine_h

#include <gl/OffscreenGLCanvas.h>
#ifdef USE_GL
#include <gl/GLWidget.h>
#else
#include <vk/VKWidget.h>
#endif
#include <qmutex.h>

#include <render/Engine.h>
#include <procedural/ProceduralSkybox.h>

#include <OctreeConstants.h>
#include <shared/RateCounter.h>

#include "FrameTimingsScriptingInterface.h"

/**
 * Contains current frame configuration for the renderer. Instance of `RenderArgs` is stored in `GraphicsEngine` and edited using
 * `GraphicsEngine::editRenderArgs` but the application on the main thread.
 */
struct AppRenderArgs {
    render::Args _renderArgs;
    glm::mat4 _eyeToWorld;
    glm::mat4 _view;
    glm::mat4 _eyeOffsets[2];
    glm::mat4 _eyeProjections[2];
    glm::mat4 _headPose;
    glm::mat4 _sensorToWorld;
    float _sensorToWorldScale{ 1.0f };
    bool _isStereo{ false };
};

using RenderArgsEditor = std::function <void(AppRenderArgs&)>;

/**
 * Main class for the graphics engine.
 */
class GraphicsEngine {
public:
    GraphicsEngine();
    ~GraphicsEngine();

#ifdef USE_GL
    /**
     * Creates render event handler, rendering backend and context.
     * Initializes compiling the basic set of shaders if needed.
     *
     * @param primaryWidget Widget containing 3D view on the main window.
     */
    void initializeGPU(GLWidget*  primaryWidget);
#else
    /**
     * Creates render event handler, rendering backend and context.
     * Initializes compiling the basic set of shaders if needed.
     *
     * @param primaryWidget Widget containing 3D view on the main window.
     */
    void initializeGPU(VKWidget*  primaryWidget);
#endif

    /**
     * Adds renderer jobs, loads renderer configuration from a json file and initializes shape pipelines.
     */
    void initializeRender();

    /**
     * Tells render thread to start operation.
     */
    void startup();

    /**
     * Flushes and processes all transactions, shutdown the gpu::Context and the render engine.
     * Schedules render event handler for deletion.
     * Called on main thread from the Application destructor.
     */
    void shutdown();

    /**
     * @return Shared pointer to the render::Scene.
     */
    render::ScenePointer getRenderScene() const { return _renderScene; }

    /**
     * @return Shared pointer to the RenderEngine.
     */
    render::EnginePointer getRenderEngine() const { return _renderEngine; }

    /**
     * @return Shared pointer to the gpu::Context.
     */
    gpu::ContextPointer getGPUContext() const { return _gpuContext; }

    /**
     * Same as the one in application.
     * Used by render event handler.
     * Can return false during shutdown, and when framerate is throttled.
     * There's a setting to throttle framerate when out of focus which uses this function.
     * @return `true` if application should render frame, `false` if not.
     */
    bool shouldPaint() const;

    /**
     * Used by `Application::onPresent` to check if a new Frame object creation event can be posted.
     * Internally it changes state of `_pendingRenderingEvent` atomic_bool.
     *
     * @return `true` if previous Frame object creation event has finished and new one can be posted.
     */
    bool checkPendingRenderEvent();

    /**
     * @return Number of Frame objects generated this far. Does not have to be equal to number of frames actually rendered.
     */
    size_t getRenderFrameCount() const { return _renderFrameCount; }

    /**
     * @return Framerate of the "Render" loop. Render loop does not actually render, it only generates frames to be rendered on a separate thread.
     */
    float getRenderLoopRate() const { return _renderLoopCounter.rate(); }

    /**
     * Give Graphics Engine new frame configuration.
     * @param editor
     */
    void editRenderArgs(RenderArgsEditor editor);

private:
    // Thread specific calls
    /**
     * Creates a new frame object with all rendering operations and submits it to the display plugin.
     * Does not actually render frame.
     */
    void render_performFrame();

    /**
     * Called by `render_performFrame`. Generates `Frame` object to be rendered later on the Present thread.
     * @param renderArgs Configuration for this frame.
     */
    void render_runRenderFrame(RenderArgs* renderArgs);

protected:
    /**
     * Mutex used to protect frame configuration.
     */
    mutable QRecursiveMutex _renderArgsMutex;

    /**
     * Frame configuration. Updated from the main thread and used by the "Render" thread, which generates `Frame` objects but
     * does not render them.
     */
    AppRenderArgs _appRenderArgs;

    /**
     * Used for measuring rate at which frame objects are generated.
     */
    RateCounter<500> _renderLoopCounter;

    /**
     * Counts number of frame objects that were created.
     */
    uint32_t _renderFrameCount{ 0 };

    /**
     * DOCTODO
     */
    render::ScenePointer _renderScene{ new render::Scene(glm::vec3(-0.5f * (float)TREE_SCALE), (float)TREE_SCALE) };

    /**
     * `RenderEngine` object contains all the tasks needed to generate a Frame object that can later be submitted to
     * display plugin to be rendered.
     */
    render::EnginePointer _renderEngine{ new render::RenderEngine() };

    /**
     * Object that manages rendering backend and GPU statistics.
     */
    gpu::ContextPointer _gpuContext; // initialized during window creation

    /**
     * `RenderEventHandler` responsible for creating Frame objects and submitting them to display plugin, where later
     * they get rendered on Present thread.
     */
    QObject* _renderEventHandler{ nullptr };

    friend class RenderEventHandler;

    /**
     * Used for "FrameTimings" scripting API.
     */
    FrameTimingsScriptingInterface _frameTimingsScriptingInterface;

    /**
     * A simple skybox shown before the shaders are compiled.
     */
    std::shared_ptr<ProceduralSkybox> _splashScreen { std::make_shared<ProceduralSkybox>() };

    /**
     * Splash screen texture. Shown as a skybox before the shaders load and compile.
     */
    NetworkTexturePointer _texture;
#ifndef Q_OS_ANDROID
    /**
     * Changes to true when the shaders are loaded and compiled.
     * Used to show the splash screen skybox.
     */
    std::atomic<bool> _programsCompiled { false };
#else
    std::atomic<bool> _programsCompiled { true };
#endif

    friend class Application;
};

#endif // hifi_GraphicsEngine_h