/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
 *
 * SPDX-License-Identifier: Apache-2.0 */

#pragma once

#include "bvh/params.h"

#include "scene/devicescene.h"
#include "scene/film.h"
#include "scene/image.h"
#include "scene/scene_attributes.h"
#include "scene/shader.h"

#include "util/param.h"
#include "util/string.h"
#include "util/thread.h"
#include "util/unique_ptr.h"
#include "util/unique_ptr_vector.h"

CCL_NAMESPACE_BEGIN

class AttributeRequestSet;
class Background;
class BVH;
class Camera;
class Device;
class DeviceInfo;
class Film;
class Integrator;
class SceneAttributes;
class PointLight;
class SpotLight;
class AreaLight;
class SunLight;
class BackgroundLight;
class Light;
class LightManager;
class LookupTables;
class Geometry;
class GeometryManager;
class Object;
class ObjectManager;
class OSLManager;
class ParticleSystemManager;
class ParticleSystem;
class PointCloud;
class Procedural;
class ProceduralManager;
class CurveSystemManager;
class Shader;
class ShaderManager;
class Progress;
class BakeManager;
class BakeData;
class RenderStats;
class SceneUpdateStats;
class Volume;
class VolumeManager;

/* Scene Parameters */

class SceneParams {
 public:
  ShadingSystem shadingsystem;

  /* Requested BVH layout.
   *
   * If it's not supported by the device, the widest one from supported ones
   * will be used, but BVH wider than this one will never be used.
   */
  BVHLayout bvh_layout;

  BVHType bvh_type;
  bool use_bvh_spatial_split;
  bool use_bvh_compact_structure;
  bool use_bvh_unaligned_nodes;
  int num_bvh_time_steps;
  int hair_subdivisions;
  CurveShapeType hair_shape;
  float texture_resolution;
  int texture_limit;

  /* Use tx files if they exist. */
  bool use_texture_cache = true;
  /* Auto generate tx files. */
  bool auto_texture_cache = false;
  /* Relative (to the image file) or absolute directory for auto generating tx files. */
  std::string texture_cache_path;

  bool background;

  SceneParams()
  {
    shadingsystem = SHADINGSYSTEM_SVM;
    bvh_layout = BVH_LAYOUT_AUTO;
    bvh_type = BVH_TYPE_DYNAMIC;
    use_bvh_spatial_split = false;
    use_bvh_compact_structure = true;
    use_bvh_unaligned_nodes = true;
    num_bvh_time_steps = 0;
    hair_subdivisions = 3;
    hair_shape = CURVE_RIBBON;
    texture_resolution = 1.0f;
    texture_limit = 0;
    background = true;
  }

  bool modified(const SceneParams &params) const
  {
    return !(
        shadingsystem == params.shadingsystem && bvh_layout == params.bvh_layout &&
        bvh_type == params.bvh_type && use_bvh_spatial_split == params.use_bvh_spatial_split &&
        use_bvh_compact_structure == params.use_bvh_compact_structure &&
        use_bvh_unaligned_nodes == params.use_bvh_unaligned_nodes &&
        num_bvh_time_steps == params.num_bvh_time_steps &&
        hair_subdivisions == params.hair_subdivisions && hair_shape == params.hair_shape &&
        texture_resolution == params.texture_resolution && texture_limit == params.texture_limit &&
        use_texture_cache == params.use_texture_cache &&
        auto_texture_cache == params.auto_texture_cache &&
        texture_cache_path == params.texture_cache_path);
  }

  int curve_subdivisions()
  {
    /* Matching the tessellation rate limit in Embree. */
    return clamp(1 << hair_subdivisions, 1, 16);
  }
};

/* Scene */

class Scene : public NodeOwner {
 public:
  /* Optional name. Is used for logging and reporting. */
  string name;

  /* Maps from Light group names to their pass ID. */
  map<ustring, int> lightgroups;

  /* data */
  unique_ptr<BVH> bvh;
  unique_ptr<LookupTables> lookup_tables;

  Camera *camera;
  Camera *dicing_camera;
  Film *film;
  Background *background;
  Integrator *integrator;
  SceneAttributes *scene_attribute;

  /* data lists */
  unique_ptr_vector<Background> backgrounds;
  unique_ptr_vector<Film> films;
  unique_ptr_vector<Integrator> integrators;
  unique_ptr_vector<SceneAttributes> scene_attributes;
  unique_ptr_vector<Camera> cameras;
  unique_ptr_vector<Shader> shaders;
  unique_ptr_vector<Pass> passes;
  unique_ptr_vector<ParticleSystem> particle_systems;
  unique_ptr_vector<Geometry> geometry;
  unique_ptr_vector<Object> objects;
  unique_ptr_vector<Procedural> procedurals;

  /* data managers */
  unique_ptr<ImageManager> image_manager;
  unique_ptr<LightManager> light_manager;
  unique_ptr<OSLManager> osl_manager;
  unique_ptr<ShaderManager> shader_manager;
  unique_ptr<GeometryManager> geometry_manager;
  unique_ptr<ObjectManager> object_manager;
  unique_ptr<ParticleSystemManager> particle_system_manager;
  unique_ptr<BakeManager> bake_manager;
  unique_ptr<ProceduralManager> procedural_manager;
  unique_ptr<VolumeManager> volume_manager;

  /* default shaders */
  Shader *default_surface;
  Shader *default_volume;
  Shader *default_light;
  Shader *default_background;
  Shader *default_empty;

  /* device */
  Device *device;
  DeviceScene dscene;

  /* parameters */
  SceneParams params;

  /* mutex must be locked manually by callers */
  thread_mutex mutex;
  bool scene_updated_while_loading_kernels = false;

  /* scene update statistics */
  unique_ptr<SceneUpdateStats> update_stats;

  Scene(const SceneParams &params, Device *device);
  ~Scene() override;

  void device_update(Device *device, Progress &progress);

  bool need_global_attribute(AttributeStandard std) const;
  void need_global_attributes(AttributeRequestSet &attributes);

  enum MotionType { MOTION_NONE = 0, MOTION_PASS, MOTION_BLUR, MOTION_PASS_INTERACTIVE };
  MotionType need_motion() const;
  float motion_shutter_time();

  bool need_update();
  bool need_reset(const bool check_camera = true);

  void reset();
  void device_free();

  void collect_statistics(RenderStats *stats);

  void enable_update_stats();

  bool update(Progress &progress);
  bool update_camera_resolution(Progress &progress, int width, int height);

  bool has_shadow_catcher();
  void tag_shadow_catcher_modified();
  bool has_volume();
  bool has_volume_modified() const;
  void tag_has_volume_modified();
  /* Check if we use multiple importance sampling for any light in the scene. */
  bool use_light_mis() const;

  /* This function is used to create a node of a specified type instead of
   * calling 'new', and sets the scene as the owner of the node.
   * The function has overloads that will also add the created node to the right
   * node array (e.g. Scene::geometry for Geometry nodes) and tag the appropriate
   * manager for an update.
   */
  template<typename T, typename... Args> T *create_node(Args &&.../*args*/) = delete;

  /* This function is used to delete a node from the scene instead of calling 'delete'
   * and manually removing the node from the data array. It also tags the
   * appropriate manager for an update, if any, and checks that the scene is indeed
   * the owner of the node. Calling this function on a node not owned by the scene
   * will likely cause a crash which we want in order to detect such cases.
   */
  template<typename T> void delete_node(T *node) = delete;

  /* Remove all nodes in the set from the appropriate data arrays, and tag the
   * specific managers for an update. This assumes that the scene owns the nodes.
   */
  template<typename T> void delete_nodes(const set<T *> &nodes)
  {
    delete_nodes(nodes, this);
  }

  /* Same as above, but specify the actual owner of all the nodes in the set.
   */
  template<typename T> void delete_nodes(const set<T *> &nodes, const NodeOwner *owner);

  template<class T> T *create_light_node();

 protected:
  /* Check if some heavy data worth logging was updated.
   * Mainly used to suppress extra annoying logging.
   */
  bool need_data_update();

  void free_memory(bool final);

  bool kernels_loaded;
  uint loaded_kernel_features;

  void update_kernel_features();

  bool has_shadow_catcher_ = false;
  bool shadow_catcher_modified_ = true;
  bool has_volume_modified_ = true;

  /* Maximum number of closure during session lifetime. */
  int max_closure_global;

  /* Get maximum number of closures to be used in kernel. */
  int get_max_closure_count();

  /* Get size of a volume stack needed to render this scene. */
  int get_volume_stack_size() const;

  bool load_kernels(Progress &progress);
};

template<> PointLight *Scene::create_node<PointLight>();
template<> SpotLight *Scene::create_node<SpotLight>();
template<> AreaLight *Scene::create_node<AreaLight>();
template<> SunLight *Scene::create_node<SunLight>();
template<> BackgroundLight *Scene::create_node<BackgroundLight>();
template<> Mesh *Scene::create_node<Mesh>();
template<> Object *Scene::create_node<Object>();
template<> Hair *Scene::create_node<Hair>();
template<> Volume *Scene::create_node<Volume>();
template<> PointCloud *Scene::create_node<PointCloud>();
template<> ParticleSystem *Scene::create_node<ParticleSystem>();
template<> Shader *Scene::create_node<Shader>();
template<> Pass *Scene::create_node<Pass>();
template<> Camera *Scene::create_node<Camera>();
template<> Background *Scene::create_node<Background>();
template<> Film *Scene::create_node<Film>();
template<> Integrator *Scene::create_node<Integrator>();
template<> SceneAttributes *Scene::create_node<SceneAttributes>();

template<> void Scene::delete_node(Light *node);
template<> void Scene::delete_node(Mesh *node);
template<> void Scene::delete_node(Volume *node);
template<> void Scene::delete_node(PointCloud *node);
template<> void Scene::delete_node(Hair *node);
template<> void Scene::delete_node(Geometry *node);
template<> void Scene::delete_node(Object *node);
template<> void Scene::delete_node(ParticleSystem *node);
template<> void Scene::delete_node(Shader *node);
template<> void Scene::delete_node(Procedural *node);
template<> void Scene::delete_node(Pass *node);

template<> void Scene::delete_nodes(const set<Geometry *> &nodes, const NodeOwner *owner);
template<> void Scene::delete_nodes(const set<Object *> &nodes, const NodeOwner *owner);
template<> void Scene::delete_nodes(const set<ParticleSystem *> &nodes, const NodeOwner *owner);
template<> void Scene::delete_nodes(const set<Shader *> &nodes, const NodeOwner *owner);
template<> void Scene::delete_nodes(const set<Procedural *> &nodes, const NodeOwner *owner);
template<> void Scene::delete_nodes(const set<Pass *> &nodes, const NodeOwner *owner);

CCL_NAMESPACE_END